| public CreateDecryptor ( ) : ICryptoTransform | ||
| Результат | ICryptoTransform | |
public static bool DecryptBase64(string cliperText, string key, out string originText)
{
byte[] inputData = Convert.FromBase64String(cliperText);
var aes = new AesManaged()
{
Padding = _padding,
Mode = _cipherMode,
IV = ORIGIN_IV,
Key = Encoding.UTF8.GetBytes(key.PadRight(KEY_LENGTH, PADDING_CHAR).Substring(0, KEY_LENGTH))
};
var decryptor = aes.CreateDecryptor();
bool decryptSuccess = true;
try
{
byte[] decryptedData = decryptor.TransformFinalBlock(inputData, 0, inputData.Length);
originText = Encoding.UTF8.GetString(decryptedData);
}
catch
{
decryptSuccess = false;
originText = string.Empty;
}
finally
{
decryptor.Dispose();
if (aes != null)
{
aes.Clear();
}
}
return decryptSuccess;
}
public string Decryption() {
try {
byte[] encrypted=Convert.FromBase64String(textInput.Text);
MemoryStream ms=null;
CryptoStream cs=null;
StreamReader sr=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform decryptor=aes.CreateDecryptor(aes.Key,aes.IV);
ms=new MemoryStream(encrypted);
cs=new CryptoStream(ms,decryptor,CryptoStreamMode.Read);
sr=new StreamReader(cs);
string decrypted=sr.ReadToEnd();
ms.Dispose();
cs.Dispose();
sr.Dispose();
if(aes!=null) {
aes.Clear();
}
return decrypted;
}
catch {
MessageBox.Show("Text entered was not valid encrypted text.");
return"";
}
}
public static string Decrypt(string str,byte[] key)
{
//No need to check RemotingRole; no call to db.
if(str==""){
return "";
}
try {
byte[] encrypted=Convert.FromBase64String(str);
MemoryStream ms=null;
CryptoStream cs=null;
StreamReader sr=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform decryptor=aes.CreateDecryptor(aes.Key,aes.IV);
ms=new MemoryStream(encrypted);
cs=new CryptoStream(ms,decryptor,CryptoStreamMode.Read);
sr=new StreamReader(cs);
string decrypted=sr.ReadToEnd();
ms.Dispose();
cs.Dispose();
sr.Dispose();
if(aes!=null) {
aes.Clear();
}
return decrypted;
}
catch {
//MessageBox.Show("Text entered was not valid encrypted text.");
return"";
}
}
public static void DecryptFile(string inputFile, string outputFile, string keyIV)
{
byte[] array1 = new byte[32];
byte[] array2 = new byte[16];
AssetStoreUtils.HexStringToByteArray(keyIV, array1, 0);
AssetStoreUtils.HexStringToByteArray(keyIV, array2, 64);
EditorUtility.DisplayProgressBar("Decrypting", "Decrypting package", 0.0f);
FileStream fileStream1 = File.Open(inputFile, System.IO.FileMode.Open);
FileStream fileStream2 = File.Open(outputFile, System.IO.FileMode.CreateNew);
long length = fileStream1.Length;
long num = 0;
AesManaged aesManaged = new AesManaged();
aesManaged.Key = array1;
aesManaged.IV = array2;
CryptoStream cryptoStream = new CryptoStream((Stream) fileStream1, aesManaged.CreateDecryptor(aesManaged.Key, aesManaged.IV), CryptoStreamMode.Read);
try
{
byte[] numArray = new byte[40960];
int count;
while ((count = cryptoStream.Read(numArray, 0, numArray.Length)) > 0)
{
fileStream2.Write(numArray, 0, count);
num += (long) count;
if (EditorUtility.DisplayCancelableProgressBar("Decrypting", "Decrypting package", (float) num / (float) length))
throw new Exception("User cancelled decryption");
}
}
finally
{
cryptoStream.Close();
fileStream1.Close();
fileStream2.Close();
EditorUtility.ClearProgressBar();
}
}
/// <summary>
/// 解密
/// </summary>
public static string AESDecrypt(string input)
{
byte[] encryptBytes = Convert.FromBase64String(input);
byte[] salt = Encoding.UTF8.GetBytes(saltValue);
System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged( );
System.Security.Cryptography.Rfc2898DeriveBytes rfc = new System.Security.Cryptography.Rfc2898DeriveBytes(pwdValue, salt);
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
aes.Key = rfc.GetBytes(aes.KeySize / 8);
aes.IV = rfc.GetBytes(aes.BlockSize / 8);
// 用当前的 Key 属性和初始化向量 IV 创建对称解密器对象
System.Security.Cryptography.ICryptoTransform decryptTransform = aes.CreateDecryptor( );
// 解密后的输出流
System.IO.MemoryStream decryptStream = new System.IO.MemoryStream( );
// 将解密后的目标流（decryptStream）与解密转换（decryptTransform）相连接
System.Security.Cryptography.CryptoStream decryptor = new System.Security.Cryptography.CryptoStream(
decryptStream, decryptTransform, System.Security.Cryptography.CryptoStreamMode.Write);
// 将一个字节序列写入当前 CryptoStream （完成解密的过程）
decryptor.Write(encryptBytes, 0, encryptBytes.Length);
decryptor.Close( );
// 将解密后所得到的流转换为字符串
byte[] decryptBytes = decryptStream.ToArray( );
string decryptedString = UTF8Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
return(decryptedString);
}
public static byte[] Decrypt(byte[] input)
{
if (_key == null || _key.Length == 0) throw new Exception("Key can not be empty.");
if (input == null || input.Length == 0) throw new ArgumentException("Input can not be empty.");
byte[] data = new byte[0];
try
{
using (var ms = new MemoryStream(input))
{
using (var rd = new AesManaged { Key = _key })
{
byte[] iv = new byte[IVLENGTH];
ms.Read(iv, 0, IVLENGTH); // read first 16 bytes for IV, followed by encrypted message
rd.IV = iv;
using (var cs = new CryptoStream(ms, rd.CreateDecryptor(), CryptoStreamMode.Read))
{
byte[] temp = new byte[ms.Length - IVLENGTH + 1];
data = new byte[cs.Read(temp, 0, temp.Length)];
Buffer.BlockCopy(temp, 0, data, 0, data.Length);
}
}
}
}
catch
{
}
return data;
}
public static string Decrypt(byte[] encryptedData, string password, byte[] salt = null)
{
if (encryptedData == null) throw new ArgumentNullException("encryptedData");
if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password");
if (salt == null) salt = DefaultSalt;
var aes = new AesManaged();
string text;
try
{
aes.SetKey(password, salt);
using (var ms = new MemoryStream(encryptedData))
{
aes.IV = ms.GetIV();
var decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
using (var sr = new StreamReader(cs))
text = sr.ReadToEnd();
}
}
finally
{
aes.Clear();
}
return text;
}
public static string Decrypt(this string text, string lKey)
{
try
{
using (Aes aes = new AesManaged())
{
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IVa, 0, IVa.Length), Encoding.UTF8.GetBytes(lKey));
aes.Key = deriveBytes.GetBytes(128 / 8);
aes.IV = aes.Key;
using (MemoryStream decryptionStream = new MemoryStream())
{
using (CryptoStream decrypt = new CryptoStream(decryptionStream, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
byte[] encryptedData = Convert.FromBase64String(text);
decrypt.Write(encryptedData, 0, encryptedData.Length);
decrypt.Flush();
}
byte[] decryptedData = decryptionStream.ToArray();
string decryptedText = Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length);
return decryptedText;
}
}
}
catch
{
return String.Empty;
}
}
public static bool ForCodeCoverage()
{
AesManaged aes = new AesManaged();
using (ICryptoTransform cte = aes.CreateEncryptor(), ctd = aes.CreateDecryptor())
{
byte[] plain1 = new byte[64];
for (int i = 0; i < plain1.Length; i++)
plain1[i] = (byte)i;
byte[] encr1 = cte.TransformFinalBlock(plain1, 0, plain1.Length);
using(MemoryStream ms = new MemoryStream())
using(CryptoStream cs = new CryptoStream(ms, ctd, CryptoStreamMode.Write))
{
cs.Write(encr1, 0, 16);
cs.Write(encr1, 16, 16);
cs.Write(encr1, 32, 16);
cs.Write(encr1, 48, encr1.Length-48);
cs.FlushFinalBlock();
byte[] plain2 = ms.ToArray();
if (!Compare(plain1, plain2))
{
Console.WriteLine("CodeCoverage case failed");
return false;
}
return true;
}
}
}
public static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
{
if (cipherText == null || cipherText.Length <= 0)
throw new ArgumentNullException("cipherText");
if (Key == null || Key.Length <= 0)
throw new ArgumentNullException("Key");
if (IV == null || IV.Length <= 0)
throw new ArgumentNullException("Key");
string plaintext = null;
using (AesManaged aesAlg = new AesManaged())
{
aesAlg.Key = Key;
aesAlg.IV = IV;
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return plaintext;
}
/// <summary>
/// this algorithm uses the AES algorithm to decrypt the given cipherText
/// </summary>
/// <param name="cipherText"></param>
/// <param name="sharedSecret"></param>
/// <returns></returns>
public static string DecryptCipherAES(string cipherText, string sharedSecret)
{
if (string.IsNullOrEmpty(cipherText))
{
return cipherText;
}
AesManaged aesAlg = null;
string plaintext = null;
// generate the key from the shared secret and the salt
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, salt);
// Create the streams used for decryption.
byte[] bytes = Convert.FromBase64String(cipherText);
using (MemoryStream memoryDecrypt = new MemoryStream(bytes))
{
aesAlg = new AesManaged();
aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
// Get the initialization vector from the encrypted stream
aesAlg.IV = ReadByteArray(memoryDecrypt);
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (CryptoStream cryptoDecrypt =
new CryptoStream(memoryDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader streamDecrypt = new StreamReader(cryptoDecrypt))
{
plaintext = streamDecrypt.ReadToEnd();
}
}
}
return plaintext;
}
/// <summary>
/// Decrypts the ciphertext using the Key.
/// </summary>
/// <param name="ciphertext">The ciphertext to decrypt.</param>
/// <param name="password">The plain text encryption key.</param>
/// <returns>The decrypted text.</returns>
public static byte[] Decrypt(byte[] cipherText, string password)
{
if (cipherText == null || cipherText.Length == 0) throw new ArgumentNullException("cipherText");
if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password");
// Extract the salt from our ciphertext
var saltBytes = cipherText.Take(SaltSize).ToArray();
var ciphertextBytes = cipherText.Skip(SaltSize).ToArray();
using (var keyDerivationFunction = new Rfc2898DeriveBytes(password, saltBytes))
{
// Derive the previous Key and IV from the password and salt
var keyBytes = keyDerivationFunction.GetBytes(32);
var ivBytes = keyDerivationFunction.GetBytes(16);
using (var aesManaged = new AesManaged())
using (var decryptor = aesManaged.CreateDecryptor(keyBytes, ivBytes))
using (var memoryStream = new MemoryStream(ciphertextBytes))
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
using (var outputStream = new StreamReader(cryptoStream))
using (var outMemoryStream = new MemoryStream())
{
outputStream.BaseStream.CopyTo(outMemoryStream);
return outMemoryStream.ToArray();
}
}
}
public static void Register()
{
using (var manifestResourceStream = typeof(SettingsRegister).Assembly.GetManifestResourceStream("Raven.Studio.Settings.dat"))
{
if (manifestResourceStream == null || manifestResourceStream.Length == 0)
{
return;
}
using (var reader = new BinaryReader(manifestResourceStream))
using (var aes = new AesManaged())
{
aes.Key = reader.ReadBytes(32);
aes.IV = reader.ReadBytes(16);
using (var cryptoStream = new CryptoStream(manifestResourceStream, aes.CreateDecryptor(), CryptoStreamMode.Read))
using (var cryptoReader = new BinaryReader(cryptoStream))
{
var licensee = cryptoReader.ReadString();
var licenseKey = cryptoReader.ReadString();
ActiproSoftware.Products.ActiproLicenseManager.RegisterLicense(licensee, licenseKey);
}
}
}
}
//Decrypts the 16 bytes block @cipherText using @key in ECB mode
public static byte[] AES_DecryptBlock(byte[] cipherText, byte[] key)
{
// Check arguments.
if (cipherText == null || cipherText.Length != 16)
throw new ArgumentException ("cipherText must be a 16 byte array");
if (key == null || key.Length <= 0)
throw new ArgumentNullException ("Key");
// Declare the string used to hold the decrypted text.
byte[] output_buffer = new byte[cipherText.Length];
using (AesManaged aesAlg = new AesManaged()) {
aesAlg.Mode = CipherMode.ECB;
aesAlg.BlockSize = 128;
aesAlg.KeySize = 128;
aesAlg.Padding = PaddingMode.None;
aesAlg.Key = key;
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = aesAlg.CreateDecryptor (aesAlg.Key, aesAlg.IV);
decryptor.TransformBlock (cipherText, 0, cipherText.Length, output_buffer, 0);
}
return output_buffer;
}
public static string decrypt(string valueToDecrypt)
{
using (Aes aes = new AesManaged())
{
aes.Padding = PaddingMode.PKCS7;
aes.KeySize = 128; // in bits
aes.Key = new byte[128 / 8]; // 16 bytes for 128 bit encryption
aes.IV = new byte[128 / 8]; // AES needs a 16-byte IV
// Should set Key and IV here. Good approach: derive them from
// a password via Cryptography.Rfc2898DeriveBytes
byte[] cipherText = Convert.FromBase64String(valueToDecrypt);
byte[] plainText = null;
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(cipherText, 0, cipherText.Length);
}
plainText = ms.ToArray();
}
return UTF8Encoding.UTF8.GetString(plainText);
}
}
public static void DecryptFile(string inputFile, string outputFile, string keyIV)
{
byte[] array = new byte[0x20];
byte[] buffer2 = new byte[0x10];
HexStringToByteArray(keyIV, array, 0);
HexStringToByteArray(keyIV, buffer2, 0x40);
FileStream stream = File.Open(inputFile, System.IO.FileMode.Open);
FileStream stream2 = File.Open(outputFile, System.IO.FileMode.CreateNew);
AesManaged managed = new AesManaged {
Key = array,
IV = buffer2
};
CryptoStream stream3 = new CryptoStream(stream, managed.CreateDecryptor(managed.Key, managed.IV), CryptoStreamMode.Read);
try
{
int num;
byte[] buffer = new byte[0xa000];
while ((num = stream3.Read(buffer, 0, buffer.Length)) > 0)
{
stream2.Write(buffer, 0, num);
}
}
finally
{
stream3.Close();
stream.Close();
stream2.Close();
}
}
public static void DecryptFile(string inputFile, string outputFile, string skey)
{
try
{
using (Aes aes = new AesManaged() { KeySize = 256, BlockSize = 128 })
{
var key = new Rfc2898DeriveBytes(skey, salt);
aes.Key = key.GetBytes(aes.KeySize / 8);
aes.IV = key.GetBytes(aes.BlockSize / 8);
using (FileStream fsCrypt = new FileStream(inputFile, FileMode.Open))
{
using (FileStream fsOut = new FileStream(outputFile, FileMode.Create))
{
using (ICryptoTransform decryptor = aes.CreateDecryptor())
{
using (CryptoStream cs = new CryptoStream(fsCrypt, decryptor, CryptoStreamMode.Read))
{
int data;
while ((data = cs.ReadByte()) != -1)
{
fsOut.WriteByte((byte)data);
}
}
}
}
}
}
}
catch { throw; }
}
public string Decrypt(Secret secret)
{
string plainText = null;
using (MemoryStream msDecrypt = new MemoryStream(secret.Data))
{
// Create an AesManaged object with the specified key and IV.
using (Aes aesAlg = new AesManaged())
{
aesAlg.Key = _key;
aesAlg.IV = secret.IV;
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = aesAlg.CreateDecryptor();
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt, Encoding.Unicode))
{
// Read the decrypted bytes from the decrypting stream
// and place them in a string.
plainText = srDecrypt.ReadToEnd();
}
}
}
}
return plainText;
}
/// <summary>
/// <see cref="IAesManagedWrapper.Encrypt"/>
/// </summary>
public byte[] Decrypt(byte[] bytesToBeDecrypted, byte[] aesKey, byte[] aesIv)
{
byte[] decryptedBytes;
using (var ms = new MemoryStream())
{
using (var aes = new AesManaged())
{
SetStandardConfiguration(aes);
aes.Key = aesKey;
aes.IV = aesIv;
using (var cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(bytesToBeDecrypted, 0, bytesToBeDecrypted.Length);
cs.Close();
}
decryptedBytes = ms.ToArray();
}
}
return decryptedBytes;
}
/// <summary>
/// Decrypts the ciphertext using the Key.
/// </summary>
/// <param name="ciphertext">The ciphertext to decrypt.</param>
/// <param name="key">The plain text encryption key.</param>
/// <returns>The decrypted text.</returns>
public static string Decrypt(string ciphertext, string key)
{
if (string.IsNullOrEmpty(ciphertext))
throw new ArgumentNullException("cipherText");
if (string.IsNullOrEmpty(key))
throw new ArgumentNullException("key");
// Extract the salt from our ciphertext
var allTheBytes = Convert.FromBase64String(ciphertext);
var saltBytes = allTheBytes.Take(_saltSize).ToArray();
var ciphertextBytes = allTheBytes.Skip(_saltSize).Take(allTheBytes.Length - _saltSize).ToArray();
using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, saltBytes))
{
// Derive the previous IV from the Key and Salt
var keyBytes = keyDerivationFunction.GetBytes(32);
var ivBytes = keyDerivationFunction.GetBytes(16);
// Create a decrytor to perform the stream transform.
// Create the streams used for decryption.
// The default Cipher Mode is CBC and the Padding is PKCS7 which are both good
using (var aesManaged = new AesManaged())
using (var decryptor = aesManaged.CreateDecryptor(keyBytes, ivBytes))
using (var memoryStream = new MemoryStream(ciphertextBytes))
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream))
{
// Return the decrypted bytes from the decrypting stream.
return streamReader.ReadToEnd();
}
}
}
public static MyWallet Load(string path, string password)
{
MyWallet wallet = new MyWallet();
byte[] aes_key = Encoding.UTF8.GetBytes(password).Sha256().Sha256();
byte[] aes_iv = new byte[16];
using (AesManaged aes = new AesManaged())
using (FileStream fs = new FileStream(path, FileMode.Open, FileAccess.Read))
{
fs.Read(aes_iv, 0, aes_iv.Length);
using (ICryptoTransform decryptor = aes.CreateDecryptor(aes_key, aes_iv))
using (CryptoStream cs = new CryptoStream(fs, decryptor, CryptoStreamMode.Read))
using (BinaryReader reader = new BinaryReader(cs))
{
int count = (int)reader.ReadVarInt();
for (int i = 0; i < count; i++)
{
byte[] privateKey = reader.ReadBytes(32);
bool compressed = reader.ReadBoolean();
ECPoint publicKey = ECCurve.Secp256k1.G * privateKey;
UInt160 publicKeyHash = publicKey.EncodePoint(compressed).ToScriptHash();
wallet.accounts.Add(new WalletEntry(privateKey, publicKey, publicKeyHash, compressed));
}
}
}
Array.Clear(aes_key, 0, aes_key.Length);
return wallet;
}
public static string Decrypt(this string text)
{
if (string.IsNullOrEmpty(text))
{
return null;
}
using (MemoryStream ms = new MemoryStream())
{
byte[] cipherText = StringToByteArray(text);
byte[] plainText;
using (Aes aes = new AesManaged())
{
aes.Padding = PaddingMode.PKCS7;
aes.KeySize = AesKeySizeInBits;
int KeyStrengthInBytes = aes.KeySize / 8;
System.Security.Cryptography.Rfc2898DeriveBytes rfc2898 =
new System.Security.Cryptography.Rfc2898DeriveBytes(Password, Salt, Rfc2898KeygenIterations);
aes.Key = rfc2898.GetBytes(KeyStrengthInBytes);
aes.IV = rfc2898.GetBytes(KeyStrengthInBytes);
using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(cipherText, 0, cipherText.Length);
}
plainText = ms.ToArray();
return System.Text.Encoding.Unicode.GetString(plainText);
}
}
}
public byte[] Decrypt(byte[] cipher, byte[] key, byte[] IV)
{
System.Collections.Generic.List<byte> bytes = new List<byte>();
using (AesManaged _aesAlgorithm = new AesManaged())
{
_aesAlgorithm.Key = key;
_aesAlgorithm.IV = IV;
using (ICryptoTransform decryptor = _aesAlgorithm.CreateDecryptor(_aesAlgorithm.Key, _aesAlgorithm.IV))
{
using (System.IO.MemoryStream str = new System.IO.MemoryStream(cipher))
{
using (CryptoStream crypto = new CryptoStream(str, decryptor, CryptoStreamMode.Read))
{
int b = crypto.ReadByte();
while (b > -1)
{
b = crypto.ReadByte();
bytes.Add((byte)b);
}
}
}
_aesAlgorithm.Clear();
}
}
return bytes.ToArray();
}
internal static byte[] Decrypt(byte[] data)
{
byte[] output = null;
using (var aes = new AesManaged())
{
using (var decryptor = aes.CreateDecryptor(Configuration.Default.EncryptionKey, Configuration.Default.EncryptionIV))
{
using (var dataStream = new MemoryStream())
{
using (var encryptionStream = new CryptoStream(dataStream, decryptor, CryptoStreamMode.Write))
{
encryptionStream.Write(data, 0, data.Length);
encryptionStream.FlushFinalBlock();
dataStream.Position = 0;
byte[] transformedBytes = new byte[dataStream.Length];
dataStream.Read(transformedBytes, 0, transformedBytes.Length);
encryptionStream.Close();
dataStream.Close();
output = transformedBytes;
}
}
}
}
return output;
}
public static Stream Decrypt(Stream source,
Headers headers, byte[] masterKey)
{
byte[] easKey;
using (var buffer = new MemoryStream())
{
var masterSeed = headers.MasterSeed;
buffer.Write(masterSeed, 0, masterSeed.Length);
buffer.Write(masterKey, 0, masterKey.Length);
easKey = BufferEx.GetHash(buffer.ToArray());
}
var eas = new AesManaged
{
KeySize = 256,
Key = BufferEx.Clone(easKey),
IV = BufferEx.Clone(headers.EncryptionIV)
};
Stream stream = new CryptoStream(source,
eas.CreateDecryptor(),
CryptoStreamMode.Read);
if (!VerifyStartBytes(headers, stream))
return null;
stream = new HashedBlockStream(stream, true);
return headers.Compression == Compressions.GZip
? new GZipInputStream(stream) : stream;
}
/// <summary>
/// Decrypt a string
/// </summary>
/// <param name="input">Input string in base 64 format</param>
/// <returns>Decrypted string</returns>
public static string Decrypt(string input, string password)
{
byte[] encryptedBytes = Convert.FromBase64String(input);
byte[] saltBytes = Encoding.UTF8.GetBytes(password);
string decryptedString = string.Empty;
using (var aes = new AesManaged())
{
Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(password, saltBytes);
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
aes.Key = rfc.GetBytes(aes.KeySize / 8);
aes.IV = rfc.GetBytes(aes.BlockSize / 8);
using (ICryptoTransform decryptTransform = aes.CreateDecryptor())
{
using (MemoryStream decryptedStream = new MemoryStream())
{
CryptoStream decryptor =
new CryptoStream(decryptedStream, decryptTransform, CryptoStreamMode.Write);
decryptor.Write(encryptedBytes, 0, encryptedBytes.Length);
decryptor.Flush();
decryptor.Close();
byte[] decryptBytes = decryptedStream.ToArray();
decryptedString =
UTF8Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
}
}
}
return decryptedString;
}
public static string DecryptStringFromBytes(byte[] cipherText, byte[] key, byte[] IV)
{
string plaintext = null;
using (Aes aesAlg = new AesManaged())
{
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IV, 0, IV.Length), key);
aesAlg.Key = deriveBytes.GetBytes(128 / 8);
aesAlg.IV = aesAlg.Key;
ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
using (MemoryStream msDecrypt = new MemoryStream(cipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return plaintext;
}
public static string Decrypt(string ciphertext, string key)
{
if (string.IsNullOrEmpty(ciphertext))
throw new ArgumentNullException("cipherText");
if (string.IsNullOrEmpty(key))
throw new ArgumentNullException("key");
var allTheBytes = Convert.FromBase64String(ciphertext);
var saltBytes = allTheBytes.Take(_saltSize).ToArray();
var ciphertextBytes = allTheBytes.Skip(_saltSize).Take(allTheBytes.Length - _saltSize).ToArray();
using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, saltBytes))
{
var keyBytes = keyDerivationFunction.GetBytes(32);
var ivBytes = keyDerivationFunction.GetBytes(16);
using (var aesManaged = new AesManaged())
using (var decryptor = aesManaged.CreateDecryptor(keyBytes, ivBytes))
using (var memoryStream = new MemoryStream(ciphertextBytes))
using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
using (var streamReader = new StreamReader(cryptoStream))
{
return streamReader.ReadToEnd();
}
}
}
public static string DecryptStringFromByte(byte[] sourceLine, byte[] key, byte[] IV)
{
if (sourceLine == null || sourceLine.Length == 0)
{
return null;
}
if (key == null || key.Length <= 0 || IV == null || IV.Length <= 0)
{
return null;
}
AesManaged aesAlg = new AesManaged();
aesAlg.Key = key;
aesAlg.IV = IV;
ICryptoTransform decryptor = aesAlg.CreateDecryptor();
MemoryStream msDecrypt = new MemoryStream(sourceLine);
CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);
StreamReader srDecrypt = new StreamReader(csDecrypt);
string result = srDecrypt.ReadToEnd();
return result;
}
public void DecryptFile(string sourceFilename, string destinationFilename, string password)
{
AesManaged aes = new AesManaged();
aes.BlockSize = aes.LegalBlockSizes[0].MaxSize;
aes.KeySize = aes.LegalKeySizes[0].MaxSize;
// NB: Rfc2898DeriveBytes initialization and subsequent calls to GetBytes must be eactly the same, including order, on both the encryption and decryption sides.
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, salt, iterations);
aes.Key = key.GetBytes(aes.KeySize / 8);
aes.IV = key.GetBytes(aes.BlockSize / 8);
aes.Mode = CipherMode.CBC;
ICryptoTransform transform = aes.CreateDecryptor(aes.Key, aes.IV);
using (FileStream destination = new FileStream(destinationFilename, FileMode.CreateNew, FileAccess.Write, FileShare.None))
{
using (CryptoStream cryptoStream = new CryptoStream(destination, transform, CryptoStreamMode.Write))
{
try
{
using (FileStream source = new FileStream(sourceFilename, FileMode.Open, FileAccess.Read, FileShare.Read))
{
source.CopyTo(cryptoStream);
}
}
catch (CryptographicException exception)
{
if (exception.Message == "Padding is invalid and cannot be removed.")
throw new ApplicationException("Universal Microsoft Cryptographic Exception (Not to be believed!)", exception);
else
throw;
}
}
}
}
/// <summary>
/// Decrypt encrypted string
/// </summary>
/// <param name="Str">Encrypted string</param>
/// <param name="Password">Password used for encryption</param>
/// <param name="Salt">Salt string used for encryption (at least 8 bytes)</param>
/// <returns>Decrypted string if success; otherwise - empty string</returns>
public static string DecryptString(string Str, string Password = "******", string Salt = "tdcm1234")
{
try
{
using (Aes aes = new AesManaged())
{
Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Password, Encoding.UTF8.GetBytes(Salt));
aes.Key = deriveBytes.GetBytes(128 / 8);
aes.IV = aes.Key;
using (MemoryStream decryptionStream = new MemoryStream())
{
using (CryptoStream decrypt = new CryptoStream(decryptionStream, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
byte[] encryptedData = Convert.FromBase64String(Str);
decrypt.Write(encryptedData, 0, encryptedData.Length);
decrypt.Flush();
}
byte[] decryptedData = decryptionStream.ToArray();
return UTF8Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length);
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Error : AES ~ DecryptString ; " + ex.Message);
return "";
}
}
protected static void SecurityAesDecrypt(BlamVersion game, Blam.CacheSectionType section_type, byte[] input, out byte[] output,
GetAesParametersProc GetAesParameters)
{
output = null;
using (var aesm = new Crypt.AesManaged())
{
aesm.KeySize = 128;
aesm.Padding = Crypt.PaddingMode.Zeros;
aesm.Mode = Crypt.CipherMode.CBC;
byte[] key, iv;
GetAesParameters(game, section_type, out key, out iv);
if (key != null && iv != null)
{
using (var ctx = aesm.CreateDecryptor(key, iv))
{
output = ctx.TransformFinalBlock(input, 0, input.Length);
}
}
}
}
public string Decrypt(byte[] cipherText, byte[] Key, byte[] IV)
{
string plaintext = null;
// Create AesManaged
using (System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged())
{
// Create a decryptor
System.Security.Cryptography.ICryptoTransform decryptor = aes.CreateDecryptor(Key, IV);
// Create the streams used for decryption.
using (System.IO.MemoryStream ms = new System.IO.MemoryStream(cipherText))
{
// Create crypto stream
using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, decryptor, System.Security.Cryptography.CryptoStreamMode.Read))
{
// Read crypto stream
using (System.IO.StreamReader reader = new System.IO.StreamReader(cs))
plaintext = reader.ReadToEnd();
}
}
}
return(plaintext);
}
public static byte[] AESDecrypt(this byte[] data, byte[] password, CipherMode mode = CipherMode.CBC)
{
byte[] result;
try
{
using (Aes aes = new AesManaged())
{
aes.Mode = mode;
aes.Key = password;
aes.IV = password;
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, aes.CreateDecryptor(), CryptoStreamMode.Write))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
}
result = memoryStream.ToArray();
}
}
}
catch (Exception ex)
{
Debug.Print("aes encryption failed ", new object[] { ex });
result = null;
}
return(result);
}
public byte[] Decrypt(byte[] B, String PSW)
{
System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(PSW, new Byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
System.IO.MemoryStream ms = new System.IO.MemoryStream();
System.Security.Cryptography.Aes AESE = new System.Security.Cryptography.AesManaged();
AESE.Key = pdb.GetBytes(AESE.KeySize / 8);
AESE.IV = pdb.GetBytes(AESE.BlockSize / 8);
System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, AESE.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
cs.Write(B, 0, B.Length);
cs.Close();
return(ms.ToArray());
}
