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;
}
/// <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 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;
}
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;
}
private void CreateCrytoTransform()
{
// Get shared secret
GetSharedSecret(ref key, ref iv);
if (key.Length == 0)
{
return;
}
// Set transform
AesManaged aes = new System.Security.Cryptography.AesManaged();
AesManaged aes_decrypt = new AesManaged();
aes.Key = key;
aes.IV = iv;
aes.Mode = System.Security.Cryptography.CipherMode.CBC;
aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
aes.BlockSize = 128;
transform = aes.CreateEncryptor();
aes_decrypt.Key = key;
aes_decrypt.IV = iv;
aes_decrypt.Mode = System.Security.Cryptography.CipherMode.CBC;
aes_decrypt.Padding = System.Security.Cryptography.PaddingMode.None;
aes_decrypt.BlockSize = 128;
decryptTransform = aes_decrypt.CreateDecryptor();
}
public void OFB_NotAllowed ()
{
// this check is normally (e.g. RijndaelManaged) done later
using (var aes = new AesManaged ()) {
aes.Mode = CipherMode.OFB;
}
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="hashedData">密文字节</param>
/// <returns>返回解密后的字符串</returns>
public static string AESDecrypt(string hashedData)
{
//分组加密算法
string result = string.Empty;
SymmetricAlgorithm des;
System.Security.Cryptography.AesManaged aesmanaged = new System.Security.Cryptography.AesManaged();
try
{
des = aesmanaged as SymmetricAlgorithm;
des.Key = Encoding.UTF8.GetBytes(GetKey());
des.IV = _key1;
byte[] cipherText = Convert.FromBase64String(hashedData);
byte[] decryptBytes = new byte[cipherText.Length];
MemoryStream ms = new MemoryStream(cipherText);
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read);
cs.Read(decryptBytes, 0, decryptBytes.Length);
cs.Close();
ms.Close();
result = System.Text.Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length);
}
catch (Exception ex)
{
SMT.Foundation.Log.Tracer.Debug(ex.Message);
ex.Message.ToString();
}
return(string.IsNullOrEmpty(result) ? string.Empty : result);
}
public byte[] Encrypt(string plainText, byte[] Key, byte[] IV)
{
byte[] encrypted;
// Create a new AesManaged.
using (System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged())
{
// Create encryptor
System.Security.Cryptography.ICryptoTransform encryptor = aes.CreateEncryptor(Key, IV);
// Create MemoryStream
using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
{
// Create crypto stream using the CryptoStream class. This class is the key to encryption
// and encrypts and decrypts data from any given stream. In this case, we will pass a memory stream
// to encrypt
using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, encryptor, System.Security.Cryptography.CryptoStreamMode.Write))
{
// Create StreamWriter and write data to a stream
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(cs))
sw.Write(plainText);
encrypted = ms.ToArray();
}
}
}
// Return encrypted data
return(encrypted);
}
public static int Main()
{
List<byte[]>[] inputs = new List<byte[]>[]
{
GenerateInput(new int[] { 3, 1 }),
GenerateInput(new int[] { 2, 2 }),
GenerateInput(new int[] { 2, 1, 1 }),
GenerateInput(new int[] { 1, 3}),
GenerateInput(new int[] { 1, 2, 1}),
GenerateInput(new int[] { 1, 1, 2 }),
GenerateInput(new int[] { 1, 1, 1, 1 })
};
foreach (PaddingMode paddingMode in PaddingModes)
{
List<byte[]> results = new List<byte[]>();
// AESCSP is not supported on Win2k so just round-trip with AesManaged in this case
//
Aes aes1 = (AesCSPSupported()) ? (Aes) new AesCryptoServiceProvider() : (Aes) new AesManaged();
aes1.Padding = paddingMode;
Aes aes2 = new AesManaged();
aes2.Padding = paddingMode;
aes1.Key = aes2.Key;
aes1.IV = aes2.IV;
aes1.Mode = aes2.Mode;
for (int i = 0; i < inputs.Length; i++)
{
byte[] result = null;
if (!TestRoundTrip(aes1, aes2, inputs[i], out result))
{
Console.WriteLine("Test Fail - roundtrip fails");
return FailCode;
}
results.Add(result);
}
for(int i = 0; i < results.Count - 1; i++)
{
if (!CompareBytes(results[i], results[i + 1]))
{
Console.WriteLine("Test Fail - mismatch");
Console.WriteLine("Result {0}: {1}", i, ByteArrayToString(results[i]));
Console.WriteLine("Result {0}: {1}", i+1, ByteArrayToString(results[i+1]));
Console.WriteLine("Key: {0}", ByteArrayToString(aes1.Key));
Console.WriteLine("IV: {0}", ByteArrayToString(aes1.IV));
Console.WriteLine("Cipher mode: {0}", aes1.Mode.ToString());
Console.WriteLine("Padding mode: {0}", aes1.Padding.ToString());
return FailCode;
}
}
}
Console.WriteLine("Test Passed");
return PassCode;
}
/// <summary>
/// 加密
/// </summary>
public static string AESEncrypt(string input)
{
byte[] data = System.Text.UTF8Encoding.UTF8.GetBytes(input);
byte[] salt = System.Text.UTF8Encoding.UTF8.GetBytes(saltValue);
// AesManaged - 高级加密标准(AES) 对称算法的管理类
System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged( );
// Rfc2898DeriveBytes - 通过使用基于 HMACSHA1 的伪随机数生成器，实现基于密码的密钥派生功能 (PBKDF2 - 一种基于密码的密钥派生函数)
// 通过 密码 和 salt 派生密钥
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 encryptTransform = aes.CreateEncryptor( );
// 加密后的输出流
System.IO.MemoryStream encryptStream = new System.IO.MemoryStream( );
// 将加密后的目标流（encryptStream）与加密转换（encryptTransform）相连接
System.Security.Cryptography.CryptoStream encryptor = new System.Security.Cryptography.CryptoStream
(encryptStream, encryptTransform, System.Security.Cryptography.CryptoStreamMode.Write);
// 将一个字节序列写入当前 CryptoStream （完成加密的过程）
encryptor.Write(data, 0, data.Length);
encryptor.Close( );
// 将加密后所得到的流转换成字节数组，再用Base64编码将其转换为字符串
string encryptedString = Convert.ToBase64String(encryptStream.ToArray( ));
return(encryptedString);
}
/// <summary>
/// Returns a platform-specific algorithm that conforms to the prescribed platform-neutral algorithm.
/// </summary>
/// <returns>
/// The platform-specific algorithm.
/// </returns>
private Platform.SymmetricAlgorithm GetAlgorithm()
{
#if SILVERLIGHT
if (this.Name == SymmetricAlgorithmName.Aes &&
this.Mode == SymmetricAlgorithmMode.Cbc &&
this.Padding == SymmetricAlgorithmPadding.PKCS7)
{
return(new Platform.AesManaged());
}
else
{
throw new NotSupportedException();
}
#else
Platform.SymmetricAlgorithm platform = null;
#if __IOS__
if (this.Name == SymmetricAlgorithmName.Aes)
{
platform = new Platform.AesManaged();
}
#else
platform = Platform.SymmetricAlgorithm.Create(this.Name.GetString());
#endif
if (platform == null)
{
throw new NotSupportedException();
}
platform.Mode = GetMode(this.Mode);
platform.Padding = GetPadding(this.Padding);
return(platform);
#endif
}
/// <summary>
/// Encrypts the plainText input using the given Key.
/// A 128 bit random salt will be generated and prepended to the ciphertext before it is returned.
/// </summary>
/// <param name="plainText">The plain text to encrypt.</param>
/// <param name="password">The plain text encryption key.</param>
/// <returns>The salt and the ciphertext</returns>
public static byte[] Encrypt(byte[] plainText, string password)
{
if (plainText == null || plainText.Length == 0) throw new ArgumentNullException("plainText");
if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password");
// Derive a new Salt, Key, and IV from the password
using (var keyDerivationFunction = new Rfc2898DeriveBytes(password, SaltSize))
{
var saltBytes = keyDerivationFunction.Salt;
var keyBytes = keyDerivationFunction.GetBytes(32);
var ivBytes = keyDerivationFunction.GetBytes(16);
using (var aesManaged = new AesManaged())
using (var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes))
using (var memoryStream = new MemoryStream())
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
{
using (var streamWriter = new BinaryWriter(cryptoStream))
{
streamWriter.Write(plainText);
}
var cipherTextBytes = memoryStream.ToArray();
Array.Resize(ref saltBytes, saltBytes.Length + cipherTextBytes.Length);
Array.Copy(cipherTextBytes, 0, saltBytes, SaltSize, cipherTextBytes.Length);
return saltBytes;
}
}
}
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 void Can_Send_Encrypted_Message()
{
var client = CreateClient();
var request = new HelloSecure { Name = "World" };
var aes = new AesManaged { KeySize = AesUtils.KeySize };
var aesKeyBytes = aes.Key.Combine(aes.IV);
var rsaEncAesKeyBytes = RsaUtils.Encrypt(aesKeyBytes, SecureConfig.PublicKeyXml);
var timestamp = DateTime.UtcNow.ToUnixTime();
var requestBody = timestamp + " POST " + typeof(HelloSecure).Name + " " + request.ToJson();
var encryptedMessage = new EncryptedMessage
{
EncryptedSymmetricKey = Convert.ToBase64String(rsaEncAesKeyBytes),
EncryptedBody = AesUtils.Encrypt(requestBody, aes.Key, aes.IV)
};
var encResponse = client.Post(encryptedMessage);
var responseJson = AesUtils.Decrypt(encResponse.EncryptedBody, aes.Key, aes.IV);
var response = responseJson.FromJson<HelloSecureResponse>();
Assert.That(response.Result, Is.EqualTo("Hello, World!"));
}
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 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 "";
}
}
/// <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>
/// Encrypt a string using AES
/// </summary>
/// <param name="Str">String to encrypt</param>
/// <param name="Password">Encryption password</param>
/// <param name="Salt">A salt string (at least 8 bytes)</param>
/// <returns>Encrypted string in case of success; otherwise - empty string</returns>
public static string EncryptString(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 encryptionStream = new MemoryStream())
{
using (CryptoStream encrypt = new CryptoStream(encryptionStream, aes.CreateEncryptor(), CryptoStreamMode.Write))
{
byte[] utfD1 = UTF8Encoding.UTF8.GetBytes(Str);
encrypt.Write(utfD1, 0, utfD1.Length);
encrypt.FlushFinalBlock();
}
return Convert.ToBase64String(encryptionStream.ToArray());
}
}
}
catch (Exception ex)
{
Debug.WriteLine("Error : AES ~ EncryptString ; " + ex.Message);
return "";
}
}
/// <summary>
/// konstruktor obiektu Server
/// </summary>
public Server()
{
requestReceived += Server_requestReceived;
aesKeyGenerator = new AesManaged();
hashAlgorithm = new SHA256Managed();
rsaKeyGenerator = new RSACryptoServiceProvider();
}
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);
}
}
}
}
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;
}
/// <summary>
/// Encrypt the data
/// </summary>
/// <param name="input">String to encrypt</param>
/// <returns>Encrypted string</returns>
public static string Encrypt(string input, string password)
{
byte[] utfData = UTF8Encoding.UTF8.GetBytes(input);
byte[] saltBytes = Encoding.UTF8.GetBytes(password);
string encryptedString = string.Empty;
using (AesManaged 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 encryptTransform = aes.CreateEncryptor())
{
using (MemoryStream encryptedStream = new MemoryStream())
{
using (CryptoStream encryptor =
new CryptoStream(encryptedStream, encryptTransform, CryptoStreamMode.Write))
{
encryptor.Write(utfData, 0, utfData.Length);
encryptor.Flush();
encryptor.Close();
byte[] encryptBytes = encryptedStream.ToArray();
encryptedString = Convert.ToBase64String(encryptBytes);
}
}
}
}
return encryptedString;
}
/// <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 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 string Encrypt(string plainText, string key)
{
if (string.IsNullOrEmpty(plainText))
throw new ArgumentNullException("plainText");
if (string.IsNullOrEmpty(key))
throw new ArgumentNullException("key");
using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, _saltSize))
{
var saltBytes = keyDerivationFunction.Salt;
var keyBytes = keyDerivationFunction.GetBytes(32);
var ivBytes = keyDerivationFunction.GetBytes(16);
using (var aesManaged = new AesManaged())
using (var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes))
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
using (var streamWriter = new StreamWriter(cryptoStream))
streamWriter.Write(plainText);
var cipherTextBytes = memoryStream.ToArray();
Array.Resize(ref saltBytes, saltBytes.Length + cipherTextBytes.Length);
Array.Copy(cipherTextBytes, 0, saltBytes, _saltSize, cipherTextBytes.Length);
return Convert.ToBase64String(saltBytes);
}
}
}
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();
}
}
}
static Boolean Test()
{
Boolean bResult;
Console.WriteLine("Testing AesManaged encrypt/decrypt...");
AesManaged aes = new AesManaged();
EncDec ed = new EncDec();
EncDecMul edm = new EncDecMul();
bResult = ed.TestAlgorithm(aes);
bResult = edm.TestAlgorithm(aes) && bResult;
if (AesCSPSupported())
{
Console.WriteLine("Testing AesCryptoServiceProvider encrypt/decrypt...");
AesCryptoServiceProvider aescsp = new AesCryptoServiceProvider();
ed = new EncDec();
edm = new EncDecMul();
bResult = ed.TestAlgorithm(aescsp);
bResult = edm.TestAlgorithm(aescsp) && bResult;
}
return bResult;
}
///<summary>Encrypts signature text and returns a base 64 string so that it can go directly into the database.</summary>
public static string Encrypt(string str,byte[] key){
//No need to check RemotingRole; no call to db.
if(str==""){
return "";
}
byte[] ecryptBytes=Encoding.UTF8.GetBytes(str);
MemoryStream ms=new MemoryStream();
CryptoStream cs=null;
Aes aes=new AesManaged();
aes.Key=key;
aes.IV=new byte[16];
ICryptoTransform encryptor=aes.CreateEncryptor(aes.Key,aes.IV);
cs=new CryptoStream(ms,encryptor,CryptoStreamMode.Write);
cs.Write(ecryptBytes,0,ecryptBytes.Length);
cs.FlushFinalBlock();
byte[] encryptedBytes=new byte[ms.Length];
ms.Position=0;
ms.Read(encryptedBytes,0,(int)ms.Length);
cs.Dispose();
ms.Dispose();
if(aes!=null) {
aes.Clear();
}
return Convert.ToBase64String(encryptedBytes);
}
public int dbEncrypt(String partition, int size, String data, out String dataOut)
{
AesManaged aes = null;
MemoryStream memoryStream = null;
CryptoStream cryptoStream = null;
try
{
aes = new AesManaged();
aes.Key = readKeyFromFile(partition);
memoryStream = new MemoryStream();
cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
byte[] buf = Encoding.UTF8.GetBytes(data);
cryptoStream.Write(buf, 0, buf.Length);
cryptoStream.FlushFinalBlock();
dataOut = Convert.ToBase64String(memoryStream.ToArray());
}
finally
{
if (cryptoStream != null)
cryptoStream.Close();
if (memoryStream != null)
memoryStream.Close();
if (aes != null)
aes.Clear();
}
return getErrorCode() == 0 ? 1 : 0;
}
public UniRx.IObservable <Sas.Net.HTTPResult> SignUp(AccountSignupParam param)
{
return(Observable.Range(0, 1)
.SelectMany(_ => {
var req = new AccountSignUpReqParam();
using (var aes = new System.Security.Cryptography.AesManaged()) {
using (var iv = SecureHelper.APP_IV) {
aes.IV = iv.GetByte(Convert.FromBase64String);
}
using (var key = SecureHelper.APP_KEY) {
aes.Key = key.GetByte(Convert.FromBase64String);
}
req.authentication = authentication;
req.token = param.password.GetByte(aes.Encrypt);
req.email = param.email.GetByte(aes.Encrypt);
using (var rsa = new System.Security.Cryptography.RSACryptoServiceProvider()) {
req.public_key = aes.Encrypt(rsa.ToXmlString(false));
req.private_key = rsa.ExportPrivateKey().GetByte(aes.Encrypt);
req.test = param.email.GetByte(rsa.Encrypt);
}
}
var json = JObject.FromObject(req);
return context.Post("/Account/SignUp", json);
}));
}
public Secret Encrypt(string plainText)
{
Secret result = new Secret();
using (MemoryStream ms = new MemoryStream())
{
using (Aes aesAlg = new AesManaged())
{
aesAlg.Key = _key;
result.IV = aesAlg.IV;
ICryptoTransform encryptor = aesAlg.CreateEncryptor();
using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
byte[] rawPlaintext = Encoding.Unicode.GetBytes(plainText);
cs.Write(rawPlaintext, 0, rawPlaintext.Length);
cs.FlushFinalBlock();
// get the encrypted text
ms.Seek(0, SeekOrigin.Begin);
byte[] content = new byte[ms.Length];
ms.Read(content, 0, content.Length);
result.Data = content;
}
}
}
return result;
}
// should be used to encrypt a key with another key
public static string EncryptWithKey(this string plaintext, string hexkey, string iv)
{
byte[] key = hexkey.ToByteArray ();
byte[] byte_iv = iv.ToByteArray ();
var aes = new AesManaged ();
if (key.Length != 16 && key.Length != 20 && key.Length != 32)
throw new Exception ("Key must be 128, 192 or 256 bits");
ICryptoTransform encryptor = aes.CreateEncryptor (key, byte_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);
}
var encrypted = msEncrypt.ToArray();
return encrypted.ToHexString ();
}
}
}
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;
}
public static string Encrypt(string plainText, string key)
{
if(string.IsNullOrEmpty(plainText)) {
throw new ArgumentNullException("plainText");
}
if(string.IsNullOrEmpty(key)) {
throw new ArgumentNullException("key");
}
using(var keyDerivationFunction = new Rfc2898DeriveBytes(key, SALT_SIZE)) {
byte[] saltBytes = keyDerivationFunction.Salt;
byte[] keyBytes = keyDerivationFunction.GetBytes(32);
byte[] ivBytes = keyDerivationFunction.GetBytes(16);
using(var aesManaged = new AesManaged()) {
aesManaged.KeySize = 256;
using(var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) {
MemoryStream memoryStream = null;
CryptoStream cryptoStream = null;
return WriteMemoryStream(plainText, ref saltBytes, encryptor, ref memoryStream, ref cryptoStream);
}
}
}
}
/// <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 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;
}
}
}
}
public String EncryptIt(String s)
{
Encoding byteEncoder = Encoding.UTF8;
byte[] rijnKey = byteEncoder.GetBytes("h504lXb1erd4ilw7"); //this is key for encrypt data
byte[] rijnIV = byteEncoder.GetBytes("4hx7e4bwM15d0CrL"); //this is iv for encrypt data
String result;
AesManaged rijn = new AesManaged();
//Using AES-128
rijn.KeySize = 128;
rijn.BlockSize = 128;
using (MemoryStream msEncrypt = new MemoryStream())
{
using (ICryptoTransform encryptor = rijn.CreateEncryptor(rijnKey, rijnIV))
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
{
swEncrypt.Write(s);
}
}
}
result = Convert.ToBase64String(msEncrypt.ToArray());
}
rijn.Clear();
return result;
}
public static byte[] GenerateIV()
{
var aes = new System.Security.Cryptography.AesManaged();
aes.KeySize = 256;
aes.GenerateIV();
return(aes.IV);
}
internal ReferenceAttributeCollection()
{
#if WINDOWS_PHONE
m_hash = new HASH();
#else
m_hash = HASH.Create();
#endif
}
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());
}
static byte[] MakeAuthentication(JToken token)
{
var cipher = token.ToObject <byte[]> ();
using (var aes = new System.Security.Cryptography.AesManaged()) {
using (var key = Sas.SecureHelper.APP_KEY)
aes.Key = key.GetByte(Convert.FromBase64String);
using (var iv = Sas.SecureHelper.APP_IV)
aes.IV = iv.GetByte(Convert.FromBase64String);
using (var question = aes.Decrypt(cipher.ToArray())) {
var val = SasUtil.Evaluate(question.GetByte(b => b));
question.AppendChar('=');
foreach (var ch in val.ToString())
{
question.AppendChar(ch);
}
return(question.GetByte(aes.Encrypt));
}
}
}
UniRx.IObservable <Net.HTTPResult> LoginAsSas(AccountLoginParam param)
{
return(Observable.Range(0, 1)
.SelectMany(_ => {
var req = new AccountLoginReqParam();
using (var aes = new System.Security.Cryptography.AesManaged()) {
using (var iv = SecureHelper.APP_IV) {
aes.IV = iv.GetByte(Convert.FromBase64String);
}
using (var key = SecureHelper.APP_KEY) {
aes.Key = key.GetByte(Convert.FromBase64String);
}
req.email = param.email.GetByte(aes.Encrypt);
req.token = param.password.GetByte(aes.Encrypt);
}
var json = JObject.FromObject(req);
return context.Post("/Account/Login", json);
}));
}
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);
}
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);
}
}
}
}
/// <summary>
/// Returns a platform-specific algorithm that conforms to the prescribed platform-neutral algorithm.
/// </summary>
/// <returns>
/// The platform-specific algorithm.
/// </returns>
private Platform.SymmetricAlgorithm GetAlgorithm()
{
Platform.SymmetricAlgorithm?platform = null;
#if __IOS__
if (this.Name == SymmetricAlgorithmName.Aes)
{
platform = new Platform.AesManaged();
}
#elif NETCOREAPP1_0
platform = Platform.Aes.Create();
#else
platform = Platform.SymmetricAlgorithm.Create(this.Name.GetString());
#endif
if (platform == null)
{
throw new PlatformNotSupportedException();
}
platform.Mode = GetMode(this.Mode);
platform.Padding = GetPadding(this.Padding);
return(platform);
}
void Start()
{
AES = new System.Security.Cryptography.AesManaged();
}
