public static byte[] EncryptData(byte[] output)
{
//byte[] unicodeBytes = Encoding.UTF8.GetBytes(plaintext);
using (Aes aesAlg = Aes.Create())
{
aesAlg.Padding = PaddingMode.PKCS7;
aesAlg.KeySize = 256;
aesAlg.Key = AES_KEY;
aesAlg.IV = AES_IV;
ICryptoTransform decryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream encryptedData = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(encryptedData, decryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(output, 0, output.Length);
cryptoStream.FlushFinalBlock();
return(encryptedData.ToArray());
}
}
}
}
private string Encrypt(string clearText)
{ // kullanıcı şifresinin kodlanarak şifrelendiği metotdur.
// şifreyi kodlanmış şekilde geri döndürür.
string EncryptionKey = "MAKV2SPBNI99212";
byte[] clearBytes = Encoding.Unicode.GetBytes(clearText);
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();
}
clearText = Convert.ToBase64String(ms.ToArray());
}
}
return(clearText);
}
public static void PaddedAes_PartialRead_Success()
{
using (Aes aes = Aes.Create())
{
aes.Mode = CipherMode.CBC;
aes.Key = aes.IV = new byte[] { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0xD, 0xE, 0xF, };
var memoryStream = new MemoryStream();
using (var cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write, leaveOpen: true))
{
cryptoStream.Write("Sample string that's bigger than cryptoAlg.BlockSize" u8);
cryptoStream.FlushFinalBlock();
}
memoryStream.Position = 0;
using (var cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Read))
{
cryptoStream.ReadByte(); // Partially read the CryptoStream before disposing it.
}
// No exception should be thrown.
}
}
/// <summary>
/// 加密字节数组
/// </summary>
public static byte[] Encrypt(byte[] decodeBytes, string key, bool needIV = false)
{
decodeBytes.CheckNotNull("decodeBytes");
using (Aes aes = Aes.Create())
{
aes.Key = CheckKey(key);
aes.Padding = PaddingMode.PKCS7;
aes.Mode = CipherMode.ECB;
byte[] ivBytes = { };
if (needIV)
{
aes.Mode = CipherMode.CBC;
aes.GenerateIV();
ivBytes = aes.IV;
}
using (ICryptoTransform encryptor = aes.CreateEncryptor())
{
byte[] encodeBytes = encryptor.TransformFinalBlock(decodeBytes, 0, decodeBytes.Length);
aes.Clear();
return(needIV ? ivBytes.Concat(encodeBytes).ToArray() : encodeBytes);
}
}
}
public void Modern_AES_256()
{
byte[] key = new byte[] { 0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe, 0x2b, 0x73, 0xae,
0xf0, 0x85, 0x7d, 0x77, 0x81, 0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61,
0x08, 0xd7, 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4 };
byte[] iv = new byte[] { 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, //0x0, 0x0, 0x0, 0x0, 0x0, 0x0
0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 }; //, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
AES a = new AES();
a.Key = key;
a.IV = iv;
byte[] test = new byte[48] {
0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34,
0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34,
0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34
};
byte[] cipher = a.Encrypt(test);
byte[] checkcipher = new byte[test.Length];
using (Aes check = Aes.Create())
{
check.Key = a.Key;
check.IV = iv;
ICryptoTransform encryptor = check.CreateEncryptor(check.Key, check.IV);
encryptor.TransformBlock(test, 0, test.Length, checkcipher, 0);
}
CollectionAssert.AreEqual(checkcipher, cipher);
byte[] clear = a.Decrypt(cipher);
CollectionAssert.AreEqual(test, clear);
}
public static byte[] CryptMessage2(this byte[] cmessage, bool forEncryption, byte[] m_Key, byte[] iVector)
{
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = m_Key;
aesAlg.IV = iVector;
aesAlg.Mode = CipherMode.CFB;
aesAlg.Padding = PaddingMode.None;
if (forEncryption)
{
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(cmessage, 0, cmessage.Length);
csEncrypt.FlushFinalBlock();
return(msEncrypt.ToArray());
}
}
}
else
{
using (ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV))
{
using (MemoryStream ms = new MemoryStream())
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write))
{
cs.Write(cmessage, 0, cmessage.Length); //here is the exception thrown
cs.FlushFinalBlock();
return(ms.ToArray());
}
}
}
}
}
public byte[] EncryptStringToBytes_Aes(string Jsonstring, byte[] Key, byte[] IV)
{
// Check arguments.
if (Jsonstring == null || Jsonstring.Length <= 0)
{
throw new ArgumentNullException("Jsonstring");
}
if (Key == null || Key.Length <= 0)
{
throw new ArgumentNullException("Key");
}
if (IV == null || IV.Length <= 0)
{
throw new ArgumentNullException("IV");
}
byte[] encrypted;
using (Aes aes = Aes.Create()){
aes.Key = Key;
aes.IV = IV;
// Create an Encryptor to perform stream transform
ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.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(Jsonstring);
}
encrypted = msEncrypt.ToArray();
}
}
}
return(encrypted);
}
private CryptoStream OpenAesStream(Stream streamObj, bool isEncrypt)
{
try
{
//Create a new instance of the default Aes implementation class
// and encrypt the stream.
Aes aes = Aes.Create();
byte[] key = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
byte[] iv = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16 };
if (isEncrypt)
{
//Create a CryptoStream for encrypt, pass it the FileStream, and encrypt
//it with the Aes class.
CryptoStream cryptStreamEncrypt = new CryptoStream(streamObj, aes.CreateEncryptor(key, iv), CryptoStreamMode.Write);
Debug.WriteLine("The encrypted stream is opened. =)");
return(cryptStreamEncrypt);
}
else
{
//Create a CryptoStream for decrypt, pass it the file stream, and decrypt
//it with the Aes class using the key and IV.
CryptoStream cryptStreamDecrypt = new CryptoStream(streamObj, aes.CreateDecryptor(key, iv), CryptoStreamMode.Read);
Debug.WriteLine("The decrypted stream is opened. =)");
return(cryptStreamDecrypt);
}
}
catch
{
//Inform the user that an exception was raised.
Debug.WriteLine("The encryption stream open failed. =(");
return(null);
throw;
}
}
public string Encrypt(string plainText, string key)
{
if (plainText == null || plainText.Length <= 0)
{
throw new ArgumentNullException("plainText");
}
byte[] encrypted;
byte[] IV;
// Create an Aes object
// with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Encoding.ASCII.GetBytes(key);
IV = aesAlg.IV;
// Create an encryptor 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($"{ToHexString(IV)}.{ToHexString(encrypted)}");
}
public byte[] Pack(string key, byte[] data)
{
byte[] iv = new byte[16];
byte[] kb = Encoding.UTF8.GetBytes(key);
RandomProvider.GetBytes(iv);
Aes aes = Aes.Create();
aes.KeySize = 256;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
aes.Key = kb;
aes.IV = iv;
using (var encryptor = aes.CreateEncryptor())
{
using (var m = new MemoryStream())
{
using (var c = new CryptoStream(m, encryptor, CryptoStreamMode.Write))
{
using (var w = new BinaryWriter(c))
{
w.Write(data);
}
var raw = m.ToArray();
using (var hmac = new HMACSHA256(kb))
{
byte[] hash = hmac.ComputeHash(raw);
List <byte> buffer = new List <byte>();
log.InfoFormat("iv: {0} hash: {1} text: {2}", iv.Length, hash.Length, raw.Length);
buffer.AddRange(iv);
buffer.AddRange(hash);
buffer.AddRange(raw);
return(buffer.ToArray());
}
}
}
}
}
private static byte[] EncryptStringToBytes_Aes(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");
}
byte[] encrypted;
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = key;
aesAlg.IV = iv;
var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (var swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
return(encrypted);
}
public static byte[] Encrypt(string texto, byte[] key, byte[] IV)
{
if (texto == null || texto.Length <= 0)
{
throw new ArgumentNullException("texto");
}
if (key == null || key.Length <= 0)
{
throw new ArgumentNullException("key");
}
if (IV == null || IV.Length <= 0)
{
throw new ArgumentNullException("IV");
}
byte[] encrypted;
using (Aes aes = Aes.Create())
{
aes.Key = key;
aes.IV = IV;
ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(texto);
}
encrypted = msEncrypt.ToArray();
}
}
}
return(encrypted);
}
private byte[] Encrypt(string data, out byte[] key, out byte[] IV)
{
if (data == null || data.Length <= 0)
{
throw new ArgumentNullException("data");
}
byte[] encrypted;
// Create an Aes object
// with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
key = aesAlg.Key;
IV = aesAlg.IV;
// Create an encryptor 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(data);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream.
return(encrypted);
}
public static void Main(string[] args)
{
//byte[] key = { 0x01, 0x23, 0x45, 0x67, 0x89, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xAB, 0xCD, 0xEF, 0x01, 0xCD, 0xEF };
//byte[] IV = { 0x67, 0x89, 0xAB, 0xAB, 0xCD, 0x01, 0x23, 0x45, 0x67, 0x89, 0x23, 0x45, 0xEF, 0x01, 0xCD, 0xEF };
if (args.Length != 2)
{
Console.WriteLine("usage: dotnet Encrypt <<file name>> <<password>>");
}
byte[] IV = new byte[16];
byte[] salt = new byte[16];
RandomNumberGenerator rng = RandomNumberGenerator.Create();
rng.GetBytes(IV);
rng.GetBytes(salt);
string password = "******";
Rfc2898DeriveBytes hasher = new Rfc2898DeriveBytes(password, salt);
byte[] key = hasher.GetBytes(16);
using (FileStream inputStream = File.OpenRead(@"Encryptor.cs"))
using (StreamReader reader = new StreamReader(inputStream))
{
using (Aes algorithm = Aes.Create())
using (FileStream outputStream = File.Create(@"..\Encryptor.bin"))
using (CryptoStream encryptedStream = new CryptoStream(
outputStream,
algorithm.CreateEncryptor(key, IV),
CryptoStreamMode.Write))
using (StreamWriter writer = new StreamWriter(encryptedStream))
{
writer.Write(reader.ReadToEnd());
}
}
Console.WriteLine("You have been encrypted.");
}
/// <summary>
/// Do not use this function at the moment!
/// </summary>
/// <param name="plainText"></param>
/// <param name="Key"></param>
/// <param name="IV"></param>
/// <returns></returns>
internal static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
{
if (plainText == null || plainText.Length <= 0)
{
throw new ArgumentNullException(nameof(plainText));
}
if (Key == null || Key.Length <= 0)
{
throw new ArgumentNullException(nameof(Key));
}
if (IV == null || IV.Length <= 0)
{
throw new ArgumentNullException(nameof(IV));
}
byte[] encrypted;
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
return(encrypted);
}
//Encripto un string usand el algporitmo AES, retorno bytes.
public static byte[] Encrypt(string plainText)
{
byte[] Key = KeyToBytes();
byte[] encrypted;
byte[] IV;
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.GenerateIV();
IV = aesAlg.IV;
aesAlg.Mode = CipherMode.CBC;
var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (var swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
var combinedIvCt = new byte[IV.Length + encrypted.Length];
Array.Copy(IV, 0, combinedIvCt, 0, IV.Length);
Array.Copy(encrypted, 0, combinedIvCt, IV.Length, encrypted.Length);
return(combinedIvCt);
}
private static byte[] AesEncryptStringToBytes(string plainText, byte[] key, byte[] iv)
{
if (plainText == null || plainText.Length <= 0)
{
throw new ArgumentNullException($"{nameof(plainText)}");
}
if (key == null || key.Length <= 0)
{
throw new ArgumentNullException($"{nameof(key)}");
}
if (iv == null || iv.Length <= 0)
{
throw new ArgumentNullException($"{nameof(iv)}");
}
byte[] encrypted;
using (Aes aes = Aes.Create())
{
aes.Mode = CipherMode.CBC; //remember this parameter
aes.Padding = PaddingMode.PKCS7; //remember this parameter
aes.Key = key;
aes.IV = iv;
using (MemoryStream memoryStream = new MemoryStream())
{
using (ICryptoTransform encryptor = aes.CreateEncryptor())
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
{
streamWriter.Write(plainText);
}
encrypted = memoryStream.ToArray();
}
}
return(encrypted);
}
/// <summary>
/// Encrypt a string using AES
/// </summary>
/// <param name="text">The string to encrypt</param>
/// <param name="keyString">The secret key</param>
/// <returns></returns>
public static string EncryptString(string text, string keyString)
{
string result = null;
using (Aes aes = Aes.Create())
{
aes.Padding = PaddingMode.PKCS7;
// AES-256 uses the same block size as AES-128 (the default) however the key size is larger (32 bytes).
byte[] key = Encoding.UTF8.GetBytes(keyString.Substring(0, AES_256_KEY_SIZE_BYTES));
using (var encryptor = aes.CreateEncryptor(key, aes.IV))
{
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
using (var swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(text);
}
var iv = aes.IV;
var decryptedContent = msEncrypt.ToArray();
byte[] byteResult = new byte[iv.Length + decryptedContent.Length];
Buffer.BlockCopy(iv, 0, byteResult, 0, iv.Length);
Buffer.BlockCopy(decryptedContent, 0, byteResult, iv.Length, decryptedContent.Length);
result = Convert.ToBase64String(byteResult);
}
}
}
return(result);
}
/// <summary>
/// AES 加密
/// </summary>
/// <param name="plainText">明文</param>
/// <param name="key">密钥</param>
/// <returns></returns>
public static string Encrypt(string plainText, string key)
{
string cipherText = string.Empty;
try
{
// Create an Aes object
// with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Encoding.UTF8.GetBytes(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);
}
cipherText = Convert.ToBase64String(msEncrypt.ToArray());
}
}
}
}
catch
{
cipherText = string.Empty;
}
return(cipherText);
}
public static string EncryptStringHex(string text, string keyString)
{
string result = null;
using (Aes aes = Aes.Create())
{
aes.Padding = PaddingMode.PKCS7;
byte[] key = Encoding.UTF8.GetBytes(keyString.Substring(0, AES_256_KEY_SIZE_BYTES));
using (var encryptor = aes.CreateEncryptor(key, aes.IV))
{
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (var swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(text);
}
}
var iv = aes.IV;
byte[] data = msEncrypt.ToArray();
byte[] byteResult = new byte[iv.Length + data.Length];
Buffer.BlockCopy(iv, 0, byteResult, 0, iv.Length);
Buffer.BlockCopy(data, 0, byteResult, iv.Length, data.Length);
result = BitConverter.ToString(byteResult).Replace("-", "");
}
}
}
return(result);
}
public byte[] Encrypt(string Text, byte[] Key, byte[] IV)
{
if (Text == null || Text.Length <= 0)
{
throw new ArgumentException("Text");
}
if (Key == null || Key.Length <= 0)
{
throw new ArgumentException("Key");
}
if (IV == null || IV.Length <= 0)
{
throw new ArgumentException("IV");
}
byte[] eData;
//Aes object
using (Aes aes = Aes.Create())
{
aes.Key = Key;
aes.IV = IV;
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(aes.Key, aes.IV), CryptoStreamMode.Write))
{
using (StreamWriter sw = new StreamWriter(cs))
{
sw.Write(Text);
}
eData = ms.ToArray();
}
}
}
return(eData);
}
private static string DecryptPrivateKey(string content, string password)
{
byte[] passwordHash = GenerateHash(password);
byte[] contentBytes = Convert.FromBase64String(content);
byte[] decrypted;
int decryptedByteCount = 0;
byte[] initialVector = new byte[16];
using (MemoryStream from = new MemoryStream(contentBytes)) {
from.Read(initialVector, 0, 16);
using (Aes aes = Aes.Create()) {
try {
aes.Key = passwordHash;
aes.IV = initialVector;
aes.Mode = CipherMode.ECB;
aes.CreateEncryptor(aes.Key, aes.IV);
try {
using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV)) {
using (CryptoStream reader = new CryptoStream(from, decryptor, CryptoStreamMode.Read)) {
decrypted = new byte[content.Length];
decryptedByteCount = reader.Read(decrypted, 0, decrypted.Length);
}
}
} catch (Exception e) {
return(string.Empty);
}
} finally {
aes.Clear();
}
}
}
return(Encoding.UTF8.GetString(decrypted, 0, decryptedByteCount));
}
/// <summary>
/// AES加密算法（ECB）
/// </summary>
/// <param name="plainText">明文字符串</param>
/// <param name="privateKey">16位密钥</param>
/// <param name="en">编码，默认Utf8</param>
/// <returns>将加密后的密文转换为Base64编码，以便显示</returns>
public static string AESEncrypt(string plainText, string privateKey, Encoding en)
{
// password = ShortMD5(password, charsetName);
byte[] plainBytes = en.GetBytes(plainText);
byte[] keyBytes = en.GetBytes(privateKey);
Aes kgen = Aes.Create("AES");
kgen.Mode = CipherMode.ECB;
kgen.Key = keyBytes;
ICryptoTransform cTransform = kgen.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(plainBytes, 0, plainBytes.Length);
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
////分组加密算法
//Aes des = Aes.Create("AES");
//des.Mode = CipherMode.ECB;
////SymmetricAlgorithm des = Rijndael.Create();
//byte[] inputByteArray = Encoding.UTF8.GetBytes(plainText);//得到需要加密的字节数组
////设置密钥及密钥向量
//des.Key = Encoding.UTF8.GetBytes(privateKey);
////des.IV = _key1;
//byte[] cipherBytes = null;
//using (MemoryStream ms = new MemoryStream())
//{
// using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
// {
// cs.Write(inputByteArray, 0, inputByteArray.Length);
// cs.FlushFinalBlock();
// cipherBytes = ms.ToArray();//得到加密后的字节数组
// cs.Close();
// ms.Close();
// }
//}
//return Convert.ToBase64String(cipherBytes);
}
// encriptar y desencriptar adaptados de https://docs.microsoft.com/es-es/dotnet/api/system.security.cryptography.aes?redirectedfrom=MSDN&view=netframework-4.7.2
private static byte[] EncriptarStringABytes_Aes(string pTextoPlano)
{
// Revisar parámetro
if (pTextoPlano == null || pTextoPlano.Length <= 0)
{
throw new ArgumentNullException("pTextoPlano");
}
byte[] encriptado;
// Crear un objeto Aes con la clave y vector de inicializacion especificados
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = KEY;
aesAlg.IV = IV;
// Crear un encriptador para realizar la transformación del stream
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Crear streams usados en la encriptacion
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
//escribir datos en el stream
swEncrypt.Write(pTextoPlano);
}
encriptado = msEncrypt.ToArray();
}
}
}
// devolver los bytes encriptados del stream de memoria
return(encriptado);
}
static byte[] EncryptAES(string plainText, byte[] Key)
{
byte[] encrypted;
byte[] IV;
// Create a new Aes
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Key;
aesAlg.GenerateIV();
IV = aesAlg.IV;
aesAlg.Mode = CipherMode.CBC;
// Create encryptor
var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (var msEncrypt = new MemoryStream())
{
using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (var swEncrypt = new StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
var combinedIvCt = new byte[IV.Length + encrypted.Length];
Array.Copy(IV, 0, combinedIvCt, 0, IV.Length);
Array.Copy(encrypted, 0, combinedIvCt, IV.Length, encrypted.Length);
// Return the encrypted bytes from the memory stream.
return(combinedIvCt);
}
/// <summary>
/// AES encrypt ( no IV)
/// </summary>
/// <param name="data">Raw data</param>
/// <param name="key">Key, requires 32 bits</param>
/// <returns>Encrypted string</returns>
public static string AESEncrypt(string data, string key)
{
Check.Argument.IsNotEmpty(data, nameof(data));
Check.Argument.IsNotEmpty(key, nameof(key));
Check.Argument.IsNotOutOfRange(key.Length, 32, 32, nameof(key));
using (MemoryStream Memory = new MemoryStream())
{
using (Aes aes = Aes.Create())
{
byte[] plainBytes = Encoding.UTF8.GetBytes(data);
Byte[] bKey = new Byte[32];
Array.Copy(Encoding.UTF8.GetBytes(key.PadRight(bKey.Length)), bKey, bKey.Length);
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.PKCS7;
aes.KeySize = 128;
//aes.Key = _key;
aes.Key = bKey;
//aes.IV = _iV;
using (CryptoStream cryptoStream = new CryptoStream(Memory, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
try
{
cryptoStream.Write(plainBytes, 0, plainBytes.Length);
cryptoStream.FlushFinalBlock();
return(Convert.ToBase64String(Memory.ToArray()));
}
catch (Exception ex)
{
return(null);
}
}
}
}
}
public static string EncryptString(string text, string key)
{
return(text);
if (text == null || text.Length <= 0)
{
throw new ArgumentNullException("text is null");
}
byte[] encrypted;
var keyBytes = Encoding.UTF8.GetBytes(key);
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = keyBytes;
var iv = aesAlg.IV;
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
// write iv
msEncrypt.Write(iv, 0, iv.Length);
//Write all data to the stream.
swEncrypt.Write(text);
}
encrypted = msEncrypt.ToArray();
}
}
}
return(Convert.ToBase64String(encrypted));
}
public static byte[] Crypt(string plainText)
{
// Check arguments.
if (plainText == null || plainText.Length <= 0)
{
throw new ArgumentNullException(nameof(plainText));
}
byte[] encrypted;
// Create an Aes object
// with the specified key and IV.
using (Aes aesAlg = Aes.Create())
{
aesAlg.Key = Cle;
aesAlg.IV = Iv;
// Create an encryptor 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>
/// Method to encrypt plain text using AES
/// </summary>
/// <param name="plain">Plain text</param>
/// <param name="key">Secret key used to encrypt</param>
/// <param name="keySize">Size of the secret key</param>
/// <returns>Cipher and IV</returns>
public Tuple <byte[], byte[]> Encrypt(string plain, string key, int keySize = 256)
{
byte[] encrypted;
byte[] hash;
byte[] iv;
using (Aes aes = Aes.Create())
{
// Set AES algorithm properties to match the one used in front-end
aes.KeySize = keySize;
aes.BlockSize = aes.KeySize / 2;
Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(key, 16, 1000);
hash = rfc2898DeriveBytes.GetBytes(32);
iv = rfc2898DeriveBytes.Salt;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.PKCS7;
aes.Key = hash;
aes.IV = iv;
ICryptoTransform aesEncryptor = aes.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, aesEncryptor, CryptoStreamMode.Write))
{
using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
{
streamWriter.Write(plain);
}
encrypted = memoryStream.ToArray();
}
}
}
return(new Tuple <byte[], byte[]>(encrypted, iv));
}
public static string EncryptData(string inputText)
{
string EncryptionKey = "MAKV2SPBNI99212";
byte[] clearBytes = Encoding.Unicode.GetBytes(inputText);
var returnText = "";
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();
}
returnText = Convert.ToBase64String(ms.ToArray());
}
}
return(returnText);
}
private static byte[] AesEncryptDirectKey(Aes aes, byte[] key, byte[] iv, byte[] plainBytes)
{
using (MemoryStream output = new MemoryStream())
using (CryptoStream cryptoStream = new CryptoStream(output, aes.CreateEncryptor(key, iv), CryptoStreamMode.Write))
{
cryptoStream.Write(plainBytes, 0, plainBytes.Length);
cryptoStream.FlushFinalBlock();
return output.ToArray();
}
}
private static void RandomKeyRoundtrip(Aes aes)
{
byte[] decryptedBytes;
byte[] encryptedBytes;
using (MemoryStream input = new MemoryStream(s_multiBlockBytes))
using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateEncryptor(), CryptoStreamMode.Read))
using (MemoryStream output = new MemoryStream())
{
cryptoStream.CopyTo(output);
encryptedBytes = output.ToArray();
}
Assert.NotEqual(s_multiBlockBytes, encryptedBytes);
using (MemoryStream input = new MemoryStream(encryptedBytes))
using (CryptoStream cryptoStream = new CryptoStream(input, aes.CreateDecryptor(), CryptoStreamMode.Read))
using (MemoryStream output = new MemoryStream())
{
cryptoStream.CopyTo(output);
decryptedBytes = output.ToArray();
}
Assert.Equal(s_multiBlockBytes, decryptedBytes);
}
