static Boolean TestKnownEnc(Aes aes, Byte[] Key, Byte[] IV, Byte[] Plain, Byte[] Cipher)
{
Byte[] CipherCalculated;
Console.WriteLine("Encrypting the following bytes:");
PrintByteArray(Plain);
Console.WriteLine("With the following Key:");
PrintByteArray(Key);
Console.WriteLine("and IV:");
PrintByteArray(IV);
Console.WriteLine("Expecting this ciphertext:");
PrintByteArray(Cipher);
ICryptoTransform sse = aes.CreateEncryptor(Key, IV);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write);
cs.Write(Plain,0,Plain.Length);
cs.FlushFinalBlock();
CipherCalculated = ms.ToArray();
cs.Close();
Console.WriteLine("Computed this cyphertext:");
PrintByteArray(CipherCalculated);
if (!Compare(Cipher, CipherCalculated)) {
Console.WriteLine("ERROR: result is different from the expected");
return false;
}
Console.WriteLine("OK");
return true;
}
public static string EncryptString(string key, string plainText)
{
byte[] iv = new byte[16];
byte[] array;
using (Aes aes = System.Security.Cryptography.Aes.Create())
{
aes.Key = Encoding.UTF8.GetBytes(key);
aes.IV = iv;
ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream((Stream)memoryStream, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter streamWriter = new StreamWriter((Stream)cryptoStream))
{
streamWriter.Write(plainText);
}
array = memoryStream.ToArray();
}
}
}
return(Convert.ToBase64String(array));
}
/// <summary>
/// Encrypts a string
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public byte[] EncryptToBytes(string value)
{
byte[] output = null;
ICryptoTransform et = _cryptor.CreateEncryptor(_cryptor.Key, _cryptor.IV);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, et, CryptoStreamMode.Write))
{
using (StreamWriter sw = new StreamWriter(cs, this._encoding, this._padding))
{
sw.Write(value);
sw.Flush();
}
cs.Flush();
output = ms.ToArray();
}
ms.Flush();
ms.Dispose();
}
et.Dispose();
et = null;
return(output);
}
internal void ProcessEncryption(crypto.Aes cipher, CommandLine commandLine)
{
var key = new Rfc2898DeriveBytes(commandLine.Password, commandLine.KeySaltLength, commandLine.KeyIterations);
cipher.GenerateIV();
cipher.Key = key.GetBytes(cipher.KeySize / 8);
Stream inputStream = CreateInputStream(commandLine);
Stream outputStream = CreateOutputStream(commandLine);
// 2 bytes of version
outputStream.Write(Constants.FormatVersionBytes, 0, Constants.FormatVersionBytes.Length);
// stores 16 bytes of IV
outputStream.Write(cipher.IV, 0, cipher.IV.Length);
// stores 2 bytes of salt size (in network order)
short saltLength = IPAddress.HostToNetworkOrder((short)key.Salt.Length);
byte[] saltLengthBytes = BitConverter.GetBytes(saltLength);
outputStream.Write(saltLengthBytes, 0, saltLengthBytes.Length);
// stores n bytes of salt
outputStream.Write(key.Salt, 0, key.Salt.Length);
using (ICryptoTransform encryptor = cipher.CreateEncryptor())
{
using (Stream cryptoStream = new CryptoStream(outputStream, encryptor, CryptoStreamMode.Write))
inputStream.CopyTo(cryptoStream);
}
}
// Для работы TripleDES требуется вектор инициализации (IV) и ключ (Key)
// Операции шифрования/деширования должны использовать одинаковые значения IV и Key
public void EncryptStream(Stream sourcestream, Stream deststream, string key)
{
byte[] _key = new byte[32];
byte[] _IV = new byte[16];
byte[] myKey = Encoding.ASCII.GetBytes(key);
for (int i = 0; i < _key.Length; i++)
{
_key[i] = 0;
}
for (int i = 0; (i < _key.Length) && (i < myKey.Length); i++)
{
_key[i] = myKey[i];
}
for (int i = 0; (i < _key.Length) && (i < _IV.Length); i++)
{
_IV[i] = _key[i];
}
_IV.Reverse();
System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create();
aes.IV = _IV;
aes.Key = _key;
var decStream = new CryptoStream(sourcestream, aes.CreateEncryptor(), CryptoStreamMode.Read);
deststream.SetLength(0);
decStream.CopyTo(deststream);
}
protected virtual ICryptoTransform CreateTransform(System.Security.Cryptography.Aes aes, byte[] key, byte[] iv, AesMode mode)
{
if (aes == null)
{
throw new ArgumentNullException(nameof(aes));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (iv == null)
{
throw new ArgumentNullException(nameof(iv));
}
switch (mode)
{
case AesMode.Decrypt:
return(aes.CreateDecryptor(key, iv));
case AesMode.Encrypt:
return(aes.CreateEncryptor(key, iv));
default:
throw new ArgumentOutOfRangeException();
}
}
public override void init(int mode, byte[] key, byte[] iv)
{
if (mode != ENCRYPT_MODE && mode != DECRYPT_MODE) throw new ArgumentOutOfRangeException();
ms = new PipedMemoryStream();
aesm = AesManaged.Create();
aesm.BlockSize = blockSize * 8;
aesm.Padding = PaddingMode.None;
ICryptoTransform ict;
if (key.Length > blockSize)
{
byte[] tmp = new byte[blockSize];
Array.Copy(key, 0, tmp, 0, tmp.Length);
key = tmp;
}
if (iv.Length > ivSize)
{
byte[] tmp = new byte[ivSize];
Array.Copy(iv, 0, tmp, 0, tmp.Length);
iv = tmp;
}
if (mode == ENCRYPT_MODE)
{
ict = aesm.CreateEncryptor(key, iv);
}
else
{
ict = aesm.CreateDecryptor(key, iv);
}
cs = new CryptoStream(ms, ict, CryptoStreamMode.Write);
}
private static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
{
byte[] encrypted;
// Create an Aes object
// with the specified key and IV.
using (System.Security.Cryptography.Aes aesAlg = System.Security.Cryptography.Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
// Create a decrytor to perform the stream transform.
System.Security.Cryptography.ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (System.IO.MemoryStream msEncrypt = new System.IO.MemoryStream())
{
using (System.Security.Cryptography.CryptoStream csEncrypt = new System.Security.Cryptography.CryptoStream(
msEncrypt, encryptor, System.Security.Cryptography.CryptoStreamMode.Write))
{
using (System.IO.StreamWriter swEncrypt = new System.IO.StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream.
return(encrypted);
}
/// <summary>
/// Encrypt a message
/// </summary>
/// <param name="messageToEncrypt">The message to be encrypted</param>
/// <param name="secretKey">The 32 characters long secret key to be used on the encryption</param>
/// <param name="secretVector">The 16 characters long secret vector to be used on the encryption</param>
/// <returns>The encrypted message</returns>
public static String Encrypt(String messageToEncrypt, String secretKey, String secretVector)
{
String messageEncrypted = null;
using (System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create())
{
aes.Key = System.Text.Encoding.UTF8.GetBytes(secretKey);
aes.IV = System.Text.Encoding.UTF8.GetBytes(secretVector);
ICryptoTransform iCryptoTransform = aes.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, iCryptoTransform, CryptoStreamMode.Write))
{
using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
{
streamWriter.Write(messageToEncrypt);
}
messageEncrypted = Convert.ToBase64String(memoryStream.ToArray());
}
}
}
return(messageEncrypted);
}
public AES(byte[] key)
{
rsa = new AesManaged();
rsa.GenerateKey();
rsa.GenerateIV();
_decoder = rsa.CreateDecryptor();
_encoder = rsa.CreateEncryptor();
}
/// <summary>
/// AES加解密
/// </summary>
/// <param name="aes"></param>
/// <param name="forEncryption">是否加密（false为解密）</param>
/// <param name="data">待加解密的数据</param>
/// <param name="key">加解密密钥，为空则使用实体属性Key</param>
/// <param name="mode">加解密模式，为空则使用实体属性Mode</param>
/// <param name="padding">填充算法，为空则使用实体属性Padding</param>
/// <returns>加解密后数据</returns>
public static byte[] Crypto(this System.Security.Cryptography.Aes aes,
bool forEncryption, byte[] data, byte[] key = null, CipherMode?mode = null, PaddingMode?padding = null)
{
aes.Key = key ?? aes.Key;
aes.Mode = mode ?? aes.Mode;
aes.Padding = padding ?? aes.Padding;
var cryptor = forEncryption ? aes.CreateEncryptor() : aes.CreateDecryptor();
return(cryptor.TransformFinalBlock(data, 0, data.Length));
}
static DBCrypto()
{
aesAlg = Aes.Create();
aesAlg.Key = AES_CBC_KEY;
aesAlg.IV = AES_CBC_IV;
aesAlg.Padding = PaddingMode.PKCS7;
decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
}
public SimpleAes(byte[] key)
{
aes = Aes.Create();
aes.GenerateIV();
aes.Key = key;
encryptor = aes.CreateEncryptor(key, aes.IV);
decryptor = aes.CreateDecryptor(key, aes.IV);
}
/// <summary>
/// ctor
/// </summary>
/// <param name="key"></param>
/// <param name="counterBufferSegment"></param>
/// <param name="aesFactory"></param>
/// <exception cref="ArgumentException">
/// <paramref name="counterBufferSegment"/> needs to have the same length as <see cref="AesConstants.STR_AES_BLOCK_SIZE"/>.
/// </exception>
public AesCtrCryptoTransform(byte[] key, ArraySegment<byte> counterBufferSegment, Func<Aes> aesFactory = null)
{
if (counterBufferSegment.Count != AesConstants.AES_BLOCK_SIZE)
throw new ArgumentException($"{nameof(counterBufferSegment)}.Count must be {AesConstants.STR_AES_BLOCK_SIZE}.", nameof(counterBufferSegment));
_aes = aesFactory?.Invoke() ?? CipherFactory.Aes();
_aes.Mode = CipherMode.ECB;
_aes.Padding = PaddingMode.None;
Buffer.BlockCopy(counterBufferSegment.Array, counterBufferSegment.Offset, _counterBuffer.Value, 0, AesConstants.AES_BLOCK_SIZE);
_cryptoTransform = _aes.CreateEncryptor(rgbKey: key, rgbIV: null);
}
/// <summary>ctor</summary>
public AesCtrCryptoTransform(byte[] key, ArraySegment<byte> counterBufferSegment, Func<Aes> aesFactory = null)
{
if (counterBufferSegment.Count != AesConstants.AES_BLOCK_SIZE)
throw new ArgumentException("counterBufferSegment.Count must be " + AesConstants.STR_AES_BLOCK_SIZE + ".");
this.aes = aesFactory == null ? AesFactories.Aes() : aesFactory();
this.aes.Mode = CipherMode.ECB;
this.aes.Padding = PaddingMode.None;
Utils.BlockCopy(counterBufferSegment.Array, counterBufferSegment.Offset, counterBuffer, 0, AesConstants.AES_BLOCK_SIZE);
this.cryptoTransform = aes.CreateEncryptor(rgbKey: key, rgbIV: null);
}// ctor
internal static byte[] AES256Encrypt(byte[] block, byte[] key)
{
using (System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create())
{
aes.Key = key;
aes.Mode = System.Security.Cryptography.CipherMode.ECB;
aes.Padding = System.Security.Cryptography.PaddingMode.None;
using (System.Security.Cryptography.ICryptoTransform encryptor = aes.CreateEncryptor())
{
return(encryptor.TransformFinalBlock(block, 0, block.Length));
}
}
}
private string CryptoTransform(string input, bool base64in, bool base64out, Aes cipher, CMode mode)
{
byte[] bytes;
if (base64in)
bytes = decode64(input);
else
bytes = Encoding.UTF8.GetBytes(input);
using (var c = mode == CMode.ENCRYPT ? cipher.CreateEncryptor() : cipher.CreateDecryptor()) {
var buf = c.TransformFinalBlock(bytes, 0, bytes.Length);
return base64out ? encode64(buf) : Encoding.UTF8.GetString(buf);
}
}
public static byte[] EncryptStringToBytes_AES(string plainText, byte[] Key, byte[] IV)
{
// Check arguments
if (ReferenceEquals(plainText, null) || plainText.Length <= 0)
{
throw (new ArgumentNullException("plainText"));
}
if (ReferenceEquals(Key, null) || Key.Length <= 0)
{
throw (new ArgumentNullException("Key"));
}
if (ReferenceEquals(IV, null) || IV.Length <= 0)
{
throw (new ArgumentNullException("Key"));
}
byte[] encrypted = null;
// Create an Aes object with the specified key and IV
using (System.Security.Cryptography.Aes aesAlg = System.Security.Cryptography.Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
// Create a decrytor to perform the stream transform.
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
// Write all data to the stream.
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream
return(encrypted);
}
/// <summary>
/// Encrypt the giving <see cref="Byte"> <see cref="Array"/>.
/// </summary>
/// <param name="plainText">The <see cref="Byte"> <see cref="Array"/> that contains data to encrypt.</param>
/// <param name="Key">The <see cref="Byte"> <see cref="Array"/> that contains the key.</param>
/// <param name="IV">The <see cref="Byte"> <see cref="Array"/> that contains the initialize vector.</param>
/// <returns>The encrypted data.</returns>
public static byte[] Encrypt(byte[] plainText, byte[] Key, byte[] IV)
{
// Check arguments
if (ReferenceEquals(plainText, null) || plainText.Length <= 0)
{
throw (new ArgumentNullException("plainText"));
}
if (ReferenceEquals(Key, null) || Key.Length <= 0)
{
throw (new ArgumentNullException("Key"));
}
if (ReferenceEquals(IV, null) || IV.Length <= 0)
{
throw (new ArgumentNullException("IV"));
}
byte[] encrypted = null;
// Create an Aes object with the specified key and IV
using (System.Security.Cryptography.Aes aesAlg = AesManaged.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
aesAlg.Padding = PaddingMode.Zeros;
// Create a decrytor to perform the stream transform.
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(plainText, 0, plainText.Length);
csEncrypt.Flush();
csEncrypt.Close();
}
encrypted = msEncrypt.ToArray();
}
}
// Return the encrypted bytes from the memory stream
return(encrypted);
}
static Boolean Test(Aes aes, CipherMode md)
{
Byte[] PlainText = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
Byte[] Key = {1, 1, 1, 1, 1, 1, 1, 1,2,2,2,2,2,2,2,2};
Byte[] IV = {100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115};
Console.WriteLine("Encrypting the following bytes:");
PrintByteArray(PlainText);
aes.Mode = md;
Console.WriteLine("AES default key size = " + aes.KeySize);
ICryptoTransform sse = aes.CreateEncryptor(Key, IV);
Console.WriteLine("SSE mode = " + aes.Mode);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write);
cs.Write(PlainText,0,PlainText.Length);
cs.FlushFinalBlock();
byte[] CipherText = ms.ToArray();
cs.Close();
Console.WriteLine("Cyphertext:");
PrintByteArray(CipherText);
Console.WriteLine("Decrypting...");
ICryptoTransform ssd = aes.CreateDecryptor(Key, IV);
Console.WriteLine("SSD mode = " + aes.Mode);
cs = new CryptoStream(new MemoryStream(CipherText), ssd, CryptoStreamMode.Read);
byte[] NewPlainText = new byte[PlainText.Length];
cs.Read(NewPlainText,0,PlainText.Length);
PrintByteArray(NewPlainText);
if (!Compare(PlainText, NewPlainText)) {
Console.WriteLine("ERROR: roundtrip failed");
return false;
}
return true;
}
public override string Encrypt(string plainText)
{
try
{
System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create();
byte[] inputBytes = Encoding.UTF8.GetBytes(plainText);
this.Key = Convert.ToBase64String(aes.Key).Replace("-", "");
this.IV = Convert.ToBase64String(aes.IV).Replace("-", "");
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(inputBytes, 0, inputBytes.Length);
cs.FlushFinalBlock();
return(Convert.ToBase64String(ms.ToArray()));
}
catch (Exception e)
{
return("\nERROR: " + e.Message);
}
}
public string Encrypt(string str)
{
using (System.Security.Cryptography.Aes encryptor = System.Security.Cryptography.Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(key, 8);
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (MemoryStream ms = new MemoryStream())
{
byte[] bytes = Encoding.Unicode.GetBytes(str);
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(bytes, 0, bytes.Length);
cs.Close();
}
return(Convert.ToBase64String(ms.ToArray()));
}
}
}
public static string Encrypt(string EncryptText)
{
byte[] clearBytes = Encoding.Unicode.GetBytes(EncryptText);
using (Aes encryptor = Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 });
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(clearBytes, 0, clearBytes.Length);
cs.Close();
}
EncryptText = Convert.ToBase64String(ms.ToArray());
}
}
return(EncryptText);
}
public byte[] CoderBytes(byte[] input)
{
//Проверка аргументов
if (input == null || input.Length <= 0)
{
return(null);
}
byte[] coderByte;
//Создаем поток для шифрования
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, AES.CreateEncryptor(AES.Key, AES.IV), CryptoStreamMode.Write))
{
csEncrypt.Write(input, 0, input.Length);
}
coderByte = msEncrypt.ToArray();
}
return(coderByte);
}
public string Encrypt(string clearText)
{
string EncryptionKey = "KFNLP@$$W0rdMOICP@$$Word";
byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(clearText);
using (System.Security.Cryptography.Aes encryptor = Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x49, 0x65, 0x64, 0x76, 0x65, 0x64, 0x76, 0x65, 0x76 });
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (System.IO.MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(clearBytes, 0, clearBytes.Length);
cs.Close();
}
clearText = Convert.ToBase64String(ms.ToArray());
}
}
return(clearText);
}
public void Initialize(ReadOnlySpan <byte> key, ReadOnlySpan <byte> iv, CipherMode mode, bool isDecrypting)
{
Debug.Assert(key.Length == Aes.KeySize128);
Debug.Assert(iv.IsEmpty || iv.Length == Aes.BlockSize);
System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create();
if (aes == null)
{
throw new CryptographicException("Unable to create AES object");
}
aes.Key = key.ToArray();
aes.Mode = mode;
aes.Padding = PaddingMode.None;
if (!iv.IsEmpty)
{
aes.IV = iv.ToArray();
}
_transform = isDecrypting ? aes.CreateDecryptor() : aes.CreateEncryptor();
_isDecrypting = isDecrypting;
}
private static byte[] EncryptStringToBytesAes(string plainText, byte[] key, byte[] iv)
{
if (plainText == null || plainText.Length <= 0)
{
throw new ArgumentNullException("plainText");
}
if (key == null || key.Length <= 0)
{
throw new ArgumentNullException("Key");
}
if (iv == null || iv.Length <= 0)
{
throw new ArgumentNullException("IV");
}
var data = plainText.FromHexString();
using (System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create())
{
aes.Padding = PaddingMode.None;
aes.Mode = CipherMode.CBC;
aes.Key = key;
aes.IV = iv;
var encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
using (var msEncrypt = new MemoryStream())
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(data, 0, data.Length);
return(msEncrypt.ToArray());
}
}
}
// Central Method for string encryption
public static string encrypt(string encryptString)
{
string EncryptionKey = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
byte[] clearBytes = Encoding.Unicode.GetBytes(encryptString);
using (System.Security.Cryptography.Aes encryptor = Aes.Create())
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, new byte[] {
0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76
});
encryptor.Key = pdb.GetBytes(32);
encryptor.IV = pdb.GetBytes(16);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(clearBytes, 0, clearBytes.Length);
cs.Close();
}
encryptString = Convert.ToBase64String(ms.ToArray());
}
}
return(encryptString);
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="data">待加密的明文</param>
/// <param name="password">加密公钥</param>
/// <returns>返回一个Base64编码的密文</returns>
public static string AesEncrypt(this string data, string password)
{
if (string.IsNullOrEmpty(data) || string.IsNullOrEmpty(password))
{
return(data);
}
byte[] keyBytes = password.ToBytes();
byte[] toEncryptArray = data.ToBytes();
Aes aesProvider = Aes.Create();
if (keyBytes.Length < aesProvider.KeySize)
{
throw new KeySizeException();
}
aesProvider.Key = keyBytes;
aesProvider.Mode = CipherMode.ECB;
aesProvider.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = aesProvider.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(resultArray.ToBase64String());
}
public static bool TestTransform(Aes aes)
{
CipherMode[] modes;
// AES allows CBC, ECB, and CFB modes. Due to bug in RijndaelManaged, AesManaged does not
// allow CFB.
//
if (aes is AesManaged)
modes = new CipherMode[] {CipherMode.CBC, CipherMode.ECB};
else
modes = new CipherMode[] {CipherMode.CBC, CipherMode.ECB, CipherMode.CFB};
ICryptoTransform encryptor;
ICryptoTransform decryptor;
foreach (CipherMode mode in modes)
{
aes.Mode = mode;
encryptor = aes.CreateEncryptor();
decryptor = aes.CreateDecryptor();
if (encryptor.CanReuseTransform != true)
{
Console.WriteLine("Error - encryptor CanReuseTransform not true");
return false;
}
if (decryptor.CanReuseTransform != true)
{
Console.WriteLine("Error - decryptor CanReuseTransform not true");
return false;
}
if (encryptor.CanTransformMultipleBlocks != true)
{
Console.WriteLine("Error - encryptor CanTransformMultipleBlocks not true");
return false;
}
if (decryptor.CanTransformMultipleBlocks != true)
{
Console.WriteLine("Error - decryptor CanTransformMultipleBlocks not true");
return false;
}
if (encryptor.InputBlockSize != 16)
{
Console.WriteLine("Error - encryptor InputBlockSize not 16");
return false;
}
if (decryptor.InputBlockSize != 16)
{
Console.WriteLine("Error - decryptor InputBlockSize not 16");
return false;
}
if (encryptor.OutputBlockSize != 16)
{
Console.WriteLine("Error - encryptor OutputBlockSize not 16");
return false;
}
if (decryptor.OutputBlockSize != 16)
{
Console.WriteLine("Error - decryptor OutputBlockSize not 16");
return false;
}
}
return true;
}
/// <summary>
/// Encrypt a byte array by using the AES algorightm.
/// <para>The input is: [data]</para>
/// <para>The output is: [Magic Number (4 bytes)] [AES IV (16 bytes)] [AES(data) (xx bytes)] [HMAC(IV || AES(data)) (32 bytes)]</para>
/// </summary>
public static byte[] Encrypt(byte[] content, Aes aes)
{
using (MemoryStream outputStream = new MemoryStream()) {
// Write the magic number
outputStream.Write (MAGIC_NUMBER, 0, 4);
using (MemoryStream cypherStream = new MemoryStream()) {
// Write the IV
cypherStream.Write (aes.IV, 0, 16);
// Write the AES encrypted content
using (ICryptoTransform transform = aes.CreateEncryptor ()) {
using (CryptoStream cryptoStream = new CryptoStream(cypherStream, transform, CryptoStreamMode.Write)) {
cryptoStream.Write (content, 0, content.Length);
cryptoStream.Flush ();
cryptoStream.Close ();
}
}
// Collect cypher result
cypherStream.Flush ();
cypherStream.Close ();
byte[] cypherBytes = cypherStream.ToArray ();
// Write the cypher
outputStream.Write (cypherBytes, 0, cypherBytes.Length);
// Compute the HMAC of the cypher
using (HMACSHA256 hmac = new HMACSHA256 (DeriveKey (aes.Key))) {
byte[] hmacBytes = hmac.ComputeHash (cypherBytes);
// Write the HMAC
outputStream.Write (hmacBytes, 0, hmacBytes.Length);
}
}
outputStream.Flush ();
outputStream.Close ();
byte[] outputBytes = outputStream.ToArray ();
return outputBytes;
}
}
public static ICryptoTransform getEncryptor(Aes aes)
{
return aes.CreateEncryptor(aes.Key, aes.IV);
}
internal AesCbcHmacSha2Encryptor( string name, byte[] key, byte[] iv, byte[] associatedData )
{
// Split the key to get the AES key, the HMAC key and the HMAC object
byte[] aesKey;
GetAlgorithmParameters( name, key, out aesKey, out _hmac_key, out _hmac );
// Create the AES provider
_aes = Aes.Create();
_aes.Mode = CipherMode.CBC;
_aes.Padding = PaddingMode.PKCS7;
_aes.KeySize = aesKey.Length * 8;
_aes.Key = aesKey;
_aes.IV = iv;
_inner = _aes.CreateEncryptor();
_associated_data_length = ConvertToBigEndian( associatedData.Length * 8 );
// Prime the hash.
_hmac.TransformBlock( associatedData, 0, associatedData.Length, associatedData, 0 );
_hmac.TransformBlock( iv, 0, iv.Length, iv, 0 );
}
/// <summary>
/// Encrypts data.
/// </summary>
/// <param name="aes">Aes object.</param>
/// <param name="content">Content to be encrypted.</param>
/// <param name="key">Encryption key.</param>
/// <param name="iv">Initial vector.</param>
/// <returns>Encrypted data.</returns>
public static byte[] Encrypt(Aes aes, byte[] content, byte[] key, byte[] iv)
{
var encryptor = aes.CreateEncryptor(key, iv);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
cs.Write(content, 0, content.Length);
}
return ms.ToArray();
}
}
public static bool TestTransform(Aes aes)
{
ICryptoTransform encryptor;
ICryptoTransform decryptor;
encryptor = aes.CreateEncryptor();
decryptor = aes.CreateDecryptor();
if (encryptor.CanReuseTransform != true)
{
Console.WriteLine("Error - encryptor CanReuseTransform not true");
return false;
}
if (decryptor.CanReuseTransform != true)
{
Console.WriteLine("Error - decryptor CanReuseTransform not true");
return false;
}
if (encryptor.CanTransformMultipleBlocks != true)
{
Console.WriteLine("Error - encryptor CanTransformMultipleBlocks not true");
return false;
}
if (decryptor.CanTransformMultipleBlocks != true)
{
Console.WriteLine("Error - decryptor CanTransformMultipleBlocks not true");
return false;
}
if (encryptor.InputBlockSize != 16)
{
Console.WriteLine("Error - encryptor InputBlockSize not 16");
return false;
}
if (decryptor.InputBlockSize != 16)
{
Console.WriteLine("Error - decryptor InputBlockSize not 16");
return false;
}
if (encryptor.OutputBlockSize != 16)
{
Console.WriteLine("Error - encryptor OutputBlockSize not 16");
return false;
}
if (decryptor.OutputBlockSize != 16)
{
Console.WriteLine("Error - decryptor OutputBlockSize not 16");
return false;
}
return true;
}
// AES allows CBC, ECB, and CFB modes. Due to bug in RijndaelManaged, AesManaged does not
// allow CFB.
//
public static bool TestModes(Aes aes)
{
if (aes.Mode != CipherMode.CBC)
{
Console.WriteLine("Error - default Mode not CBC");
return false;
}
aes.CreateEncryptor().TransformFinalBlock(new byte[10], 0, 10);
aes.Mode = CipherMode.ECB;
aes.CreateEncryptor().TransformFinalBlock(new byte[10], 0, 10);
try
{
aes.Mode = CipherMode.CFB;
aes.CreateEncryptor().TransformFinalBlock(new byte[10], 0, 10);
if (aes is AesManaged)
{
Console.WriteLine("Error - CFB mode allowed");
return false;
}
}
catch (CryptographicException)
{
if (!(aes is AesManaged))
{
Console.WriteLine("Error - CFB mode not allowed");
return false;
}
}
try
{
aes.Mode = CipherMode.CTS;
aes.CreateEncryptor().TransformFinalBlock(new byte[10], 0, 10);
Console.WriteLine("Error - CTS mode allowed");
return false;
}
catch (CryptographicException)
{
}
try
{
aes.Mode = CipherMode.OFB;
aes.CreateEncryptor().TransformFinalBlock(new byte[10], 0, 10);
Console.WriteLine("Error - OFB mode allowed");
return false;
}
catch (CryptographicException)
{
}
return true;
}
/**********************************************************************************************************
* void MainWindow_Closing
* Purpose: Fires when the window is to be closed. Prompts the user to save changes.
* Encrypts the file using AES using a SHA-3 key derived from the MasterPassword.
**********************************************************************************************************/
void MainWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
MessageBoxResult save = MessageBox.Show("Save your data?", "Save Prompt", MessageBoxButton.YesNoCancel);
if (save == MessageBoxResult.No)
{
return;
}
else if (save == MessageBoxResult.Cancel)
{
e.Cancel = true;
return;
}
// Need 128 bits password for the encryption key.
ApplicationEntry self = new ApplicationEntry("MasterPass", 128 / sizeof(char) / 8, 0, true, true, true, false);
HashedPassword fileName = self.GeneratePassword(MasterPassword);
HashedPassword aesKey = self.GeneratePassword(MasterPassword);
HashedPassword aesIV = self.GeneratePassword(MasterPassword);
System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create();
// Even if aes is broken the master password is unrecoverable.
aes.Key = Encoding.Unicode.GetBytes(aesKey.Password);
aes.IV = Encoding.Unicode.GetBytes(aesIV.Password);
aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
ICryptoTransform encryptor = aes.CreateEncryptor();
// Open the file
using (FileStream outputStream = new FileStream(fileName.Password + ".pass", FileMode.OpenOrCreate))
{
// Use a safe to file encryption method
using (CryptoStream csEncrypt = new CryptoStream(outputStream, encryptor, CryptoStreamMode.Write))
{
// Convert the object to a byte array
using (MemoryStream objectStream = new MemoryStream())
{
// Throw the userData into the object stream.
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(objectStream, Data);
objectStream.Position = 0;
byte[] buffer = new byte[1024];
int bytesRead = objectStream.Read(buffer, 0, buffer.Length);
// While there are still more bytes to write
while (bytesRead > 0)
{
// Write them to the file.
csEncrypt.Write(buffer, 0, bytesRead);
bytesRead = objectStream.Read(buffer, 0, buffer.Length);
}
// Flush the final block.
csEncrypt.FlushFinalBlock();
}
}
}
}
public SegmentReader(Stream _bsstr, Aes rdale, int _fragsize)
{
_rdale = rdale as AesManaged;
basestream = _bsstr;
fragsize = _fragsize;
reader = rdale.CreateDecryptor();
writer = rdale.CreateEncryptor();
#if !SINGLE_THREADED
mthread = new System.Threading.Thread(thetar);
mthread.Start();
#endif
}
public byte[] EncodeBytes(byte[] e)
{
var es = new PerformanceCounter();
return(Transform(_encoder ?? rsa.CreateEncryptor(), e));
}
public static byte[] GetPaddingBytes(Aes aes, PaddingMode mode, int offset)
{
byte[] originalData = new byte[BlockSizeBytes + offset];
new Random().NextBytes(originalData);
aes.Padding = mode;
byte[] encryptedData = aes.CreateEncryptor().TransformFinalBlock(originalData, 0, originalData.Length);
aes.Padding = PaddingMode.None;
byte[] decryptedData = aes.CreateDecryptor().TransformFinalBlock(encryptedData, 0, encryptedData.Length);
byte[] paddingBytes = new byte[decryptedData.Length - BlockSizeBytes - offset];
Array.Copy(decryptedData, BlockSizeBytes + offset, paddingBytes, 0, decryptedData.Length - BlockSizeBytes - offset);
return paddingBytes;
}
public override ICryptoTransform CreateEncryptor() => _impl.CreateEncryptor();
public static void WriteMessageStream(MemoryStream outStream, Message outMessage, string sessionKey, Aes aes, bool encrypt)
{
outMessage.ReplaceControlValue(Message.TimestampControlValueName, DateTime.Now.ToUniversalTime().ToString());
outMessage.ReplaceControlValue(Message.SessionKeyControlValueName, sessionKey);
if (encrypt)
{
aes.GenerateIV();
StreamUtilities.WriteStringToMemoryStream(outStream, aes.IV.Length + "!");
outStream.Write(aes.IV, 0, aes.IV.Length);
StreamUtilities.RunCryptoTransform(outMessage.Serialize(), aes.CreateEncryptor(), outStream, true);
}
else
{
outMessage.Serialize(outStream);
}
}
