public void TestThat_YamlCanBeLoadedIntoModel()
{
var key = JsonPasswordCrypto.GenerateKey(256);
var serializer = new ConfigYamlSerializer(new YamlConfigCrypto(key));
var condepConfig = serializer.DeSerialize(_yml);
}
private static void EncryptTaggedValue(JsonPasswordCrypto cryptoHandler, dynamic valueToEncrypt)
{
var value = valueToEncrypt.encrypt.Value;
var encryptedValue = cryptoHandler.Encrypt(value);
valueToEncrypt.Replace(JObject.FromObject(encryptedValue));
}
public void TestThatEncryptedJsonCanBeDecryptedIntoTypedConfig()
{
var parser = new EnvConfigParser();
dynamic config;
parser.Encrypted(_json, out config);
string deploymentPassword = config.DeploymentUser.Password;
string lbPassword = config.LoadBalancer.Password;
var key = JsonPasswordCrypto.GenerateKey(256);
var crypto = new JsonPasswordCrypto(key);
parser.EncryptJsonConfig(config, crypto);
var encryptedJson = parser.ConvertToJsonText(config);
Assert.That(parser.Encrypted(encryptedJson, out config), Is.True);
using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(encryptedJson)))
{
var decryptedConfig = parser.GetTypedEnvConfig(memStream, key);
Assert.That(decryptedConfig.DeploymentUser.Password, Is.EqualTo(deploymentPassword));
Assert.That(decryptedConfig.LoadBalancer.Password, Is.EqualTo(lbPassword));
}
}
private static void DecryptYamlValue(JsonPasswordCrypto cryptoHandler, YamlEncryptedNode encryptedNode)
{
var decryptedValue = cryptoHandler.Decrypt(encryptedNode.EncryptedValue);
encryptedNode.Parent.Children.Remove(encryptedNode.Container);
encryptedNode.Parent.Add(encryptedNode.Container.Key, decryptedValue);
}
private static void EncryptJsonValue(JsonPasswordCrypto cryptoHandler, JValue valueToEncrypt)
{
var value = valueToEncrypt.Value <string>();
var encryptedValue = cryptoHandler.Encrypt(value);
valueToEncrypt.Replace(JObject.FromObject(encryptedValue));
}
private static void DecryptJsonValue(JsonPasswordCrypto cryptoHandler, dynamic originalValue)
{
var valueToDecrypt = new EncryptedValue(originalValue.IV.Value, originalValue.Value.Value);
var decryptedValue = cryptoHandler.Decrypt(valueToDecrypt);
JObject valueToReplace = originalValue;
valueToReplace.Replace(decryptedValue);
}
public void TestThat_CanEncryptYaml()
{
var key = JsonPasswordCrypto.GenerateKey(256);
var crypto = new YamlConfigCrypto(key);
var encryptedYml = crypto.Encrypt(_yml);
Assert.That(crypto.IsEncrypted(encryptedYml));
}
public void Setup()
{
var memStream = new MemoryStream(Encoding.UTF8.GetBytes(_json));
var tiersMemStream = new MemoryStream(Encoding.UTF8.GetBytes(_tiersJson));
_cryptoKey = JsonPasswordCrypto.GenerateKey(256);
var parser = new EnvConfigParser(new ConfigJsonSerializer(new JsonConfigCrypto(_cryptoKey)));
_config = parser.GetTypedEnvConfig(memStream, null);
_tiersConfig = parser.GetTypedEnvConfig(tiersMemStream, null);
}
public void TestThat_CanEncryptTaggedForEncryption()
{
string yml = @"SomeKey : Administrator
SomeSensitiveKey : !!encrypt SomeSensitiveValue";
var key = JsonPasswordCrypto.GenerateKey(256);
var crypto = new YamlConfigCrypto(key);
var encryptedYml = crypto.Encrypt(yml);
Assert.That(crypto.IsEncrypted(encryptedYml));
}
public void TestThat_CanEncryptPassword()
{
string yml = @"UserName : Administrator
Password : !!encrypt SomePassword";
var key = JsonPasswordCrypto.GenerateKey(256);
var crypto = new YamlConfigCrypto(key);
var encryptedYml = crypto.Encrypt(yml);
Assert.That(crypto.IsEncrypted(encryptedYml));
}
private static void ValidateCryptoKey(ConDepOptions options)
{
if (string.IsNullOrWhiteSpace(options.CryptoKey))
{
return;
}
if (!JsonPasswordCrypto.ValidKey(options.CryptoKey))
{
throw new ConDepCmdParseException(
"Decryption key not valid. Key must be base64 encoded and 128, 192 or 256 bits long.");
}
}
public void EncryptJsonConfig(dynamic config, JsonPasswordCrypto crypto)
{
((JObject)config).FindTaggedTokens("encrypt")
.ForEach(x => EncryptTaggedValue(crypto, x));
var passwordTokens = ((JObject)config).SelectTokens("$..Password").OfType <JValue>().ToList();
foreach (var token in passwordTokens)
{
EncryptJsonValue(crypto, token);
}
}
public void EncryptFile(string file, JsonPasswordCrypto crypto)
{
var json = GetConDepConfigAsJsonText(file);
dynamic config;
if (Encrypted(json, out config))
{
throw new ConDepCryptoException(string.Format("File [{0}] already encrypted.", file));
}
EncryptJsonConfig(config, crypto);
UpdateConfig(file, config);
}
public void DecryptFile(string file, JsonPasswordCrypto crypto)
{
var json = GetConDepConfigAsJsonText(file);
dynamic config;
if (!Encrypted(json, out config))
{
throw new ConDepCryptoException("Unable to decrypt. No content in file [{0}] is encrypted.");
}
DecryptJsonConfig(config, crypto);
UpdateConfig(file, config);
}
public override void Validate(ConDepDecryptOptions options)
{
if (string.IsNullOrWhiteSpace(options.Key))
{
throw new ConDepValidationException("Decryption key not provided.");
}
if (!JsonPasswordCrypto.ValidKey(options.Key))
{
throw new ConDepCmdParseException(
"Decryption key not valid. Key must be base64 encoded and 128, 192 or 256 bits long.");
}
}
private static void EncryptTaggedValue(JsonPasswordCrypto cryptoHandler, KeyValuePair <YamlMappingNode, YamlNode> containerKeyPair)
{
var container = containerKeyPair.Key;
var key = containerKeyPair.Value;
var value = container.Children[key].ToString();
var encryptedValue = cryptoHandler.Encrypt(value);
container.Children.Remove(key);
var serializer = new Serializer();
using (var writer = new StringWriter())
{
serializer.Serialize(writer, encryptedValue);
var stream = new YamlStream();
stream.Load(new StringReader(writer.ToString()));
stream.Documents[0].RootNode.Tag = "tag:yaml.org,2002:encrypted";
container.Add(key, stream.Documents[0].RootNode);
}
}
public void TestThatEncryptTagGetsEncrypted()
{
var parser = new EnvConfigParser();
dynamic config;
parser.Encrypted(_encryptJson, out config);
var key = JsonPasswordCrypto.GenerateKey(256);
var crypto = new JsonPasswordCrypto(key);
parser.EncryptJsonConfig(config, crypto);
var encryptedJson = parser.ConvertToJsonText(config);
//Assert.That(parser.Encrypted(encryptedJson, out config), Is.True);
//using (var memStream = new MemoryStream(Encoding.UTF8.GetBytes(encryptedJson)))
//{
// var decryptedConfig = parser.GetTypedEnvConfig(memStream, key);
// Assert.That(decryptedConfig.DeploymentUser.Password, Is.EqualTo(password));
//}
}
public void DecryptJsonConfig(dynamic config, JsonPasswordCrypto crypto)
{
((JObject)config).FindEncryptedTokens()
.ForEach(x => DecryptJsonValue(crypto, x));
}
public ConDepEnvConfig GetTypedEnvConfig(Stream stream, string cryptoKey)
{
ConDepEnvConfig config;
using (var memStream = GetMemoryStreamWithCorrectEncoding(stream))
{
using (var reader = new StreamReader(memStream))
{
var json = reader.ReadToEnd();
dynamic jsonModel;
if (Encrypted(json, out jsonModel))
{
if (string.IsNullOrWhiteSpace(cryptoKey))
{
throw new ConDepCryptoException(
"ConDep configuration is encrypted, so a decryption key is needed. Specify using -k switch.");
}
var crypto = new JsonPasswordCrypto(cryptoKey);
DecryptJsonConfig(jsonModel, crypto);
config = ((JObject)jsonModel).ToObject <ConDepEnvConfig>();
}
else
{
config = JsonConvert.DeserializeObject <ConDepEnvConfig>(json, JsonSettings);
}
}
}
if (config.Servers != null && config.Tiers != null)
{
throw new ConDepConfigurationException(
"You cannot define both Tiers and Servers at the same level. Either you use Tiers and define servers for each tier or you use Servers without Tiers. Servers without Tiers would be the same as having just one Tier.");
}
if (config.Servers == null)
{
config.Servers = new List <ServerConfig>();
}
if (config.Node.Port == null)
{
config.Node.Port = 4444;
}
if (config.Node.TimeoutInSeconds == null)
{
config.Node.TimeoutInSeconds = 100;
}
if (config.PowerShell.HttpPort == null)
{
config.PowerShell.HttpPort = 5985;
}
if (config.PowerShell.HttpsPort == null)
{
config.PowerShell.HttpsPort = 5986;
}
foreach (var server in config.Servers)
{
if (server.Node == null)
{
server.Node = config.Node;
}
if (server.PowerShell == null)
{
server.PowerShell = config.PowerShell;
}
if (server.Node.Port == null)
{
server.Node.Port = config.Node.Port;
}
if (server.Node.TimeoutInSeconds == null)
{
server.Node.TimeoutInSeconds = config.Node.TimeoutInSeconds;
}
if (server.PowerShell.HttpPort == null)
{
server.PowerShell.HttpPort = config.PowerShell.HttpPort;
}
if (server.PowerShell.HttpsPort == null)
{
server.PowerShell.HttpsPort = config.PowerShell.HttpsPort;
}
}
if (config.Tiers == null)
{
foreach (var server in config.Servers.Where(server => !server.DeploymentUser.IsDefined()))
{
server.DeploymentUser = config.DeploymentUser;
}
}
else
{
foreach (var server in config.Tiers.SelectMany(tier => tier.Servers.Where(server => !server.DeploymentUser.IsDefined())))
{
server.DeploymentUser = config.DeploymentUser;
}
}
return(config);
}
public JsonConfigCrypto(string key)
{
_valueHandler = new JsonPasswordCrypto(key);
}
private static string GetKey(ConDepEncryptOptions options)
{
return(string.IsNullOrWhiteSpace(options.Key) ? JsonPasswordCrypto.GenerateKey(256) : options.Key);
}
