361 lines
10 KiB
C#
361 lines
10 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
|
|
using Mono.Options;
|
|
using Mono.Configuration.Crypto;
|
|
|
|
[assembly: AssemblyTitle ("mono-configuration-crypto")]
|
|
[assembly: AssemblyDescription ("Mono configuration utility to manage encryption keys and encrypt/decrypt config file sections")]
|
|
[assembly: AssemblyCompany (Consts.MonoCompany)]
|
|
[assembly: AssemblyProduct ("Mono Configuration Cryptography Tools")]
|
|
[assembly: AssemblyCopyright ("Copyright (c) 2010 Novell, Inc (http://novell.com, http://mono-project.com/)")]
|
|
[assembly: AssemblyVersion (Consts.FxVersion)]
|
|
|
|
namespace MonoConfigurationCrypto
|
|
{
|
|
class MonoConfigurationCrypto
|
|
{
|
|
void Success ()
|
|
{
|
|
Console.WriteLine ("Success.");
|
|
}
|
|
|
|
void Failure (Exception ex, Config cfg)
|
|
{
|
|
Failure (ex, cfg, null);
|
|
}
|
|
|
|
void Failure (Config cfg, string message, params object[] parms)
|
|
{
|
|
Failure (null, cfg, message, parms);
|
|
}
|
|
|
|
void Failure (Exception ex, Config cfg, string message, params object[] parms)
|
|
{
|
|
if (!String.IsNullOrEmpty (message)) {
|
|
if (parms == null || parms.Length == 0)
|
|
Console.Error.WriteLine (message);
|
|
else
|
|
Console.Error.WriteLine (message, parms);
|
|
}
|
|
|
|
if (ex != null) {
|
|
if (cfg.Verbose)
|
|
Console.Error.WriteLine (ex.ToString ());
|
|
else
|
|
Console.Error.WriteLine (ex.Message);
|
|
}
|
|
Console.Error.WriteLine ("Failure.");
|
|
}
|
|
|
|
bool ListContainers (Config cfg)
|
|
{
|
|
try {
|
|
var kc = new KeyContainerCollection (cfg.UseMachinePath);
|
|
int count;
|
|
foreach (KeyContainer c in kc) {
|
|
count = c.Count;
|
|
Console.WriteLine ("{0} container '{1}' ({2} key{3})", c.Local ? "Local" : "Global", c.Name, count,
|
|
count == 1 ? String.Empty : "s");
|
|
}
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
string FindConfigFile (string path, string configFileName)
|
|
{
|
|
if (!Directory.Exists (path))
|
|
return null;
|
|
|
|
string fileName = null;
|
|
foreach (var s in Directory.GetFiles (path, "*.*", SearchOption.TopDirectoryOnly)) {
|
|
string fn = Path.GetFileName (s);
|
|
if (String.Compare (fn, configFileName, StringComparison.OrdinalIgnoreCase) == 0) {
|
|
fileName = fn;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (fileName == null)
|
|
return null;
|
|
|
|
return Path.Combine (path, fileName);
|
|
}
|
|
|
|
bool EncryptSection (Config cfg)
|
|
{
|
|
string configSection = cfg.ConfigSectionName;
|
|
string containerName = cfg.ContainerName;
|
|
string configFile = FindConfigFile (cfg.ApplicationPhysicalPath, cfg.ConfigFileName);
|
|
|
|
Console.WriteLine ("Encrypting section '{0}' in config file '{1}' using key container '{2}'...", configSection, configFile, containerName);
|
|
|
|
if (String.IsNullOrEmpty (configFile)) {
|
|
Failure (cfg, "No config file found in directory '{0}'", cfg.ApplicationPhysicalPath);
|
|
return true;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty (configSection)) {
|
|
Failure (cfg, "No config section name specified.");
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
var cs = new ConfigSection ();
|
|
cs.Encrypt (configFile, configSection, containerName, cfg.UseMachinePath);
|
|
Console.WriteLine ("Success.");
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool DecryptSection (Config cfg)
|
|
{
|
|
string configSection = cfg.ConfigSectionName;
|
|
string containerName = cfg.ContainerName;
|
|
string configFile = FindConfigFile (cfg.ApplicationPhysicalPath, cfg.ConfigFileName);
|
|
|
|
Console.WriteLine ("Decrypting section '{0}' in config file '{1}' using key container '{2}'...", configSection, configFile, containerName);
|
|
|
|
if (String.IsNullOrEmpty (configFile)) {
|
|
Failure (cfg, "No config file found in directory '{0}'", cfg.ApplicationPhysicalPath);
|
|
return true;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty (configSection)) {
|
|
Failure (cfg, "No config section name specified.");
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
var cs = new ConfigSection ();
|
|
cs.Decrypt (configFile, configSection, containerName, cfg.UseMachinePath);
|
|
Console.WriteLine ("Success.");
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CreateKey (Config cfg)
|
|
{
|
|
string name = cfg.ContainerName;
|
|
KeyContainerCollection kc;
|
|
|
|
Console.WriteLine ("Creating RSA key container '{0}'...", name);
|
|
try {
|
|
kc = new KeyContainerCollection (cfg.UseMachinePath);
|
|
if (kc.Contains (name)) {
|
|
Failure (cfg, "The RSA container already exists.");
|
|
return true;
|
|
}
|
|
|
|
var k = new Key (name, cfg.KeySize, cfg.UseMachinePath);
|
|
if (!k.IsValid) {
|
|
Failure (cfg, "Failed to generate RSA key pair.");
|
|
return true;
|
|
}
|
|
k.Save ();
|
|
Success ();
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ImportKey (Config cfg)
|
|
{
|
|
string containerName = cfg.ContainerName;
|
|
string fileName = cfg.FileName;
|
|
|
|
Console.WriteLine ("Importing an RSA key from file '{0}' into the container '{1}'...", fileName, containerName);
|
|
if (String.IsNullOrEmpty (containerName)) {
|
|
Failure (cfg, "Unspecified container name.");
|
|
return true;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty (fileName)) {
|
|
Failure (cfg, "Unspecified file name.");
|
|
return true;
|
|
}
|
|
|
|
if (!File.Exists (fileName)) {
|
|
Failure (cfg, "Key file '{0}' does not exist.", fileName);
|
|
return true;
|
|
}
|
|
|
|
KeyContainerCollection kcc;
|
|
Key key;
|
|
KeyContainer kc;
|
|
try {
|
|
kcc = new KeyContainerCollection (cfg.UseMachinePath);
|
|
kc = kcc [containerName];
|
|
|
|
if (kc != null)
|
|
key = kc [0];
|
|
else
|
|
key = null;
|
|
|
|
// No validation is performed on the key - this is left for the
|
|
// encryption algorithm implementation to do.
|
|
string keyvalue = File.ReadAllText (fileName);
|
|
if (key == null)
|
|
key = new Key (containerName, keyvalue, cfg.UseMachinePath);
|
|
else {
|
|
key.KeyValue = keyvalue;
|
|
key.ContainerName = containerName;
|
|
}
|
|
|
|
key.Save ();
|
|
Console.WriteLine ("Success.");
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool ExportKey (Config cfg)
|
|
{
|
|
string containerName = cfg.ContainerName;
|
|
string fileName = cfg.FileName;
|
|
|
|
Console.WriteLine ("Exporting an RSA key from container '{0}' to file '{1}'...", containerName, fileName);
|
|
if (String.IsNullOrEmpty (containerName)) {
|
|
Failure (cfg, "Unspecified container name.");
|
|
return true;
|
|
}
|
|
|
|
if (String.IsNullOrEmpty (fileName)) {
|
|
Failure (cfg, "Unspecified file name.");
|
|
return true;
|
|
}
|
|
|
|
KeyContainerCollection kcc;
|
|
Key key;
|
|
KeyContainer kc;
|
|
try {
|
|
kcc = new KeyContainerCollection (cfg.UseMachinePath);
|
|
kc = kcc [containerName];
|
|
|
|
if (kc != null)
|
|
key = kc [0];
|
|
else {
|
|
Failure (cfg, "Container '{0}' does not exist.", containerName);
|
|
return true;
|
|
}
|
|
|
|
if (key == null) {
|
|
Failure (cfg, "Container '{0}' exists but it does not contain any keys.", containerName);
|
|
return true;
|
|
}
|
|
|
|
File.WriteAllText (fileName, key.KeyValue);
|
|
Console.WriteLine ("Success.");
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool RemoveContainer (Config cfg)
|
|
{
|
|
string containerName = cfg.ContainerName;
|
|
Console.WriteLine ("Removing container '{0}'...", containerName);
|
|
if (String.IsNullOrEmpty (containerName)) {
|
|
Failure (cfg, "Unspecified container name.");
|
|
return true;
|
|
}
|
|
|
|
try {
|
|
KeyContainer.RemoveFromDisk (containerName, cfg.UseMachinePath);
|
|
|
|
Console.WriteLine ("Success.");
|
|
} catch (Exception ex) {
|
|
Failure (ex, cfg);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ShowHeader ()
|
|
{
|
|
string title = String.Empty, version = String.Empty, description = String.Empty, copyright = String.Empty;
|
|
Assembly asm = Assembly.GetExecutingAssembly ();
|
|
foreach (object o in asm.GetCustomAttributes (false)) {
|
|
if (o is AssemblyTitleAttribute)
|
|
title = ((AssemblyTitleAttribute)o).Title;
|
|
else if (o is AssemblyCopyrightAttribute)
|
|
copyright = ((AssemblyCopyrightAttribute)o).Copyright;
|
|
else if (o is AssemblyDescriptionAttribute)
|
|
description = ((AssemblyDescriptionAttribute)o).Description;
|
|
}
|
|
|
|
version = asm.GetName ().Version.ToString ();
|
|
|
|
Console.WriteLine ("{1} - version {2}{0}{3}{0}{4}{0}",
|
|
Environment.NewLine,
|
|
title,
|
|
version,
|
|
description,
|
|
copyright);
|
|
}
|
|
|
|
void Run (string[] args)
|
|
{
|
|
var cfg = new Config ();
|
|
var actions = new List <Func <Config, bool>> ();
|
|
var options = new OptionSet () {
|
|
{ "h|?|help", "Show usage information", v => cfg.ShowHelp = true },
|
|
{ "v|verbose", "Show verbose information (including exception stacktraces)", v => cfg.Verbose = true },
|
|
{ "m|machine|global", "Use machine (global) store for all the key actions", v => cfg.UseMachinePath = true },
|
|
{ "u|user|local", "Use local (user) store for all the key actions [*]", v => cfg.UseMachinePath = false },
|
|
{ "l|list", "List all the key container names in the store", v => actions.Add (ListContainers) },
|
|
{ "c|create", "Creates an RSA public/private key pair", v => actions.Add (CreateKey) },
|
|
{ "i|import", "Import key to a container", v => actions.Add (ImportKey) },
|
|
{ "x|export", "Export key from a container", v => actions.Add (ExportKey) },
|
|
{ "r|remove", "Remove a container", v => actions.Add (RemoveContainer) },
|
|
{ "f=|file=", "File name for import or export operations", (string s) => cfg.FileName = s },
|
|
{ "cf=|config-file=", String.Format ("Config file name (not path) [{0}]", Config.DefaultConfigFileName), (string s) => cfg.ConfigFileName = s },
|
|
{ "n=|name=", String.Format ("Container name [{0}]", Config.DefaultContainerName), (string s) => cfg.ContainerName = s },
|
|
{ "s=|size=", String.Format ("Key size [{0}]", Config.DefaultKeySize), (uint s) => cfg.KeySize = s },
|
|
{ "p=|path=", String.Format ("Application physical path [{0}]", Config.DefaultApplicationPhysicalPath), (string s) => cfg.ApplicationPhysicalPath = s },
|
|
{ "d=|dec=|decrypt=", "Decrypt configuration section", (string s) => { cfg.ConfigSectionName = s; actions.Add (DecryptSection);} },
|
|
{ "e=|enc=|encrypt=", "Encrypt configuration section", (string s) => { cfg.ConfigSectionName = s; actions.Add (EncryptSection);} },
|
|
};
|
|
options.Parse (args);
|
|
|
|
if (cfg.ShowHelp) {
|
|
ShowHeader ();
|
|
options.WriteOptionDescriptions (Console.Out);
|
|
return;
|
|
}
|
|
|
|
foreach (var action in actions)
|
|
if (action (cfg))
|
|
Environment.Exit (0);
|
|
}
|
|
|
|
static void Main (string[] args)
|
|
{
|
|
new MonoConfigurationCrypto ().Run (args);
|
|
}
|
|
}
|
|
}
|