public byte[] Encrypt(byte[] plainText, byte[] iv, int offset = 0)
{
// TODO do checks on args
byte[] encrypted;
if (iv is null)
{
_provider.GenerateIV();
}
else
{
_provider.IV = iv;
}
ICryptoTransform encryptor = _provider.CreateEncryptor();
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(plainText, offset, plainText.Length - offset);
}
encrypted = msEncrypt.ToArray();
}
return(encrypted);
}
public EncryptionTests()
{
var aescsp = new AesCryptoServiceProvider();
aescsp.GenerateKey();
aescsp.GenerateIV();
_correctKey = aescsp.Key;
_correctVector = aescsp.IV;
aescsp.GenerateKey();
aescsp.GenerateIV();
_wrongKey = aescsp.Key;
_wrongVector = aescsp.IV;
}
public static byte[] EncryptOuterContainer(OuterContainer outerContainer, InnerContainer innerContainer, byte[] key)
{
XmlDocument outerContainerXml = SerializeOuterContainer(outerContainer);
XmlDocument innerContainerXml = SerializeInnerContainer(innerContainer);
XmlElement encryptedDataPlaceholder = outerContainerXml.GetElementsByTagName("EncryptedDataPlaceholder")[0] as XmlElement;
XmlElement plaintextInnerContainer = innerContainerXml.GetElementsByTagName("InnerContainer")[0] as XmlElement;
EncryptedData encryptedData = new EncryptedData();
encryptedData.Type = EncryptedXml.XmlEncElementUrl;
encryptedData.EncryptionMethod = new EncryptionMethod(EncryptedXml.XmlEncAES256Url);
EncryptedXml encryptedXml = new EncryptedXml();
using (AesCryptoServiceProvider aesCsp = new AesCryptoServiceProvider())
{
aesCsp.KeySize = 256; // critical security parameter
aesCsp.Key = key; // critical security parameter
aesCsp.Mode = CipherMode.CBC; // critical security parameter
aesCsp.GenerateIV(); // critical security parameter
encryptedData.CipherData.CipherValue = encryptedXml.EncryptData(plaintextInnerContainer, aesCsp, false);
}
EncryptedXml.ReplaceElement(encryptedDataPlaceholder, encryptedData, false);
byte[] outerContainerBytes = Encoding.UTF8.GetBytes(outerContainerXml.OuterXml);
byte[] fileBytes = Shared.Utility.Compress(outerContainerBytes);
return(fileBytes);
}
internal static byte[] EncryptBytes(byte[] plain, byte[] Key, out byte[] IV, PaddingMode paddingMode = PaddingMode.None)
{
if ((plain.Length % Key.Length) != 0)
{
paddingMode = PaddingMode.PKCS7;
}
byte[] encrypted;
byte[] full;
using (MemoryStream mstream = new MemoryStream()) {
using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider()) {
aesProvider.KeySize = 128;
aesProvider.BlockSize = 128;
aesProvider.Mode = CipherMode.CBC;
aesProvider.Padding = paddingMode;
aesProvider.GenerateIV();
IV = aesProvider.IV;
aesProvider.Key = Key;
using (CryptoStream cryptoStream = new CryptoStream(mstream, aesProvider.CreateEncryptor(), CryptoStreamMode.Write)) {
cryptoStream.Write(plain, 0, plain.Length);
}
encrypted = mstream.ToArray();
full = new byte[encrypted.Length + IV.Length];
Array.Copy(encrypted, full, encrypted.Length);
Array.ConstrainedCopy(IV, 0, full, encrypted.Length, IV.Length);
}
}
return(full);
}
/// <summary>
/// Helper method to generate an Initialization Vector for the client.
/// </summary>
public static void GenerateClientIV()
{
AesCryptoServiceProvider AES = new AesCryptoServiceProvider();
AES.GenerateIV();
ClientIV = AES.IV;
}
public static byte[] Encrypt(string plainText, string key, bool nullEndMark, Encoding encoding)
{
var csp = new AesCryptoServiceProvider()
{
BlockSize = AesBlockSize,
KeySize = aesKeySize,
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7,
};
csp.GenerateIV();
csp.Key = Convert.FromBase64String(key);
byte[] bytesIV = csp.IV;
using (var outms = new MemoryStream())
using (var encryptor = csp.CreateEncryptor())
using (var cs = new CryptoStream(outms, encryptor, CryptoStreamMode.Write))
using (var writer = new StreamWriter(cs))
{
outms.Write(bytesIV, 0, 16);
byte[] toEncrypt = encoding.GetBytes(plainText);
cs.Write(toEncrypt, 0, toEncrypt.Length);
if (nullEndMark)
{
cs.Write(new byte[] { 0 }, 0, 1);
}
cs.FlushFinalBlock();
return(outms.ToArray());
}
}
public static byte[] Encrypt(byte[] data, string password)
{
byte[] encryptedData = null;
using (AesCryptoServiceProvider provider = new AesCryptoServiceProvider())
{
provider.GenerateIV();
provider.Key = CreateKey(password, provider.KeySize);
provider.Mode = CipherMode.CBC;
provider.Padding = PaddingMode.PKCS7;
using (MemoryStream memStream = new MemoryStream(data.Length))
{
memStream.Write(provider.IV, 0, 16);
using (ICryptoTransform encryptor = provider.CreateEncryptor(provider.Key, provider.IV))
{
using (CryptoStream cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
}
}
encryptedData = memStream.ToArray();
}
}
return(encryptedData);
}
public static byte[] encrypt(string receiverPublicKey, byte[] plaintext)
{
byte[] encryptedText;
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.GenerateKey();
aes.GenerateIV();
ICryptoTransform encryptor = aes.CreateEncryptor();
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(plaintext, 0, plaintext.Length);
csEncrypt.FlushFinalBlock();
encryptedText = msEncrypt.ToArray();
}
}
byte[] encryptedKey = Account.encryptData(receiverPublicKey, aes.Key);
byte[] ciphertext = new byte[1 + encryptedKey.Length + aes.IV.Length + encryptedText.Length];
ciphertext[0] = (byte)encryptedKey.Length;
Buffer.BlockCopy(encryptedKey, 0, ciphertext, 1, encryptedKey.Length);
Buffer.BlockCopy(aes.IV, 0, ciphertext, 1 + encryptedKey.Length, aes.IV.Length);
Buffer.BlockCopy(encryptedText, 0, ciphertext, 1 + encryptedKey.Length + aes.IV.Length, encryptedText.Length);
return(ciphertext);
}
private EncryptedBlob Encrypt(SecureBuffer input)
{
EncryptedBlob blob;
#if NETSTANDARD1_3
var aes = Aes.Create();
#elif NET20 || NET30
var aes = Rijndael.Create();
#else
var aes = new AesCryptoServiceProvider();
#endif
using (aes)
{
aes.Mode = CipherMode.CBC;
aes.Key = _encryptionKey.Buffer;
aes.BlockSize = 128;
aes.GenerateIV();
blob.IV = aes.IV;
using (var encryptor = aes.CreateEncryptor())
{
blob.Payload = encryptor.TransformFinalBlock(input.Buffer, 0, input.Buffer.Length);
}
}
blob.Hmac = Authenticate(blob.IV, blob.Payload);
return(blob);
}
/// <summary>
/// 获取加密和解密时用的key和iv
/// </summary>
/// <param name="providerType">算法类型</param>
/// <param name="key"></param>
/// <param name="iv"></param>
public static void GenerateCryptKeyAndIV(CryptProviderType providerType, out byte[] key, out byte[] iv)
{
key = null;
iv = null;
switch (providerType)
{
case CryptProviderType.AES:
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.GenerateKey();
aes.GenerateIV();
key = aes.Key;
iv = aes.IV;
return;
case CryptProviderType.DES:
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.GenerateKey();
des.GenerateIV();
key = des.Key;
iv = des.IV;
return;
case CryptProviderType.TripleDES:
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.GenerateKey();
tdes.GenerateIV();
key = tdes.Key;
iv = tdes.IV;
return;
default:
return;
}
}
public int EncrytpData(byte[] pubKey, byte[] input, int offset, int inputSize, out byte[] output)
{
using (var keyAlg = new ECDiffieHellmanCng(this._crypKey))
using (var otherKey = CngKey.Import(pubKey, CngKeyBlobFormat.EccPublicBlob))
{
var symmKey = keyAlg.DeriveKeyMaterial(otherKey);
using (var aes = new AesCryptoServiceProvider())
{
aes.Key = symmKey;
aes.GenerateIV();
int ivSize = aes.IV.Count();
using (var encryptor = aes.CreateEncryptor())
using (var memStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))
{
memStream.Write(aes.IV, 0, ivSize);
cryptoStream.Write(input, offset, inputSize);
}
output = memStream.ToArray();
return(output.Count());
}
}
}
}
private void Init(long startTime, long period, int numberOfEntries, long replicationDuration)
{
if (numberOfEntries > 0)
{
using (AesCryptoServiceProvider aesCryptoServiceProvider = new AesCryptoServiceProvider())
{
int num = aesCryptoServiceProvider.Key.Length + aesCryptoServiceProvider.IV.Length;
long ticks = (Canary15DataSegment.UtcNow + Canary15DataSegment.ReplicationDuration).Ticks;
if (startTime < ticks)
{
startTime = ticks;
}
this.header = new Canary15DataSegment.DataSegmentHeader(startTime, ticks, Canary15DataSegment.UtcNowTicks, period, numberOfEntries, num, replicationDuration);
this.data = new byte[numberOfEntries][];
for (int i = 0; i < numberOfEntries; i++)
{
aesCryptoServiceProvider.GenerateKey();
aesCryptoServiceProvider.GenerateIV();
this.data[i] = new byte[num];
aesCryptoServiceProvider.Key.CopyTo(this.data[i], 0);
aesCryptoServiceProvider.IV.CopyTo(this.data[i], aesCryptoServiceProvider.Key.Length);
}
this.header.ComputeState(this.data);
this.Trace(0, "Init()");
}
}
}
public void Encrypt(byte[] data, byte[] AESKey)
{
//Generate random 256 bit AES key
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider())
{
AES.Key = AESKey;
AES.GenerateIV();
//Encrypt the data with aes
using (MemoryStream memStream = new MemoryStream())
{
using (
CryptoStream cryptoStream = new CryptoStream(memStream, AES.CreateEncryptor(),
CryptoStreamMode.Write))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
this.data = memStream.ToArray();
memStream.Close();
cryptoStream.Close();
}
}
IV = AES.IV;
}
}
public byte[] Encrypt(byte[] data, string RSAKey)
{
//Generate random 256 bit AES key
using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider())
{
AES.KeySize = 256;
AES.GenerateKey();
AES.GenerateIV();
//Encrypt the data with aes
using (MemoryStream memStream = new MemoryStream())
{
using (
CryptoStream cryptoStream = new CryptoStream(memStream, AES.CreateEncryptor(),
CryptoStreamMode.Write))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
this.data = memStream.ToArray();
memStream.Close();
cryptoStream.Close();
}
}
//Encrypt the AES key with RSA
using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
{
rsa.FromXmlString(RSAKey);
sessionKey = rsa.Encrypt(AES.Key, true);
}
IV = AES.IV;
return(AES.Key);
}
}
//https://stackoverflow.com/questions/8041451/good-aes-initialization-vector-practice
public byte[] EncryptBytes(byte[] toEncrypt, byte[] encryptionKey)
{
if (toEncrypt == null || toEncrypt.Length == 0)
{
throw new ArgumentException("toEncrypt");
}
if (encryptionKey == null || encryptionKey.Length == 0)
{
throw new ArgumentException("encryptionKey");
}
var toEncryptBytes = toEncrypt;
using (var provider = new AesCryptoServiceProvider())
{
provider.Key = encryptionKey;
provider.Mode = CipherMode.CBC;
provider.Padding = PaddingMode.PKCS7;
provider.GenerateIV();
using (var encryptor = provider.CreateEncryptor(provider.Key, provider.IV))
{
using (var ms = new MemoryStream())
{
ms.Write(provider.IV, 0, 16);
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
cs.Write(toEncryptBytes, 0, toEncryptBytes.Length);
cs.FlushFinalBlock();
}
return(ms.ToArray());
}
}
}
}
public ServiceAES(CipherMode mode, string password, bool decryption)
{
if (decryption)
{
AesCsp = new AesCryptoServiceProvider
{
BlockSize = 128,
KeySize = 256,
Mode = mode,
Padding = PaddingMode.PKCS7
};
AesCsp.Key = GetHashSha256(password);
}
else
{
AesCsp = new AesCryptoServiceProvider
{
BlockSize = 128,
KeySize = 256,
Mode = mode,
Padding = PaddingMode.PKCS7
};
AesCsp.GenerateIV();
AesCsp.Key = GetHashSha256(password);
}
}
/// <summary>
/// Privater Schlüssel mit AES verschlüsseln
/// </summary>
/// <param name="privkey">Privater Schlüssel(klartext)</param>
/// <param name="password">Kennwort vom Benutzer</param>
/// <param name="salt_masterkey">Salt</param>
/// <returns>Privater Schlüsel(verschlüsselt) in Base64</returns>
public static string toEncryptPrivateKey(string privkey, string password, byte[] salt_masterkey)
{
byte[] data = Util.GetBytes(privkey);
byte[] encryptedData = null;
using (var aes = new AesCryptoServiceProvider())
{
aes.GenerateIV();
aes.Key = createMasterkey(password, salt_masterkey, aes.KeySize);
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
using (MemoryStream memStream = new MemoryStream(data.Length))
{
memStream.Write(aes.IV, 0, 16);
using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
{
using (CryptoStream cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
}
}
encryptedData = memStream.ToArray();
}
}
return(Convert.ToBase64String(encryptedData));
}
public static byte[] decrypt(Account receiver, string passphrase, byte[] ciphertext)
{
if (receiver.checkPassphrase(passphrase))
{
AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.Key = Account.decryptData(receiver, passphrase, ciphertext.Skip(1).Take(ciphertext[0]).ToArray());
aes.GenerateIV();
aes.IV = ciphertext.Skip(1 + ciphertext[0]).Take(aes.IV.Length).ToArray();
ICryptoTransform decryptor = aes.CreateDecryptor();
using (MemoryStream msDecrypt = new MemoryStream())
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write))
{
csDecrypt.Write(ciphertext, 1 + ciphertext[0] + aes.IV.Length, ciphertext.Length - (1 + ciphertext[0] + aes.IV.Length));
csDecrypt.FlushFinalBlock();
return(msDecrypt.ToArray());
}
}
}
else
{
return(null);
}
}
static int Handle(bool onlyIV, bool onlyKey)
{
if (onlyIV && onlyKey)
{
throw new ArgumentException("Unable to exclusively print both");
}
using (var provider = new AesCryptoServiceProvider())
{
provider.GenerateKey();
provider.GenerateIV();
if (!onlyKey)
{
Console.WriteLine($"IV: \"{Convert.ToBase64String(provider.IV)}\"");
}
if (!onlyIV)
{
Console.WriteLine($"Key: \"{Convert.ToBase64String(provider.Key)}\"");
}
}
return(0);
}
public static string Encrypt(string str, string key)
{
AesCryptoServiceProvider aesCryptoProvider = new AesCryptoServiceProvider();
byte[] byteBuff;
try
{
aesCryptoProvider.Key = Encoding.UTF8.GetBytes(key);
aesCryptoProvider.GenerateIV();
aesCryptoProvider.IV = aesCryptoProvider.IV;
byteBuff = Encoding.UTF8.GetBytes(str);
byte[] encoded = aesCryptoProvider.CreateEncryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length);
string ivHexString = ToHexString(aesCryptoProvider.IV);
string encodedHexString = ToHexString(encoded);
return(ivHexString + ':' + encodedHexString);
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(null);
}
}
public static byte[] Encrypt(byte[] data, string password, int keySize = 256)
{
AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider();
aesProvider.Mode = CipherMode.CBC;
aesProvider.Padding = PaddingMode.PKCS7;
aesProvider.KeySize = keySize;
aesProvider.GenerateIV();
//We are not saving this hash so we do not need a salt.
aesProvider.Key = new PasswordDeriveBytes(password, new byte[] { }).GetBytes(aesProvider.KeySize / 8);
ICryptoTransform encrypter = aesProvider.CreateEncryptor();
using (MemoryStream output = new MemoryStream())
using (CryptoStream writer = new CryptoStream(output, encrypter, CryptoStreamMode.Write))
{
writer.Write(data, 0, data.Length);
writer.FlushFinalBlock();
byte[] encrypted = new byte[output.Length + 16];
Buffer.BlockCopy(aesProvider.IV, 0, encrypted, 0, aesProvider.IV.Length);
Buffer.BlockCopy(output.ToArray(), 0, encrypted, aesProvider.IV.Length, output.ToArray().Length);
return(encrypted);
}
}
private static AesCryptoServiceProvider CreateAes(byte[] secret, byte[] iv)
{
var aes = new AesCryptoServiceProvider
{
KeySize = KeySize,
BlockSize = BlockSize,
Mode = CipherMode,
Padding = PaddingMode,
};
if (iv == null)
{
aes.GenerateIV();
}
else
{
aes.IV = iv;
}
using (var sha256 = SHA256.Create())
{
aes.Key = sha256.ComputeHash(secret, 0, secret.Length);
}
return(aes);
}
public byte[] Protect(byte[] data)
{
byte[] dataHash;
using (var sha = new SHA256CryptoServiceProvider())
{
dataHash = sha.ComputeHash(data);
}
using (var aesAlg = new AesCryptoServiceProvider())
{
aesAlg.Key = _key;
aesAlg.GenerateIV();
using (var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV))
using (var msEncrypt = new MemoryStream())
{
msEncrypt.Write(aesAlg.IV, 0, 16);
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
using (var bwEncrypt = new BinaryWriter(csEncrypt))
{
bwEncrypt.Write(dataHash);
bwEncrypt.Write(data.Length);
bwEncrypt.Write(data);
}
var protectedData = msEncrypt.ToArray();
return(protectedData);
}
}
}
public byte[] GenerateIV()
{
Aes aes = new AesCryptoServiceProvider();
aes.GenerateIV();
return(aes.IV);
}
//Cifra un texto en AES, la contraseña se pasa ya crifrada mediante SHA de 32 bytes
public static string CifrarPassArchivoAES(string text, Byte[] password)
{
//Crea el AES Crypto Service Provider
var aes = new AesCryptoServiceProvider()
{
BlockSize = 128,
KeySize = 256,
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7, //Se hace por defecto
Key = password
};
//Genera un vector de inicialización (IV) aleatorio
aes.GenerateIV();
//Obtiene IV
byte[] bytesIV = aes.IV;
//Convierte el texto de entrada a byte[]
byte[] bytesText = Encoding.Unicode.GetBytes(text);
using (ICryptoTransform encrypt = aes.CreateEncryptor())
{
byte[] dest = encrypt.TransformFinalBlock(bytesText, 0, bytesText.Length);
//Añade el IV al principio, con un carácter de separación
string ret = Convert.ToBase64String(aes.IV) + '$' + Convert.ToBase64String(dest);
return(ret);
}
}
/// <summary>
/// 在AliceSendsDataAsync()方法中，包含文本字符的字符串使用Encoding类转换为一个字节数组。
/// 创建一个ECDiffieHellmanCng对象，用Alice的密钥对初始化它。
/// Alice调用DeriveKeyMaterial()方法，从而使用其密钥对和Bob的公钥创建一个对称密钥。
/// 返回的对称密钥使用对称算法AES加密数据。
/// AesCryptoServiceProvider需要密钥和一个初始化矢量（IV）。
/// IV从GenerateIV()方法中动态生成，对称密钥用EC Diffe-He11man算法交换，但还必须交换IV。
/// 从安全性角度来看，在网络上传输未加密的IV是可行的一一只是密钥交换必须是安全的。
/// IV存储为内存流中的第一项内容，其后是加密的数据，其中，CryptoStream类使用AesCryptoServiceProvider类创建的encryptor。
/// 在访问内存流中的加密数据之前，必须关闭加密流。否则，加密数据就会丢失最后的位。
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
private static async Task <byte[]> AliceSendsDataAsync(string message)
{
Console.WriteLine($"Alice发送了信息{message}");
byte[] rawData = Encoding.UTF8.GetBytes(message);
byte[] encryptedData = null;
using (var aliceAlgorithm = new ECDiffieHellmanCng(_aliceKey))
using (CngKey bobPubkey = CngKey.Import(_bobPubKeyBlob, CngKeyBlobFormat.EccPublicBlob))
{
byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubkey);
Console.WriteLine($"Alice创建对称密钥——bob的公共密钥信息{Convert.ToBase64String(symmKey)}");
using (var aes = new AesCryptoServiceProvider())
{
aes.Key = symmKey;
aes.GenerateIV();
using (ICryptoTransform encryptor = aes.CreateEncryptor())
using (var ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
await ms.WriteAsync(aes.IV, 0, aes.IV.Length);
cs.Write(rawData, 0, rawData.Length);
}
encryptedData = ms.ToArray();
}
aes.Clear();
}
}
Console.WriteLine($"Alice：加密消息{ Convert.ToBase64String(encryptedData)}");
Console.WriteLine();
return(encryptedData);
}
private async static Task <byte[]> AliceSendsData(string message)
{
Console.WriteLine("Alice send message {0}", message);
byte[] rawData = Encoding.UTF8.GetBytes(message);
byte[] encryptedData = null;
using (var aliceAlgo = new ECDiffieHellmanCng(aliceKey))
{
using (CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.GenericPublicBlob))
{
byte[] symmKey = aliceAlgo.DeriveKeyMaterial(bobPubKey);
Console.WriteLine("Alice create this symm key with Bobs public key information : {0}", Convert.ToBase64String(symmKey));
using (var aes = new AesCryptoServiceProvider())
{
aes.Key = symmKey;
aes.GenerateIV();
using (ICryptoTransform encryptor = aes.CreateEncryptor())
{
using (MemoryStream ms = new MemoryStream())
{
var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
await ms.WriteAsync(aes.IV, 0, aes.IV.Length);
cs.Write(rawData, 0, rawData.Length);
cs.Close();
encryptedData = ms.ToArray();
}
}
aes.Clear();
}
}
}
Console.WriteLine("Alice message is encrypted : {0}", Convert.ToBase64String(encryptedData));
return(encryptedData);
}
public static void TestShims()
{
using (var alg = new AesCryptoServiceProvider())
{
alg.BlockSize = 128;
Assert.Equal(128, alg.BlockSize);
var emptyIV = new byte[alg.BlockSize / 8];
alg.IV = emptyIV;
Assert.Equal(emptyIV, alg.IV);
alg.GenerateIV();
Assert.NotEqual(emptyIV, alg.IV);
var emptyKey = new byte[alg.KeySize / 8];
alg.Key = emptyKey;
Assert.Equal(emptyKey, alg.Key);
alg.GenerateKey();
Assert.NotEqual(emptyKey, alg.Key);
alg.KeySize = 128;
Assert.Equal(128, alg.KeySize);
alg.Mode = CipherMode.ECB;
Assert.Equal(CipherMode.ECB, alg.Mode);
alg.Padding = PaddingMode.PKCS7;
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
}
public static void Encrypt(byte[] bytesToEncrypt, string toReturn, string key)
{
byte[] encrypted = null;
AesCryptoServiceProvider aes = new AesCryptoServiceProvider
{
Key = ASCIIEncoding.ASCII.GetBytes(key),
Mode = CipherMode.CBC, Padding = PaddingMode.Zeros
};
aes.GenerateIV();
ICryptoTransform encrypt = aes.CreateEncryptor();
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encrypt, CryptoStreamMode.Write))
{
cs.Write(bytesToEncrypt, 0, bytesToEncrypt.Length);
cs.FlushFinalBlock();
encrypted = aes.IV.Concat(ms.ToArray()).ToArray();
}
}
BinaryWriter writer = new BinaryWriter(File.OpenWrite(toReturn + ".txt"));
writer.Write(encrypted);
writer.Flush();
writer.Close();
}
/// <summary>
/// encrypt data
/// </summary>
/// <param name="data">decrypted bytes</param>
/// <returns>ecrypted bytes</returns>
public byte[] Encrypt(byte[] data)
{
using (AesCryptoServiceProvider csp = new AesCryptoServiceProvider())
{
// load key & iv
csp.Key = key;
csp.GenerateIV();
byte[] iv = csp.IV;
int len = data.Length;
ICryptoTransform encryptor = csp.CreateEncryptor(key, iv);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
// Write all data to the crypto stream and flush it.
cs.Write(data, 0, len);
cs.FlushFinalBlock();
// write iv to output
long ms_len = ms.Length;
ms.Write(iv, 0, AES.DEFAULT_IV_SIZE);
byte[] output = ms.ToArray();
return(output);
}
}
}
}
public static void TestShims()
{
using (var alg = new AesCryptoServiceProvider())
{
alg.BlockSize = 128;
Assert.Equal(128, alg.BlockSize);
var emptyIV = new byte[alg.BlockSize / 8];
alg.IV = emptyIV;
Assert.Equal(emptyIV, alg.IV);
alg.GenerateIV();
Assert.NotEqual(emptyIV, alg.IV);
var emptyKey = new byte[alg.KeySize / 8];
alg.Key = emptyKey;
Assert.Equal(emptyKey, alg.Key);
alg.GenerateKey();
Assert.NotEqual(emptyKey, alg.Key);
alg.KeySize = 128;
Assert.Equal(128, alg.KeySize);
alg.Mode = CipherMode.ECB;
Assert.Equal(CipherMode.ECB, alg.Mode);
alg.Padding = PaddingMode.PKCS7;
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
}