public static bool TestAlgorithms(SymmetricAlgorithm encAlgorithm, SymmetricAlgorithm decAlgorithm, int maxLength, int iterations)
{
Random rand = new Random();
for (int i = 0; i < iterations; i++)
{
// Create random data, key, IV, mode
//
byte[] key = new byte[KeySizeBytes[rand.Next(KeySizeBytes.Length)]];
rand.NextBytes(key);
byte[] data = new byte[rand.Next(1, maxLength + 1)];
rand.NextBytes(data);
byte[] IV = new byte[BlockSizeBytes];
rand.NextBytes(IV);
// Encrypt the data
//
byte[] encryptedData;
encAlgorithm.Key = key;
encAlgorithm.IV = IV;
ICryptoTransform transform = encAlgorithm.CreateEncryptor();
encryptedData = transform.TransformFinalBlock(data, 0, data.Length);
// Decrypt the data
//
byte[] decryptedData;
decAlgorithm.Key = key;
decAlgorithm.IV = IV;
transform = decAlgorithm.CreateDecryptor();
decryptedData = transform.TransformFinalBlock(encryptedData, 0, encryptedData.Length);
if (!CompareBytes(data, decryptedData))
{
Console.WriteLine("ERROR - roundtrip encrypt/decrypt failed!\n");
Console.WriteLine("Encryption algorithm: {0}", encAlgorithm.ToString());
Console.WriteLine("Decryption algorithm: {0}", decAlgorithm.ToString());
Console.WriteLine("Original data: {0}", ByteArrayToString(data));
Console.WriteLine("Roundtrip data: {0}", ByteArrayToString(decryptedData));
Console.WriteLine("Key: {0}", ByteArrayToString(key));
Console.WriteLine("IV: {0}", ByteArrayToString(IV));
return false;
}
}
return true;
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="cipherText">密文字符串</param>
/// <returns>返回解密后的明文字符串</returns>
public static string AESDecrypt(string showText, string Key)
{
showText = showText.Replace("%3d", "=").Replace(" ", "+").Replace("%2b", "+");
byte[] cipherText = Convert.FromBase64String(showText);
SymmetricAlgorithm des = Rijndael.Create();
des.Key = Encoding.UTF8.GetBytes(Key);
des.IV = _aesKey;
byte[] decryptBytes = new byte[cipherText.Length];
using (MemoryStream ms = new MemoryStream(cipherText))
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
{
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Close();
ms.Close();
}
}
return(Encoding.UTF8.GetString(decryptBytes).Replace("\0", "")); ///将字符串后尾的'\0'去掉
}
/// <summary>
/// 通用 SymmetricAlgorithm 解密函數. 可指定 (AES, DES, RC2, Rijndael, TripleDES) 演算法解密.
/// </summary>
/// <param name="symAlg"></param>
/// <param name="baEncrypt"></param>
/// <returns></returns>
public static byte[] Decrypt(SymmetricAlgorithm symAlg, byte[] baEncrypt)
{
// usage:
//AesCryptoServiceProvider aesCSP = new AesCryptoServiceProvider();
//aesCSP.GenerateKey();
//aesCSP.GenerateIV();
//byte[] baEncrypt1 = Encrypt(aesCSP, baPlainText);
//byte[] baDecrypt1 = Decrypt(aesCSP, baPlainText);
try
{
ICryptoTransform transform1 = symAlg.CreateDecryptor();
byte[] baDecrypt = transform1.TransformFinalBlock(baEncrypt, 0, baEncrypt.Length);
symAlg.Clear();
return(baDecrypt);
}
catch (Exception e1)
{
msError = e1.Message;
return(null);
}
}
/// <summary>
/// 解密字符串
/// </summary>
/// <param name="Value">要解密字符串</param>
/// <returns>解密了的字符串</returns>
public string DecryptString(string Value)
{
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
byte[] byt;
mCSP = new DESCryptoServiceProvider();
ct = mCSP.CreateDecryptor(Convert.FromBase64String(CKEY), Convert.FromBase64String(CIV));
byt = Convert.FromBase64String(Value);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(byt, 0, byt.Length);
cs.FlushFinalBlock();
cs.Close();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
/// <summary>
/// AES decoder
/// </summary>
/// <param name="str">string you want decode with Base64.</param>
/// <returns>string </returns>
public static string DecodeAES(string base64Str)
{
try {
byte[] cipherText = Convert.FromBase64String(base64Str);
SymmetricAlgorithm des = Rijndael.Create();
des.Key = Encoding.UTF8.GetBytes(_aes_key);
des.IV = _aes_IV;
byte[] decryptBytes = new byte[cipherText.Length];
using (MemoryStream ms = new MemoryStream(cipherText)) {
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read)) {
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Close();
ms.Close();
}
}
return(Encoding.UTF8.GetString(decryptBytes).Replace("\0", "")); ///remove \0
} catch (Exception e) {
XLAFInnerLog.Error(e.ToString());
}
return("");
}
public override byte[] Decrypt(byte[] encryptedValue, byte[] initializationVector = null)
{
int dataOffset = 0;
if (initializationVector == null)
{
initializationVector = new byte[algorithm.BlockSize / 8];
Buffer.BlockCopy(encryptedValue, 0, initializationVector, 0, initializationVector.Length);
dataOffset = initializationVector.Length;
}
using (var output = new MemoryStream())
{
using (var cryptoOutput = new CryptoStream(output, algorithm.CreateDecryptor(secretKey, initializationVector), CryptoStreamMode.Write))
{
cryptoOutput.Write(encryptedValue, dataOffset, encryptedValue.Length - dataOffset);
}
return(output.ToArray());
}
}
/// <summary>
/// 使用AES解密字符串,按128位处理key
/// </summary>
/// <param name="content">内容</param>
/// <param name="key">秘钥，需要128位、256位.....</param>
/// <returns>UTF8解密结果</returns>
private static string AesDecrypt(string content, string key, bool autoHandle = true)
{
byte[] keyArray = Encoding.UTF8.GetBytes(key);
if (autoHandle)
{
keyArray = GetAesKey(keyArray, key);
}
byte[] toEncryptArray = Convert.FromBase64String(content);
SymmetricAlgorithm des = Aes.Create();
des.Key = keyArray;
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = des.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray));
}
/// <summary>
/// Decrypt
/// </summary>
/// <param name="securityTxt"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string Decrypt(string securityTxt, string key, VECTOR vector)
{
try
{
var bytes = Convert.FromBase64String(securityTxt);
SymmetricAlgorithm des = Rijndael.Create();
des.Key = Encoding.Default.GetBytes(key);
des.IV = vector.ToByteArray();
using (MemoryStream ms = new MemoryStream())
{
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(bytes, 0, bytes.Length);
cs.FlushFinalBlock();
return(Convert.ToBase64String(ms.ToArray()));
}
}
catch (Exception)
{
return(string.Empty);
}
}
/// <summary>
/// Decrypt string
/// </summary>
/// <param name="crypt_str"></param>
/// <returns></returns>
string Decrypt(string crypt_str)
{
// Получаем массив байт
byte[] crypt_data = Convert.FromBase64String(crypt_str);
// Алгоритм
SymmetricAlgorithm sa_out = Rijndael.Create();
// Объект для преобразования данных
ICryptoTransform ct_out = sa_out.CreateDecryptor(
(new PasswordDeriveBytes(encryPass, null)).GetBytes(16),
new byte[16]);
// Поток
MemoryStream ms_out = new MemoryStream(crypt_data);
// Расшифровываем поток
CryptoStream cs_out = new CryptoStream(ms_out, ct_out, CryptoStreamMode.Read);
// Создаем строку
StreamReader sr_out = new StreamReader(cs_out);
string source_out = sr_out.ReadToEnd();
return(source_out);
}
/// <summary>
/// 解密字符串
/// </summary>
/// <param name="Value">要解密的字符串</param>
/// <returns>string</returns>
public static string DecryptString(string Value)
{
ICryptoTransform ct; //定义基本的加密转换运算
MemoryStream ms; //定义内存流
CryptoStream cs; //定义将数据流链接到加密转换的流
byte[] byt;
ct = mCSP.CreateDecryptor(Convert.FromBase64String(CKEY), Convert.FromBase64String(CIV)); //用指定的密钥和初始化向量创建对称数据解密标准
var bytes = StringToBytes(Value);
Value = Convert.ToBase64String(bytes);
byt = Convert.FromBase64String(Value); //将Value(Base 64)字符转换成字节数组
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(byt, 0, byt.Length);
cs.FlushFinalBlock();
cs.Close();
return(Encoding.UTF8.GetString(ms.ToArray())); //将字节数组中的所有字符解码为一个字符串
}
public static string DecryptString(byte[] data)
{
SymmetricAlgorithm algo = SymmetricAlgorithm.Create();
algo.Key = GetByte(Key);
MemoryStream mStream = new MemoryStream();
byte[] byteData = new byte[algo.IV.Length];
Array.Copy(data, byteData, byteData.Length);
algo.IV = byteData;
int readFrom = 0;
readFrom += algo.IV.Length;
CryptoStream myCrypto = new CryptoStream(mStream, algo.CreateDecryptor(), CryptoStreamMode.Write);
myCrypto.Write(data, readFrom, data.Length - readFrom);
myCrypto.FlushFinalBlock();
return(Encoding.UTF8.GetString(mStream.ToArray()));
}
public string DesEncriptar(string Value)
{
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
byte[] byt;
ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV);
byt = Convert.FromBase64String(Value);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(byt, 0, byt.Length);
cs.FlushFinalBlock();
cs.Close();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
// AES 解密
public string AESDecrypt(byte[] data)
{
SymmetricAlgorithm aes = Rijndael.Create();
aes.Key = keyArray;
aes.IV = ivArray;
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.Zeros;
byte[] decryptBytes = new byte[data.Length];
using (MemoryStream ms = new MemoryStream(data))
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read))
{
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Close();
ms.Close();
}
}
aes.Clear();
return(System.Text.Encoding.Unicode.GetString(decryptBytes).Replace("\0", " "));
}
public static string DecryptData(SymmetricAlgorithm aesAlgorithm, string value)
{
// Create a decryptor from the aes algorithm
ICryptoTransform decryptor = aesAlgorithm.CreateDecryptor(aesAlgorithm.Key, aesAlgorithm.IV);
byte[] encryptedDataBuffer = Encoding.ASCII.GetBytes(value);
// Create a memorystream to write the decrypted data in it
using (MemoryStream ms = new MemoryStream(encryptedDataBuffer))
{
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
{
using (StreamReader reader = new StreamReader(cs))
{
// Reutrn all the data from the streamreader
return(reader.ReadLine());
}
}
}
}
public static string Decrypt(string str)
{
SymmetricAlgorithm des = Rijndael.Create();
var kb = Ultra.Web.Core.Common.HashDigest.StringDigest(PwdKey);
des.Key = kb;
des.IV = _key1;
var cipherText = Ultra.Web.Core.Common.ByteStringUtil.ByteArrayFromHexStr(str);
byte[] decryptBytes = new byte[cipherText.Length];
using (MemoryStream ms = new MemoryStream(cipherText))
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
{
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Close();
ms.Close();
return(Encoding.UTF8.GetString(decryptBytes));
}
}
}
public override bool Decrypt(NetIncomingMessage msg)
{
int unEncLenBits = (int)msg.ReadUInt32();
var ms = new MemoryStream(msg.m_data, 4, msg.LengthBytes - 4);
var cs = new CryptoStream(ms, m_algorithm.CreateDecryptor(), CryptoStreamMode.Read);
var byteLen = NetUtility.BytesToHoldBits(unEncLenBits);
var result = m_peer.GetStorage(byteLen);
cs.Read(result, 0, byteLen);
cs.Close();
// TODO: recycle existing msg
msg.m_data = result;
msg.m_bitLength = unEncLenBits;
msg.m_readPosition = 0;
return(true);
}
//Benton Stark 10-21-2013
/// <summary>
/// Decrypt ciphertext data using specified symmetric cipher and optional IV.
/// </summary>
/// <param name="algo">Symmetric cipher algorithm object.</param>
/// <param name="key">Symmetric algorithm key.</param>
/// <param name="iv">Optional IV value (can be null or empty byte array).</param>
/// <param name="mode">Symmetric cipher block mode.</param>
/// <param name="ciphertext">Ciphertext data to decrypt.</param>
/// <returns>Cleartext data.</returns>
public static byte[] Decrypt(SymmetricAlgorithm algo, byte[] key, byte[] iv, CipherMode mode, byte[] ciphertext)
{
if (algo == null)
{
throw new ArgumentNullException("algo");
}
if (key == null)
{
throw new ArgumentNullException("key");
}
if (ciphertext == null)
{
throw new ArgumentNullException("cleartext");
}
algo.Mode = mode;
ICryptoTransform d = algo.CreateDecryptor(key, iv);
byte[] cleartext = new byte[ciphertext.Length];
d.TransformBlock(ciphertext, 0, ciphertext.Length, cleartext, 0);
return(cleartext);
}
private static byte[] DecryptBytes(SymmetricAlgorithm alg, byte[] message)
{
if ((message == null) || (message.Length == 0))
{
return(message);
}
if (alg == null)
{
throw new ArgumentNullException("alg");
}
using (var stream = new MemoryStream())
using (var decryptor = alg.CreateDecryptor())
using (var encrypt = new CryptoStream(stream, decryptor, CryptoStreamMode.Write))
{
encrypt.Write(message, 0, message.Length);
encrypt.FlushFinalBlock();
return(stream.ToArray());
}
}
/// <summary>
/// Decrypt the byte array.
/// </summary>
/// <param name="CypherText"></param>
/// <param name="key"></param>
/// <returns></returns>
private static string decrypt(byte[] CypherText, SymmetricAlgorithm key)
{
// Create a memory stream to the passed buffer.
MemoryStream ms = new MemoryStream(CypherText);
// Create a CryptoStream using the memory stream and the
// CSP DES key.
CryptoStream encStream = new CryptoStream(ms, key.CreateDecryptor(), CryptoStreamMode.Read);
// Create a StreamReader for reading the stream.
StreamReader sr = new StreamReader(encStream);
// Read the stream as a string.
string val = sr.ReadLine();
// Close the streams.
sr.Close();
encStream.Close();
ms.Close();
return(val);
}
/// <summary>
/// Creates an <see cref="EncryptionReader"/> instance using the specified stream.
/// </summary>
/// <remarks>
/// The <see cref="EncryptionReader"/> class is the preferred method to decrypt data.
/// It is also more performant. The other decryption methods defer to the EncryptionReader
/// class for actual decryption.
/// </remarks>
/// <param name="stream">The stream the encrypted data will be read from.</param>
/// <returns>An instance of the <see cref="EncryptionReader"/> class.</returns>
public EncryptionReader CreateStreamReader(Stream stream)
{
// Read salt from input stream
byte[] salt = new byte[SaltLength];
if (stream.Read(salt, 0, salt.Length) < SaltLength)
{
throw new ArgumentOutOfRangeException("Reached end of input stream before reading encryption metadata.");
}
// Create symmetric algorithm
SymmetricAlgorithm algorithm = CreateAlgorithm();
algorithm.Padding = PaddingMode.PKCS7;
// Create key and IV
byte[] key, iv;
GenerateKeyAndIv(algorithm, salt, out key, out iv);
// Create EncryptionReader
ICryptoTransform decryptor = algorithm.CreateDecryptor(key, iv);
CryptoStream cs = new CryptoStream(stream, decryptor, CryptoStreamMode.Read);
return(new EncryptionReader(algorithm, decryptor, stream));
}
private byte[] \uE001(SymmetricAlgorithm \uE000, byte[] \uE001, byte[] \uE002, byte[] \uE003)
{
byte[] result;
using (MemoryStream memoryStream = new MemoryStream())
{
ICryptoTransform transform = \uE000.CreateDecryptor(\uE002, \uE003);
using (MemoryStream memoryStream2 = new MemoryStream(\uE001))
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream2, transform, CryptoStreamMode.Read))
{
byte[] array = new byte[1024];
for (int i = cryptoStream.Read(array, 0, array.Length); i > 0; i = cryptoStream.Read(array, 0, array.Length))
{
memoryStream.Write(array, 0, i);
}
}
}
result = memoryStream.ToArray();
}
return(result);
}
/// <summary>
/// 使用AES解密字符串,按128位处理key
/// </summary>
/// <param name="toDecryptArray">内容</param>
/// <param name="key">秘钥，需要128位、256位.....</param>
/// <returns>UTF8解密结果</returns>
public static byte[] AesDecrypt(byte[] toDecryptArray, string key, bool autoHandle = true)
{
byte[] keyArray = Encoding.UTF8.GetBytes(key);
if (autoHandle)
{
keyArray = GetAesKey(AESBit.Bit128, key);
}
SymmetricAlgorithm aes = Aes.Create();
aes.Key = keyArray;
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = aes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toDecryptArray, 0, toDecryptArray.Length);
//return Encoding.UTF8.GetString(resultArray);
return(resultArray);
}
/// <summary>
/// Decrypt a string. Usage for license key
/// </summary>
/// <param name="text"></param>
/// <returns>Decrypted sting or null if nota able to Decrypt</returns>
public static string Decrypt(string text)
{
try
{
byte[] key = new byte[8] {
1, 2, 3, 4, 5, 6, 7, 8
};
byte[] iv = new byte[8] {
1, 2, 3, 4, 5, 6, 7, 8
};
SymmetricAlgorithm algorithm = DES.Create();
ICryptoTransform transform = algorithm.CreateDecryptor(key, iv);
byte[] inputbuffer = Convert.FromBase64String(text);
byte[] outputBuffer = transform.TransformFinalBlock(inputbuffer, 0, inputbuffer.Length);
return(Encoding.Unicode.GetString(outputBuffer));
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="cipherText">密文字符串</param>
/// <param name="key">密钥</param>
/// <param name="encoding">编码格式</param>
/// <returns>返回解密后的明文字符串</returns>
public static string Decrypt(string cipherText, string key, Encoding encoding = null)
{
encoding = encoding ?? JlEncoding.Default;
byte[] byteCipherText = Convert.FromBase64String(cipherText);
SymmetricAlgorithm des = Rijndael.Create();
des.Key = encoding.GetBytes(key);
des.IV = _key1;
byte[] decryptBytes = new byte[cipherText.Length];
using (MemoryStream ms = new MemoryStream(byteCipherText))
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
{
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Close();
ms.Close();
}
}
return(Encoding.UTF8.GetString(decryptBytes).Replace("\0", "")); //将字符串后尾的'\0'去掉
}
/// <summary>
/// Desencripta o dado solicitado.
/// </summary>
/// <param name="cryptoText">Texto a ser descriptografado.</param>
/// <returns>Texto descriptografado.</returns>
public virtual string Decrypt(string textoCriptografado)
{
// Converte a base 64 string em num array de bytes
byte[] cryptoByte = Convert.FromBase64String(textoCriptografado);
byte[] keyByte = GetKey();
// Seta a chave privada
_algorithm.Key = keyByte;
SetIV();
// Interface de criptografia / Cria objeto de descriptografia
ICryptoTransform cryptoTransform = _algorithm.CreateDecryptor();
try
{
MemoryStream _memoryStream = new MemoryStream(cryptoByte, 0, cryptoByte.Length);
CryptoStream _cryptoStream = new CryptoStream(_memoryStream, cryptoTransform, CryptoStreamMode.Read);
// Busca resultado do CryptoStream
StreamReader _streamReader = new StreamReader(_cryptoStream);
return(_streamReader.ReadToEnd());
}
catch
{
return(null);
}
}
private string RODecryptString(string inStr, string inKey)
{
try
{
var hasher = new ROHasher(DesMD5);
byte[] encryptedData = Convert.FromBase64String(inStr);
byte ver = encryptedData[0];
int ivSize = 0;
if (ver == 1)
{
ivSize = 8;
}
else if (ver == 2)
{
ivSize = 16;
}
else
{
throw new Exception("unsupported encryption version");
}
SymmetricAlgorithm cipher = ver == 1 ? (SymmetricAlgorithm) new TripleDESCryptoServiceProvider() : (SymmetricAlgorithm) new AesCryptoServiceProvider();
try
{
cipher.IV = encryptedData.Skip(1).Take(ivSize).ToArray();
cipher.Mode = CipherMode.CBC;
cipher.Key = hasher.ComputeHash(UTF8Encoding.UTF8.GetBytes(inKey)).Take(DesMD5 ? 16 : 32).ToArray();
string outStr = UTF8Encoding.UTF8.GetString(cipher.CreateDecryptor().TransformFinalBlock(encryptedData.Skip(1 + ivSize).ToArray(), 0, encryptedData.Length - (1 + ivSize)));
return(outStr);
}
catch
{
return(null);
}
}
catch {
return(null);
}
}
/// <summary>
/// Decriptografa a string
/// </summary>
/// <param name="pdstCriptografia">string criptografada</param>
/// <returns>string decriptografada</returns>
internal string Decriptografar(string p_strValorCriptografado)
{
//Declaração de variáveis
MemoryStream objStream = null;
CryptoStream objCriptoStream = null;
SymmetricAlgorithm objRijndael = null;
string strCriptografia = null;
byte[] aryString;
//Objeto responsável pela manipulação dos dados
objStream = new MemoryStream();
//Recupera o valor do dataset
strCriptografia = p_strValorCriptografado;
//Monta uma array de bytes com o texto a ser criptografado
aryString = Convert.FromBase64String(strCriptografia);
//Cria o objeto de criptografia default "Rijndael"
objRijndael = SymmetricAlgorithm.Create();
//Atribui as chaves
objRijndael.Key = Convert.FromBase64String(CriptografiaInfo.KEY);
objRijndael.IV = Convert.FromBase64String(CriptografiaInfo.IV);
//Objeto responsável pela conversão
objCriptoStream = new CryptoStream(objStream, objRijndael.CreateDecryptor(objRijndael.Key, objRijndael.IV), CryptoStreamMode.Write);
//Decriptografa a string
objCriptoStream.Write(aryString, 0, aryString.Length);
objCriptoStream.FlushFinalBlock();
objCriptoStream.Close();
//Converte o retorno para o formato UTF-8
strCriptografia = Encoding.UTF8.GetString(objStream.ToArray());
//Retorna o dataset com o resultado
return(strCriptografia);
}
public AesXtsTransform(byte[] tweakBytes, byte[] dataAesKey, byte[] tweakAesKey, bool encrypt)
{
if (tweakBytes == null)
{
throw new InvalidDataException("Tweak bytes not provided");
}
if (dataAesKey == null)
{
throw new InvalidDataException("Data AES key not provided");
}
if (tweakAesKey == null)
{
throw new InvalidDataException("Tweak AES key not provided");
}
if (tweakBytes.Length != 16)
{
throw new InvalidDataException("Tweak bytes not 16 bytes");
}
if (dataAesKey.Length != 16)
{
throw new InvalidDataException("Data AES key not 16 bytes");
}
if (tweakAesKey.Length != 16)
{
throw new InvalidDataException("Tweak AES not 16 bytes");
}
_tweakBytes = tweakBytes;
_symmetricAlgorithm = Aes.Create();
_symmetricAlgorithm.Padding = PaddingMode.None;
_symmetricAlgorithm.Mode = CipherMode.ECB;
byte[] nullIv = new byte[16];
_tweakEncryptor = _symmetricAlgorithm.CreateEncryptor(tweakAesKey, nullIv);
_dataTransform = encrypt ? _symmetricAlgorithm.CreateEncryptor(dataAesKey, nullIv) :
_symmetricAlgorithm.CreateDecryptor(dataAesKey, nullIv);
BlockSize = _symmetricAlgorithm.BlockSize / 8;
}
public void aesDekriptiranje(string file, string decryptedFile)
{
FileStream fstreamU = File.OpenRead(file), fstreamO = File.OpenWrite(decryptedFile);
MachineKeyStore = 128 * 1024;
byte[] bytes = new byte[MachineKeyStore];
int read = -1;
SymmetricAlgorithm sma = Rijndael.Create();
sma.Mode = CipherMode.ECB;
TextReader tr = new StreamReader("tajni_kljuc.txt");
string secretKey = tr.ReadLine();
sma.Key = Convert.FromBase64String(secretKey);
tr.Close();
CryptoStream cin = new CryptoStream(fstreamU, sma.CreateDecryptor(), CryptoStreamMode.Read);
BinaryReader br = new BinaryReader(cin);
long lSize = br.ReadInt64();
long numReads = lSize / MachineKeyStore;
long slack = (long)lSize % MachineKeyStore;
for (int i = 0; i < numReads; ++i)
{
read = cin.Read(bytes, 0, bytes.Length);
fstreamO.Write(bytes, 0, read);
}
if (slack > 0)
{
read = cin.Read(bytes, 0, (int)slack);
fstreamO.Write(bytes, 0, read);
}
fstreamO.Flush();
fstreamO.Close();
fstreamO.Dispose();
}
public static MFTestResults Test_EncryptCsp(SymmetricAlgorithm csp1, SymmetricAlgorithm csp2, CryptokiAttribute[] keyTemplate)
{
bool testResult = false;
try
{
string dataToEncrypt = "This is a simple message to be encrypted dfjdfh ";
byte[] data = System.Text.UTF8Encoding.UTF8.GetBytes(dataToEncrypt);
byte[] encData = null;
byte[] newData = null;
csp2.Key = CryptoKey.CreateObject(csp2.Session, keyTemplate) as CryptoKey;
csp1.Key = CryptoKey.CreateObject(csp1.Session, keyTemplate) as CryptoKey;
csp2.IV = csp1.IV;
using (ICryptoTransform encr = csp1.CreateEncryptor())
{
encData = encr.TransformFinalBlock(data, 0, data.Length);
}
using (ICryptoTransform decr = csp2.CreateDecryptor())
{
newData = decr.TransformFinalBlock(encData, 0, encData.Length);
}
string res = new string(System.Text.UTF8Encoding.UTF8.GetChars(newData));
//Debug.Print(dataToEncrypt);
//Debug.Print(res);
testResult = string.Compare(dataToEncrypt, res) == 0;
}
catch (Exception ex)
{
Log.Exception("Unexpected Exception", ex);
}
return(testResult ? MFTestResults.Pass : MFTestResults.Fail);
}
public string Decrypt(byte[] cipherbytes, string password)
{
byte[] plainbytes = null;
try
{
Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(password, SALT);
algorithm.Key = pdb.GetBytes(32);
algorithm.IV = pdb.GetBytes(16);
algorithm.Padding = PaddingMode.None;
ms = new MemoryStream(cipherbytes);
cs = new CryptoStream(ms, algorithm.CreateDecryptor(), CryptoStreamMode.Read);
plainbytes = new byte[cipherbytes.Length];
cs.Read(plainbytes, 0, cipherbytes.Length);
cs.Close();
ms.Close();
}
catch (Exception)
{
MessageBox.Show("Decrypting error");
}
return(Encoding.UTF8.GetString(plainbytes));
}
private static bool TestRoundTrip(SymmetricAlgorithm testAlgorithm, SymmetricAlgorithm baseline, List<byte[]> data, out byte[] result)
{
result = null;
try
{
byte[] testCipherValue;
byte[] baselineCipherValue;
using (MemoryStream testEncrypted = new MemoryStream())
using (MemoryStream baselineEncrypted = new MemoryStream())
{
using (CryptoStream testEncryptor = new CryptoStream(testEncrypted, testAlgorithm.CreateEncryptor(), CryptoStreamMode.Write))
using (CryptoStream baselineEncryptor = new CryptoStream(baselineEncrypted, baseline.CreateEncryptor(), CryptoStreamMode.Write))
{
foreach (byte[] blocks in data)
{
testEncryptor.Write(blocks, 0, blocks.Length);
baselineEncryptor.Write(blocks, 0, blocks.Length);
}
testEncryptor.Close();
baselineEncryptor.Close();
testCipherValue = testEncrypted.ToArray();
baselineCipherValue = baselineEncrypted.ToArray();
}
}
byte[] testRoundtrip;
byte[] baselineRoundtrip;
using (MemoryStream testDecrypted = new MemoryStream())
using (MemoryStream baselineDecrypted = new MemoryStream())
{
using (CryptoStream testDecryptor = new CryptoStream(testDecrypted, testAlgorithm.CreateDecryptor(), CryptoStreamMode.Write))
using (CryptoStream baselineDecryptor = new CryptoStream(baselineDecrypted, baseline.CreateDecryptor(), CryptoStreamMode.Write))
{
testDecryptor.Write(baselineCipherValue, 0, baselineCipherValue.Length);
testDecryptor.Close();
baselineDecryptor.Write(testCipherValue, 0, testCipherValue.Length);
baselineDecryptor.Close();
testRoundtrip = testDecrypted.ToArray();
baselineRoundtrip = baselineDecrypted.ToArray();
}
}
if (!CompareBytes(testRoundtrip, baselineRoundtrip))
{
Console.WriteLine("Roundtrip bytes do not match");
Console.WriteLine("Test data: {0}", ByteArrayToString(testRoundtrip));
Console.WriteLine("Baseline data: {0}", ByteArrayToString(baselineRoundtrip));
Console.WriteLine("Key: {0}", ByteArrayToString(testAlgorithm.Key));
Console.WriteLine("IV: {0}", ByteArrayToString(testAlgorithm.IV));
Console.WriteLine("Cipher mode: {0}", testAlgorithm.Mode.ToString());
Console.WriteLine("Padding mode: {0}", testAlgorithm.Padding.ToString());
return false;
}
result = testRoundtrip;
return true;
}
catch (Exception e)
{
Console.WriteLine("Got an exception, fail");
Console.WriteLine(e);
return false;
}
}
static bool Test(SymmetricAlgorithm cipher, byte[] key, byte[] iv, byte[] input, byte[] expected)
{
cipher.Mode = CipherMode.ECB;
cipher.KeySize = key.Length * 8;
cipher.Padding = PaddingMode.Zeros;
byte[] output = new byte [input.Length];
ICryptoTransform encryptor = cipher.CreateEncryptor (key, iv);
encryptor.TransformBlock (input, 0, input.Length, output, 0);
if (!Compare (output, expected))
return false;
byte[] original = new byte [output.Length];
ICryptoTransform decryptor = cipher.CreateDecryptor (key, iv);
decryptor.TransformBlock (output, 0, output.Length, original, 0);
return Compare (original, input);
}
// Run a symmetric algorithm test.
protected void RunSymmetric(SymmetricAlgorithm alg, byte[] key,
byte[] plaintext, byte[] expected)
{
// Set up the algorithm the way we want.
alg.Mode = CipherMode.ECB;
alg.Padding = PaddingMode.None;
// Create an encryptor and run the test forwards.
ICryptoTransform encryptor = alg.CreateEncryptor(key, null);
byte[] output = new byte [plaintext.Length * 2];
byte[] tail;
int len = encryptor.TransformBlock
(plaintext, 0, plaintext.Length,
output, 0);
AssertEquals("ECB encrypt length mismatch",
len, expected.Length);
tail = encryptor.TransformFinalBlock
(plaintext, 0, 0);
AssertNotNull("ECB encrypt tail should be non-null");
AssertEquals("ECB encrypt tail should be zero length",
tail.Length, 0);
if(!IdenticalBlock(expected, 0, output, 0,
expected.Length))
{
Fail("did not encrypt to the expected output");
}
encryptor.Dispose();
// Create a decryptor and run the test backwards.
ICryptoTransform decryptor = alg.CreateDecryptor(key, null);
len = decryptor.TransformBlock
(expected, 0, expected.Length, output, 0);
AssertEquals("ECB decrypt length mismatch",
len, expected.Length);
tail = decryptor.TransformFinalBlock
(expected, 0, 0);
AssertNotNull("ECB decrypt tail should be non-null");
AssertEquals("ECB decrypt tail should be zero length",
tail.Length, 0);
if(!IdenticalBlock(plaintext, 0, output, 0,
plaintext.Length))
{
Fail("did not decrypt to the original plaintext");
}
decryptor.Dispose();
}
// Run a cipher mode test.
private void RunModeTest(SymmetricAlgorithm alg, CipherMode mode,
PaddingMode padding, String input)
{
// Set the algorithm modes.
alg.Mode = mode;
alg.Padding = padding;
// Get the raw and padded versions of the input.
byte[] rawInput = Encoding.ASCII.GetBytes(input);
byte[] paddedInput = StringToBytes(input, alg);
// Generate key and IV values.
byte[] key = CreateKey(alg);
byte[] iv = CreateIV(alg);
// Encrypt the raw input in the selected mode.
int size = alg.BlockSize / 8;
int cutoff = rawInput.Length - rawInput.Length % size;
ICryptoTransform encryptor;
encryptor = alg.CreateEncryptor(key, iv);
Assert(GetError("encryptor cannot transform multiple blocks",
alg, input),
encryptor.CanTransformMultipleBlocks);
if(mode == CipherMode.ECB || mode == CipherMode.CBC)
{
AssertEquals(GetError("encryptor has wrong input size",
alg, input),
size, encryptor.InputBlockSize);
AssertEquals(GetError("encryptor has wrong output size",
alg, input),
size, encryptor.OutputBlockSize);
}
else
{
AssertEquals(GetError("encryptor has wrong input size",
alg, input),
1, encryptor.InputBlockSize);
AssertEquals(GetError("encryptor has wrong output size",
alg, input),
1, encryptor.OutputBlockSize);
}
byte[] rawOutput = new byte [rawInput.Length + 256];
int len = encryptor.TransformBlock
(rawInput, 0, cutoff, rawOutput, 0);
byte[] rawTail = encryptor.TransformFinalBlock
(rawInput, cutoff, rawInput.Length - cutoff);
Array.Copy(rawTail, 0, rawOutput, len, rawTail.Length);
len += rawTail.Length;
((IDisposable)encryptor).Dispose();
// Reverse the ciphertext back to the original.
cutoff = len - len % size;
ICryptoTransform decryptor;
decryptor = alg.CreateDecryptor(key, iv);
Assert(GetError("decryptor cannot transform multiple blocks",
alg, input),
decryptor.CanTransformMultipleBlocks);
if(mode == CipherMode.ECB || mode == CipherMode.CBC)
{
AssertEquals(GetError("decryptor has wrong input size",
alg, input),
size, decryptor.InputBlockSize);
AssertEquals(GetError("decryptor has wrong output size",
alg, input),
size, decryptor.OutputBlockSize);
}
else
{
AssertEquals(GetError("decryptor has wrong input size",
alg, input),
1, decryptor.InputBlockSize);
AssertEquals(GetError("decryptor has wrong output size",
alg, input),
1, decryptor.OutputBlockSize);
}
byte[] rawReverse = new byte [rawInput.Length + 256];
int rlen = decryptor.TransformBlock
(rawOutput, 0, cutoff, rawReverse, 0);
rawTail = decryptor.TransformFinalBlock
(rawOutput, cutoff, len - cutoff);
Array.Copy(rawTail, 0, rawReverse, rlen, rawTail.Length);
rlen += rawTail.Length;
((IDisposable)decryptor).Dispose();
// Compare the reversed plaintext with the original.
if(padding != PaddingMode.None)
{
AssertEquals(GetError
("reversed plaintext has incorrect length",
alg, input), rawInput.Length, rlen);
if(!IdenticalBlock(rawInput, 0, rawReverse, 0, rlen))
{
Fail(GetError
("reversed plaintext is not the same as original",
alg, input));
}
}
else
{
if(rawInput.Length > rlen)
{
Fail(GetError
("reversed plaintext has incorrect length",
alg, input));
}
if(!IdenticalBlock(rawInput, 0, rawReverse, 0,
rawInput.Length))
{
Fail(GetError
("reversed plaintext is not the same as original",
alg, input));
}
}
// Encrypt the padded plaintext using a primitive
// algorithm simulation to verify the expected output.
byte[] paddedOutput;
switch(mode)
{
case CipherMode.ECB:
{
paddedOutput = DoECB(paddedInput, alg, key);
}
break;
case CipherMode.CBC:
{
paddedOutput = DoCBC(paddedInput, alg, key, iv);
}
break;
case CipherMode.OFB:
{
paddedOutput = DoOFB(paddedInput, alg, key, iv);
}
break;
case CipherMode.CFB:
{
paddedOutput = DoCFB(paddedInput, alg, key, iv);
}
break;
case CipherMode.CTS:
default:
{
paddedOutput = DoCTS(paddedInput, alg, key, iv);
}
break;
}
// Compare the actual output with the expected output.
AssertEquals(GetError("ciphertext has incorrect length",
alg, input),
paddedOutput.Length, len);
if(!IdenticalBlock(paddedOutput, 0, rawOutput, 0, len))
{
Fail(GetError("ciphertext was not the expected value",
alg, input));
}
}