public SymetricKey Generate()
{
var symetricKey = new SymetricKey();
SymmetricAlgorithm algorithm = new AesManaged();
symetricKey.Key = algorithm.Key;
symetricKey.Salt = algorithm.IV;
return(symetricKey);
}
public void SymetricKeySerializationTest()
{
Random random = new Random();
SymetricKey key1 = new SymetricKey();
key1.Iv = new byte[16];
key1.Key = new byte[24];
random.NextBytes(key1.Iv);
random.NextBytes(key1.Key);
var stream = key1.ToStream();
SymetricKey key2 = new SymetricKey(stream);
Assert.True(key1.Iv.SequenceEqual(key2.Iv));
Assert.True(key1.Key.SequenceEqual(key2.Key));
}
public byte[] Decrypt(byte[] encryptedMessage, SymetricKey symetricKey)
{
SymmetricAlgorithm algorithm = Aes.Create();
algorithm.Key = symetricKey.Key;
algorithm.IV = symetricKey.Salt;
algorithm.Mode = Mode;
ICryptoTransform transform = algorithm.CreateDecryptor(symetricKey.Key, symetricKey.Salt);
using MemoryStream buffer = new(encryptedMessage);
using CryptoStream stream = new(buffer, transform, CryptoStreamMode.Read);
using MemoryStream mo = new();
stream.CopyTo(mo);
mo.Position = 0;
return(mo.ToArray());
}
public void NC_ISymetric_Encrypt_And_Decrypt_WithGreaterThan16Bytes()
{
SymetricKey SymetricKey = new SymetricKey();
SymetricKey.Key = Encoding.ASCII.GetBytes("MyPasswordMyPassword");
string sText = "Encriptando texto.";
byte[] aText = Encoding.ASCII.GetBytes(sText);
var aEncryptedText = this.ISymetric.Encrypt(aText, SymetricKey);
var aUnencryptedText = this.ISymetric.Decrypt(aEncryptedText, SymetricKey);
string unencryptedText = Encoding.ASCII.GetString(aUnencryptedText);
Assert.AreEqual(sText, unencryptedText);
}
public void NF_ISymetric_Encrypt_And_Decrypt_WithLessOf16Bytes()
{
SymetricKey SymetricKey = new SymetricKey()
{
Key = Encoding.ASCII.GetBytes("MyPassword")
};
string sText = "Encriptando texto.";
byte[] aText = Encoding.ASCII.GetBytes(sText);
var aEncryptedText = this.ISymetric.Encrypt(aText, SymetricKey);
var aUnencryptedText = this.ISymetric.Decrypt(aEncryptedText, SymetricKey);
string sUnencryptedText = Encoding.ASCII.GetString(aUnencryptedText);
Assert.AreEqual(sText, sUnencryptedText);
}
public void NC_ISymetric_Encrypt_And_Decrypt()
{
SymetricKey SymetricKey = new SymetricKey();
var aes = Aes.Create();
SymetricKey.Key = aes.Key;
SymetricKey.Salt = aes.IV;
string sText = "Encriptando texto con llave aleatoria.";
byte[] aText = Encoding.ASCII.GetBytes(sText);
var aEncryptedText = this.ISymetric.Encrypt(aText, SymetricKey);
var aUnencryptedText = this.ISymetric.Decrypt(aEncryptedText, SymetricKey);
string sUnencryptedText = Encoding.ASCII.GetString(aUnencryptedText);
Assert.AreEqual(sText, sUnencryptedText);
}
public void NF_ISymetric_Encrypt_And_Decrypt()
{
SymetricKey symetricKey = new SymetricKey();
AesManaged aes = new AesManaged();
symetricKey.Key = aes.Key;
symetricKey.Salt = aes.IV;
string text = "Encriptando texto con llave aleatoria.";
byte[] aText = Encoding.ASCII.GetBytes(text);
var aEncryptedText = this.ISymetric.Encrypt(aText, symetricKey);
var aUnencryptedText = this.ISymetric.Decrypt(aEncryptedText, symetricKey);
string sUnencryptedText = Encoding.ASCII.GetString(aUnencryptedText);
Assert.AreEqual(text, sUnencryptedText);
}
//T could be:
// AesManaged
// TripleDESCryptoServiceProvider
// RijndaelManaged
public byte[] Encrypt <T>(byte[] aNoEncryptedMessage, SymetricKey SymetricKey)
where T : SymmetricAlgorithm, new()
{
SymmetricAlgorithm algorithm = new T();
algorithm.Key = SymetricKey.Key;
algorithm.IV = SymetricKey.Salt;
algorithm.Mode = this.Mode;
//algorithm.Padding = PaddingMode.PKCS7;
ICryptoTransform transform = algorithm.CreateEncryptor(SymetricKey.Key, SymetricKey.Salt);
using (MemoryStream buffer = new MemoryStream())
{
using (CryptoStream stream = new CryptoStream(buffer, transform, CryptoStreamMode.Write))
{
stream.Write(aNoEncryptedMessage, 0, aNoEncryptedMessage.Length);
}
return(buffer.ToArray());
}
}
//T could be:
// AesManaged
// TripleDESCryptoServiceProvider
// RijndaelManaged
public byte[] Encrypt(byte[] noEncryptedMessage, SymetricKey symetricKey)
{
SymmetricAlgorithm algorithm = Aes.Create();
algorithm.Key = symetricKey.Key;
algorithm.IV = symetricKey.Salt;
algorithm.Mode = Mode;
//algorithm.Padding = PaddingMode.PKCS7;
ICryptoTransform transform = algorithm.CreateEncryptor(symetricKey.Key, symetricKey.Salt);
using (MemoryStream buffer = new())
{
using (CryptoStream stream = new(buffer, transform, CryptoStreamMode.Write))
{
stream.Write(noEncryptedMessage, 0, noEncryptedMessage.Length);
stream.FlushFinalBlock();//Error:https://stackoverflow.com/a/40564155
}
return(buffer.ToArray());
}
}
private void ReceivingEncryptedMessage(IAsymetricCrypt asymetricCrypt)
{
//Receiving the rest of header.
int iSymetricLength = BitHelper.ToInt32(littleBuffer, HEADER_TYPE_3_SYMKEY_LENGTH_OFFSET);//Length of message
int iBodyLength = BitHelper.ToInt32(littleBuffer, HEADER_TYPE_3_BODY_LENGTH_OFFSET);
ValidatingMaxOfSizeToReceive(iSymetricLength, "Symetric Key Length");
ValidatingMaxOfSizeToReceive(iBodyLength, "Body Length");
//Saving encrypted symetric key in little buffer.
this.ReceiveAll(littleBuffer, iSymetricLength);
//Saving encrypted body in dynamic buffer.
var aDinamicBuffer = new byte[iBodyLength];//Ugly new if is big data
this.ReceiveAll(aDinamicBuffer, iBodyLength);
#region For Debuging
#if DEBUG
//byte[] header = new byte[4 + 4 + 4];
//header[HEADER_TYPE_OFFSET] = TYPE_MESSAGE;
//ByteHelper.UIntToByte(header, HEADER_TYPE_3_SYMKEY_LENGTH_OFFSET, (uint)iSymetricLength);
//ByteHelper.UIntToByte(header, HEADER_TYPE_3_BODY_LENGTH_OFFSET, (uint)iBodyLength);
//var aReceivedHash = hash.Generate(new ByteArray(header.Concat(aLittleBuffer.Take(iSymetricLength).ToArray()).Concat(aDinamicBuffer).ToArray()));
//this.logger.Debug($"Receiving Message Hash \"{BitConverter.ToString(aReceivedHash)}\", BodyLenth={iBodyLength}");
//var aPUBKEYToDecrypt = this.hash.Generate(new ByteArray(this.serializeT.Serialize(asymetricCrypt.GetPublicKey())));
//this.logger.Debug($"PUBKEY to decrypt the message {BitConverter.ToString(aPUBKEYToDecrypt)}");
#endif
#endregion
//SymetricKey Decrypting and deserialization
byte[] aSymetricKey = asymetricCrypt.Decrypt(littleBuffer.Take(iSymetricLength).ToArray());
SymetricKey symetricKey = this.serializeT.Deserialize <SymetricKey>(aSymetricKey);
//Decrypting and Decrompres and deserialization of Body with symetric key
var aDecryptedMessageCompressed = this.symetric.Decrypt(aDinamicBuffer.Take(iBodyLength).ToArray(), symetricKey);
aDecryptedMessage = this.compression.Decrompress(new ByteArray(aDecryptedMessageCompressed));
aDinamicBuffer = null;
}
public byte[] Decrypt <T>(byte[] aEncryptedMessage, SymetricKey SymetricKey)
where T : SymmetricAlgorithm, new()
{
DeriveBytes rgb = new Rfc2898DeriveBytes(SymetricKey.Key, SymetricKey.Salt, SymetricKey.Iteration);
SymmetricAlgorithm algorithm = new T();
algorithm.Key = SymetricKey.Key;
algorithm.IV = SymetricKey.Salt;
algorithm.Mode = this.Mode;
//algorithm.Padding = PaddingMode.PKCS7;
ICryptoTransform transform = algorithm.CreateDecryptor(SymetricKey.Key, SymetricKey.Salt);
using (MemoryStream buffer = new MemoryStream(aEncryptedMessage))
using (CryptoStream stream = new CryptoStream(buffer, transform, CryptoStreamMode.Read))
using (MemoryStream mo = new MemoryStream())
{
stream.CopyTo(mo);
mo.Position = 0;
return(mo.ToArray());
}
}
public byte[] Decrypt(byte[] aEncryptedMessage, SymetricKey SymetricKey)
{
return(Decrypt <AesManaged>(aEncryptedMessage, SymetricKey));
}
public byte[] Encrypt(byte[] aNoEncryptedMessage, SymetricKey SymetricKey)
{
return(Encrypt <AesManaged>(aNoEncryptedMessage, SymetricKey));
}
//internal static bool TryEncryptStream(Stream inputStream, Stream outputStream, out SymetricKey symenticKey)
//{
// using (AesManaged aes = new AesManaged())
// {
// symenticKey = new SymetricKey();
// try
// {
// aes.GenerateIV();
// aes.GenerateKey();
// symenticKey.Iv = aes.IV;
// symenticKey.Key = aes.Key;
// string tempFile = Path.GetTempFileName();
// FileStream tempWriteFileStream = new FileStream(tempFile, FileMode.Create);
// CryptoStream cryptoStream = new CryptoStream(tempWriteFileStream, aes.CreateEncryptor(),
// CryptoStreamMode.Write);
// inputStream.CopyTo(cryptoStream);
// cryptoStream.FlushFinalBlock();
// cryptoStream.Close();
// tempWriteFileStream.Close();
// using (var tempReadFileStream = new FileStream(tempFile, FileMode.Open))
// {
// tempReadFileStream.CopyTo(outputStream);
// outputStream.Position = 0;
// }
// return true;
// }
// catch (Exception)
// {
// return false;
// }
// }
//}
internal static bool TryEncryptStream(Stream inputStream, Stream outputStream, out SymetricKey symenticKey)
{
using (AesManaged aes = new AesManaged())
{
symenticKey = new SymetricKey();
try
{
aes.GenerateIV();
aes.GenerateKey();
symenticKey.Iv = aes.IV;
symenticKey.Key = aes.Key;
CryptoStream cryptoStream = new CryptoStream(outputStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
inputStream.CopyTo(cryptoStream);
cryptoStream.FlushFinalBlock();
outputStream.Position = 0;
return true;
}
catch (Exception)
{
return false;
}
}
}
//internal static bool TryDecryptStream(Stream inputStream, Stream outputStream, SymetricKey symenticKey)
//{
// using (AesManaged aes = new AesManaged())
// {
// try
// {
// aes.IV = symenticKey.Iv;
// aes.Key = symenticKey.Key;
// string tempFile = Path.GetTempFileName();
// FileStream tempWriteFileStream = new FileStream(tempFile, FileMode.Create);
// CryptoStream cryptoStream = new CryptoStream(tempWriteFileStream, aes.CreateDecryptor(),
// CryptoStreamMode.Write);
// inputStream.CopyTo(cryptoStream);
// cryptoStream.FlushFinalBlock();
// cryptoStream.Clear();
// tempWriteFileStream.Close();
// using (var tempReadFileStream = new FileStream(tempFile, FileMode.Open))
// {
// tempReadFileStream.CopyTo(outputStream);
// outputStream.Position = 0;
// }
// return true;
// }
// catch (Exception)
// {
// return false;
// }
// }
//}
internal static bool TryDecryptStream(Stream inputStream, Stream outputStream, SymetricKey symenticKey)
{
using (AesManaged aes = new AesManaged())
{
try
{
aes.IV = symenticKey.Iv;
aes.Key = symenticKey.Key;
CryptoStream cryptoStream = new CryptoStream(outputStream, aes.CreateDecryptor(), CryptoStreamMode.Write);
inputStream.CopyTo(cryptoStream);
cryptoStream.FlushFinalBlock();
outputStream.Position = 0;
return true;
}
catch (Exception ex)
{
return false;
}
}
}
