public void DecryptStream(Stream sourcestream, Stream deststream, string key) { byte[] _key = new byte[32]; byte[] _IV = new byte[16]; byte[] myKey = Encoding.ASCII.GetBytes(key); for (int i = 0; i < _key.Length; i++) { _key[i] = 0; } for (int i = 0; (i < _key.Length) && (i < myKey.Length); i++) { _key[i] = myKey[i]; } for (int i = 0; (i < _key.Length) && (i < _IV.Length); i++) { _IV[i] = _key[i]; } _IV.Reverse(); System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create(); aes.IV = _IV; aes.Key = _key; var decStream = new CryptoStream(sourcestream, aes.CreateDecryptor(), CryptoStreamMode.Read); deststream.SetLength(0); decStream.CopyTo(deststream); }
/// <summary> /// Decrypt a message /// </summary> /// <param name="messageToDecrypt">The message to be decrypted</param> /// <param name="secretKey">The 32 characters long secret key to be used on the encryption</param> /// <param name="secretVector">The 16 characters long secret vector to be used on the encryption</param> /// <returns>The decrypted message</returns> public static String Decrypt(String messageToDecrypt, String secretKey, String secretVector) { String messageDecrypted = null; using (System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create()) { aes.Key = System.Text.Encoding.UTF8.GetBytes(secretKey); aes.IV = System.Text.Encoding.UTF8.GetBytes(secretVector); ICryptoTransform iCryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV); using (MemoryStream memoryStream = new MemoryStream(Convert.FromBase64String(messageToDecrypt))) { using (CryptoStream cryptoStream = new CryptoStream(memoryStream, iCryptoTransform, CryptoStreamMode.Read)) { using (StreamReader streamReader = new StreamReader(cryptoStream)) { messageDecrypted = streamReader.ReadToEnd(); } } } } return(messageDecrypted); }
private static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV) { // Declare the string used to hold // the decrypted text. string plaintext = null; // Create an Aes object // with the specified key and IV. using (System.Security.Cryptography.Aes aesAlg = System.Security.Cryptography.Aes.Create()) { aesAlg.Key = Key; aesAlg.IV = IV; // Create a decrytor to perform the stream transform. System.Security.Cryptography.ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); // Create the streams used for decryption. using (System.IO.MemoryStream msDecrypt = new System.IO.MemoryStream(cipherText)) { using (System.Security.Cryptography.CryptoStream csDecrypt = new System.Security.Cryptography.CryptoStream( msDecrypt, decryptor, System.Security.Cryptography.CryptoStreamMode.Read)) { using (System.IO.StreamReader srDecrypt = new System.IO.StreamReader(csDecrypt)) { // Read the decrypted bytes from the decrypting stream // and place them in a string. plaintext = srDecrypt.ReadToEnd(); } } } } return(plaintext); }
private static string DecryptStringFromBytesAes(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("IV"); } using (System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create()) { aes.Padding = PaddingMode.None; aes.Mode = CipherMode.CBC; aes.Key = key; aes.IV = iv; using (var output = new MemoryStream()) using (var decryptor = aes.CreateDecryptor(aes.Key, aes.IV)) using (var ms = new MemoryStream(cipherText)) using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { cs.CopyTo(output); return(output.ToArray().ToHexString()); } } }
protected virtual ICryptoTransform CreateTransform(System.Security.Cryptography.Aes aes, byte[] key, byte[] iv, AesMode mode) { if (aes == null) { throw new ArgumentNullException(nameof(aes)); } if (key == null) { throw new ArgumentNullException(nameof(key)); } if (iv == null) { throw new ArgumentNullException(nameof(iv)); } switch (mode) { case AesMode.Decrypt: return(aes.CreateDecryptor(key, iv)); case AesMode.Encrypt: return(aes.CreateEncryptor(key, iv)); default: throw new ArgumentOutOfRangeException(); } }
public override void init(int mode, byte[] key, byte[] iv) { if (mode != ENCRYPT_MODE && mode != DECRYPT_MODE) throw new ArgumentOutOfRangeException(); ms = new PipedMemoryStream(); aesm = AesManaged.Create(); aesm.BlockSize = blockSize * 8; aesm.Padding = PaddingMode.None; ICryptoTransform ict; if (key.Length > blockSize) { byte[] tmp = new byte[blockSize]; Array.Copy(key, 0, tmp, 0, tmp.Length); key = tmp; } if (iv.Length > ivSize) { byte[] tmp = new byte[ivSize]; Array.Copy(iv, 0, tmp, 0, tmp.Length); iv = tmp; } if (mode == ENCRYPT_MODE) { ict = aesm.CreateEncryptor(key, iv); } else { ict = aesm.CreateDecryptor(key, iv); } cs = new CryptoStream(ms, ict, CryptoStreamMode.Write); }
public byte[] Decrypt(byte[] buffer) { #if WINDOWS_STORE SymmetricKeyAlgorithmProvider provider = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7); CryptographicKey aes = provider.CreateSymmetricKey(CryptographicBuffer.CreateFromByteArray(this.key)); IBuffer result = CryptographicEngine.Decrypt(aes, CryptographicBuffer.CreateFromByteArray(buffer), CryptographicBuffer.CreateFromByteArray(this.iv)); byte[] decrypted; CryptographicBuffer.CopyToByteArray(result, out decrypted); return(decrypted); #else using (System.Security.Cryptography.Aes aes = AesManaged.Create()) { aes.KeySize = 256; aes.Mode = CipherMode.CBC; aes.IV = iv; aes.Key = key; using (ICryptoTransform decryptor = aes.CreateDecryptor()) { return(decryptor.TransformFinalBlock(buffer, 0, buffer.Length)); } } #endif }
internal int ProcessDecryption(crypto.Aes cipher, CommandLine commandLine) { Stream inputStream = CreateInputStream(commandLine); Stream outputStream = CreateOutputStream(commandLine); if (commandLine.SkipBytes > 0) { if (commandLine.SkipBytes >= inputStream.Length) { return(0); } if (inputStream.CanSeek) { inputStream.Position = commandLine.SkipBytes; } else { for (int i = 0; i < commandLine.SkipBytes; i++) { inputStream.ReadByte(); } } } var versionBytes = new byte[2]; inputStream.Read(versionBytes, 0, versionBytes.Length); ushort version = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(versionBytes, 0)); if (version != Constants.FormatVersion) { Console.WriteLine($"Unsupported version, expected {Constants.FormatVersion}, found {version}."); return(1); } // reads 16 bytes of IV var iv = new byte[cipher.BlockSize / 8]; // cipher.BlockSize / 8 = 16 since block size is always 128 for AES algorithm inputStream.Read(iv, 0, iv.Length); // reads 2 bytes of salt size (in host order) byte[] saltLengthBytes = new byte[sizeof(ushort)]; inputStream.Read(saltLengthBytes, 0, saltLengthBytes.Length); int saltLength = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(saltLengthBytes, 0)); // reads n bytes of salt byte[] salt = new byte[saltLength]; inputStream.Read(salt, 0, salt.Length); var key = new Rfc2898DeriveBytes(commandLine.Password, salt, commandLine.KeyIterations); cipher.IV = iv; cipher.Key = key.GetBytes(cipher.KeySize / 8); using (Stream cryptoStream = new CryptoStream(inputStream, cipher.CreateDecryptor(), CryptoStreamMode.Read)) cryptoStream.CopyTo(outputStream); return(0); }
public AES(byte[] key) { rsa = new AesManaged(); rsa.GenerateKey(); rsa.GenerateIV(); _decoder = rsa.CreateDecryptor(); _encoder = rsa.CreateEncryptor(); }
private static string Decrypt(byte[] cipherText, byte[] key, byte[] iv) { var decryptor = Aes.CreateDecryptor(key, iv); using (var ms = new MemoryStream(cipherText)) using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) using (var sr = new StreamReader(cs)) return(sr.ReadToEnd()); }
/********************************************************************************************************** * UserData LoadUserData(string MasterPassword) * Purpose: Loads data, if it exists, from the disk. The data is encrypted using AES using the * master password's hash as the secret key. **********************************************************************************************************/ private UserData LoadUserData(string MasterPassword) { // Need 128 bits password for the encryption key. ApplicationEntry self = new ApplicationEntry("MasterPass", 128 / sizeof(char) / 8, 0, true, true, true, false); HashedPassword fileName = self.GeneratePassword(MasterPassword); HashedPassword aesKey = self.GeneratePassword(MasterPassword); HashedPassword aesIV = self.GeneratePassword(MasterPassword); System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create(); // Even if aes is broken the master password is unrecoverable. aes.Key = Encoding.Unicode.GetBytes(aesKey.Password); aes.IV = Encoding.Unicode.GetBytes(aesIV.Password); aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7; ICryptoTransform decryptor = aes.CreateDecryptor(); UserData loadedData = null; // If there is no data don't load it. if (File.Exists(fileName.Password + ".pass") == false) { return(loadedData); } // Open the file using (FileStream outputStream = new FileStream(fileName.Password + ".pass", FileMode.Open)) { // Use a safe to file encryption method using (CryptoStream csDecrypt = new CryptoStream(outputStream, decryptor, CryptoStreamMode.Read)) { // Convert the object to a byte array using (MemoryStream objectStream = new MemoryStream()) { byte[] buffer = new byte[1024]; int bytesRead = csDecrypt.Read(buffer, 0, buffer.Length); while (bytesRead > 0) { objectStream.Write(buffer, 0, bytesRead); bytesRead = csDecrypt.Read(buffer, 0, buffer.Length); } csDecrypt.Flush(); objectStream.Position = 0; IFormatter formatter = new BinaryFormatter(); loadedData = formatter.Deserialize(objectStream) as UserData; } } } return(loadedData); }
public SimpleAes(byte[] key) { aes = Aes.Create(); aes.GenerateIV(); aes.Key = key; encryptor = aes.CreateEncryptor(key, aes.IV); decryptor = aes.CreateDecryptor(key, aes.IV); }
static DBCrypto() { aesAlg = Aes.Create(); aesAlg.Key = AES_CBC_KEY; aesAlg.IV = AES_CBC_IV; aesAlg.Padding = PaddingMode.PKCS7; decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); }
/// <summary> /// AES加解密 /// </summary> /// <param name="aes"></param> /// <param name="forEncryption">是否加密(false为解密)</param> /// <param name="data">待加解密的数据</param> /// <param name="key">加解密密钥,为空则使用实体属性Key</param> /// <param name="mode">加解密模式,为空则使用实体属性Mode</param> /// <param name="padding">填充算法,为空则使用实体属性Padding</param> /// <returns>加解密后数据</returns> public static byte[] Crypto(this System.Security.Cryptography.Aes aes, bool forEncryption, byte[] data, byte[] key = null, CipherMode?mode = null, PaddingMode?padding = null) { aes.Key = key ?? aes.Key; aes.Mode = mode ?? aes.Mode; aes.Padding = padding ?? aes.Padding; var cryptor = forEncryption ? aes.CreateEncryptor() : aes.CreateDecryptor(); return(cryptor.TransformFinalBlock(data, 0, data.Length)); }
internal static byte[] AES256Decrypt(byte[] block, byte[] key) { using (System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create()) { aes.Key = key; aes.Mode = System.Security.Cryptography.CipherMode.ECB; aes.Padding = System.Security.Cryptography.PaddingMode.None; using (System.Security.Cryptography.ICryptoTransform decryptor = aes.CreateDecryptor()) { return(decryptor.TransformFinalBlock(block, 0, block.Length)); } } }
private string CryptoTransform(string input, bool base64in, bool base64out, Aes cipher, CMode mode) { byte[] bytes; if (base64in) bytes = decode64(input); else bytes = Encoding.UTF8.GetBytes(input); using (var c = mode == CMode.ENCRYPT ? cipher.CreateEncryptor() : cipher.CreateDecryptor()) { var buf = c.TransformFinalBlock(bytes, 0, bytes.Length); return base64out ? encode64(buf) : Encoding.UTF8.GetString(buf); } }
/// <summary> /// Decrypts data. /// </summary> /// <param name="aes">Aes object.</param> /// <param name="encrypted">Encrypted data to be decrypted.</param> /// <param name="key">Encryption key.</param> /// <param name="iv">Initial vector.</param> /// <returns>Decrypted data.</returns> public static byte[] Decrypt(Aes aes, byte[] encrypted, byte[] key, byte[] iv) { byte[] buffer = new byte[encrypted.Length]; var decryptor = aes.CreateDecryptor(key, iv); using (MemoryStream ms = new MemoryStream(encrypted)) { using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { int length = cs.Read(buffer, 0, encrypted.Length); return buffer.Take(length).ToArray(); } } }
/// <summary> /// Decrypt the giving <see cref="Byte"> <see cref="Array"/>. /// </summary> /// <param name="cipherText">The <see cref="Byte"> <see cref="Array"/> that contains data to decrypt.</param> /// <param name="Key">The <see cref="Byte"> <see cref="Array"/> that contains the key.</param> /// <param name="IV">The <see cref="Byte"> <see cref="Array"/> that contains the initialize vector.</param> /// <returns>The decrypted data.</returns> public static byte[] Decrypt(byte[] cipherText, byte[] Key, byte[] IV) { // Check arguments if (ReferenceEquals(cipherText, null) || cipherText.Length <= 0) { throw (new ArgumentNullException("cipherText")); } if (ReferenceEquals(Key, null) || Key.Length <= 0) { throw (new ArgumentNullException("Key")); } if (ReferenceEquals(IV, null) || IV.Length <= 0) { throw (new ArgumentNullException("IV")); } // Declare the string used to hold the decrypted text byte[] clearBytes = null; // Create an Aes object with the specified key and IV using (System.Security.Cryptography.Aes aesAlg = AesManaged.Create()) { aesAlg.Key = Key; aesAlg.IV = IV; aesAlg.Padding = PaddingMode.Zeros; // Create a decrytor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); // Create the streams used for decryption. using (MemoryStream msDecrypt = new MemoryStream(cipherText)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Write)) { csDecrypt.Write(cipherText, 0, cipherText.Length); csDecrypt.Flush(); csDecrypt.Close(); } clearBytes = msDecrypt.ToArray(); } } return(clearBytes); }
public static string DecryptStringFromBytes_AES(byte[] cipherText, byte[] Key, byte[] IV) { // Check arguments if (ReferenceEquals(cipherText, null) || cipherText.Length <= 0) { throw (new ArgumentNullException("cipherText")); } if (ReferenceEquals(Key, null) || Key.Length <= 0) { throw (new ArgumentNullException("Key")); } if (ReferenceEquals(IV, null) || IV.Length <= 0) { throw (new ArgumentNullException("Key")); } // Declare the string used to hold the decrypted text string plaintext = null; // Create an Aes object with the specified key and IV using (System.Security.Cryptography.Aes aesAlg = System.Security.Cryptography.Aes.Create()) { aesAlg.Key = Key; aesAlg.IV = IV; // Create a decrytor to perform the stream transform. ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); // Create the streams used for decryption. using (MemoryStream msDecrypt = new MemoryStream(cipherText)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader srDecrypt = new StreamReader(csDecrypt)) { // Read the decrypted bytes from the decrypting stream and place them in a string plaintext = srDecrypt.ReadToEnd(); } } } } return(plaintext); }
/// <summary> /// Encrypt a byte array by using the AES algorightm. /// <para>The input is: [Magic Number (4 bytes)] [AES IV (16 bytes)] [AES(data) (xx bytes)] [HMAC(IV || AES(data)) (32 bytes)]</para> /// <para>The output is: [data]</para> /// </summary> public static byte[] Decrypt(byte[] content, Aes aes) { byte[] headerBytes = new byte[4]; byte[] ivBytes = new byte[16]; byte[] dataBytes = new byte[content.Length - 4 - 16 - 32]; byte[] cypherBytes = new byte[ivBytes.Length + dataBytes.Length]; byte[] hmacBytes = new byte[32]; Array.Copy (content, 0, headerBytes, 0, headerBytes.Length); Array.Copy (content, 4, ivBytes, 0, ivBytes.Length); Array.Copy (content, 4 + 16, dataBytes, 0, dataBytes.Length); Array.Copy (content, 4, cypherBytes, 0, cypherBytes.Length); Array.Copy (content, content.Length - 32, hmacBytes, 0, hmacBytes.Length); // Compute the HMAC of the cypher using (HMACSHA256 hmac = new HMACSHA256 (DeriveKey (aes.Key))) { byte[] newHmacBytes = hmac.ComputeHash (cypherBytes); // Check for HMAC equality for (int i = 0; i < newHmacBytes.Length; i++) { if (newHmacBytes [i] != hmacBytes [i]) { throw new CryptographicException ("Content has been tampered. HMAC don't match."); } } } using (MemoryStream outputStream = new MemoryStream()) { // Report the IV aes.IV = ivBytes; // Write the AES decrypted content using (ICryptoTransform transform = aes.CreateDecryptor ()) { using (CryptoStream cryptoStream = new CryptoStream(outputStream, transform, CryptoStreamMode.Write)) { cryptoStream.Write (dataBytes, 0, dataBytes.Length); } } // Collect cypher result outputStream.Flush (); outputStream.Close (); byte[] outputBytes = outputStream.ToArray (); return outputBytes; } }
private bool TestRequestVerifier(Request r, Aes aes, string key) { var success = false; var crypted = decode64(r.Verifier); aes.Key = decode64(key); aes.IV = decode64(r.Nonce); using (var dec = aes.CreateDecryptor()) { try { var buf = dec.TransformFinalBlock(crypted, 0, crypted.Length); var value = Encoding.UTF8.GetString(buf); success = value == r.Nonce; } catch (CryptographicException) { } // implicit failure } return success; }
static Boolean Test(Aes aes, CipherMode md) { Byte[] PlainText = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; Byte[] Key = {1, 1, 1, 1, 1, 1, 1, 1,2,2,2,2,2,2,2,2}; Byte[] IV = {100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115}; Console.WriteLine("Encrypting the following bytes:"); PrintByteArray(PlainText); aes.Mode = md; Console.WriteLine("AES default key size = " + aes.KeySize); ICryptoTransform sse = aes.CreateEncryptor(Key, IV); Console.WriteLine("SSE mode = " + aes.Mode); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write); cs.Write(PlainText,0,PlainText.Length); cs.FlushFinalBlock(); byte[] CipherText = ms.ToArray(); cs.Close(); Console.WriteLine("Cyphertext:"); PrintByteArray(CipherText); Console.WriteLine("Decrypting..."); ICryptoTransform ssd = aes.CreateDecryptor(Key, IV); Console.WriteLine("SSD mode = " + aes.Mode); cs = new CryptoStream(new MemoryStream(CipherText), ssd, CryptoStreamMode.Read); byte[] NewPlainText = new byte[PlainText.Length]; cs.Read(NewPlainText,0,PlainText.Length); PrintByteArray(NewPlainText); if (!Compare(PlainText, NewPlainText)) { Console.WriteLine("ERROR: roundtrip failed"); return false; } return true; }
static Boolean TestKnownEnc(Aes aes, Byte[] Key, Byte[] IV, Byte[] Cipher, Byte[] Plain) { Byte[] CipherCalculated; Console.WriteLine("Encrypting the following bytes:"); PrintByteArray(Plain); Console.WriteLine("With the following Key:"); PrintByteArray(Key); Console.WriteLine("and IV:"); PrintByteArray(IV); Console.WriteLine("Expecting this ciphertext:"); PrintByteArray(Cipher); ICryptoTransform sse = aes.CreateDecryptor(Key, IV); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write); cs.Write(Plain,0,Plain.Length); try { cs.FlushFinalBlock(); } catch (CryptographicException e) { Console.WriteLine(e.ToString()); } CipherCalculated = ms.ToArray(); cs.Close(); Console.WriteLine("Computed this cyphertext:"); PrintByteArray(CipherCalculated); if (!Compare(Cipher, CipherCalculated)) { Console.WriteLine("ERROR: result is different from the expected"); return false; } Console.WriteLine("OK"); return true; }
public override string Decrypt(string cipherText, string key, string iv) { try { System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create(); byte[] inputBytes = Convert.FromBase64String(cipherText); aes.Key = Convert.FromBase64String(key); aes.IV = Convert.FromBase64String(iv); MemoryStream ms = new MemoryStream(); CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write); cs.Write(inputBytes, 0, inputBytes.Length); cs.FlushFinalBlock(); return(Encoding.UTF8.GetString(ms.ToArray())); } catch (Exception e) { return("\nERROR: " + e.Message); } }
public string Decrypt(string str) { str = str.Replace(" ", "+"); byte[] bytes = Convert.FromBase64String(str); using (System.Security.Cryptography.Aes encryptor = System.Security.Cryptography.Aes.Create()) { Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(key, 8); encryptor.Key = pdb.GetBytes(32); encryptor.IV = pdb.GetBytes(16); using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(bytes, 0, bytes.Length); cs.Close(); } return(Encoding.Unicode.GetString(ms.ToArray())); } } }
public static string Decrypt(string DecryptText) { DecryptText = DecryptText.Replace(" ", "+"); byte[] cipherBytes = Convert.FromBase64String(DecryptText); using (Aes encryptor = Aes.Create()) { Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(EncryptionKey, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); encryptor.Key = pdb.GetBytes(32); encryptor.IV = pdb.GetBytes(16); using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(cipherBytes, 0, cipherBytes.Length); cs.Close(); } DecryptText = Encoding.Unicode.GetString(ms.ToArray()); } } return(DecryptText); }
public static string DecryptString(string key, string cipherText) { byte[] iv = new byte[16]; byte[] buffer = Convert.FromBase64String(cipherText); using (Aes aes = Aes.Create()) { aes.Key = Encoding.UTF8.GetBytes(key); aes.IV = iv; ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV); using (MemoryStream memoryStream = new MemoryStream(buffer)) { using (CryptoStream cryptoStream = new CryptoStream((Stream)memoryStream, decryptor, CryptoStreamMode.Read)) { using (StreamReader streamReader = new StreamReader((Stream)cryptoStream)) { return(streamReader.ReadToEnd()); } } } } }
public byte[] DecoderBytes(byte[] inputBytes) { Byte[] outputBytes = inputBytes; byte[] decode = new byte[] { }; using (MemoryStream memoryStream = new MemoryStream(outputBytes)) { using (CryptoStream cryptoStream = new CryptoStream(memoryStream, AES.CreateDecryptor(AES.Key, AES.IV), CryptoStreamMode.Read)) { int len = 1024, count = len; byte[] buffer = new byte[len]; while (count != 0) { count = cryptoStream.Read(buffer, 0, len); decode = Program.ConcatByte(decode, buffer, count); } } } return(decode); }
public void Initialize(ReadOnlySpan <byte> key, ReadOnlySpan <byte> iv, CipherMode mode, bool isDecrypting) { Debug.Assert(key.Length == Aes.KeySize128); Debug.Assert(iv.IsEmpty || iv.Length == Aes.BlockSize); System.Security.Cryptography.Aes aes = System.Security.Cryptography.Aes.Create(); if (aes == null) { throw new CryptographicException("Unable to create AES object"); } aes.Key = key.ToArray(); aes.Mode = mode; aes.Padding = PaddingMode.None; if (!iv.IsEmpty) { aes.IV = iv.ToArray(); } _transform = isDecrypting ? aes.CreateDecryptor() : aes.CreateEncryptor(); _isDecrypting = isDecrypting; }
/// <summary> /// Decrypts a string /// </summary> /// <param name="encryptedString"></param> /// <returns></returns> public string DecryptBytes(byte[] value) { ICryptoTransform et = _cryptor.CreateDecryptor(_cryptor.Key, _cryptor.IV); string output = string.Empty; if (value != null) { using (MemoryStream ms = new MemoryStream(value)) { using (CryptoStream cs = new CryptoStream(ms, et, CryptoStreamMode.Read)) { using (StreamReader sr = new StreamReader(cs, this._encoding, true, this._padding)) { output = sr.ReadToEnd(); sr.Dispose(); } cs.Dispose(); } ms.Dispose(); } } return(output); }
/// <summary> /// AES解密 /// </summary> /// <param name="data">待解密的密文</param> /// <param name="password">加密公钥</param> /// <returns>返回一个由AesEncrypt加密而得到的明文</returns> public static string AesDecrypt(this string data, string password) { if (string.IsNullOrEmpty(data) || string.IsNullOrEmpty(password)) { return(data); } byte[] keyBytes = password.ToBytes(); byte[] toEncryptArray = Convert.FromBase64String(data); Aes aesProvider = Aes.Create(); if (keyBytes.Length < aesProvider.KeySize) { throw new KeySizeException(); } aesProvider.Key = keyBytes; aesProvider.Mode = CipherMode.ECB; aesProvider.Padding = PaddingMode.PKCS7; ICryptoTransform cTransform = aesProvider.CreateDecryptor(); byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return(Encoding.UTF8.GetString(resultArray)); }
private static void Decrypt(byte[] cipherText, byte[] plaintext, byte[] key, byte[] iv) { var decryptor = Aes.CreateDecryptor(key, iv); decryptor.TransformBlock(cipherText, 0, cipherText.Length, plaintext, 0); }
public SegmentReader(Stream _bsstr, Aes rdale, int _fragsize) { _rdale = rdale as AesManaged; basestream = _bsstr; fragsize = _fragsize; reader = rdale.CreateDecryptor(); writer = rdale.CreateEncryptor(); #if !SINGLE_THREADED mthread = new System.Threading.Thread(thetar); mthread.Start(); #endif }
public static bool TestTransform(Aes aes) { ICryptoTransform encryptor; ICryptoTransform decryptor; encryptor = aes.CreateEncryptor(); decryptor = aes.CreateDecryptor(); if (encryptor.CanReuseTransform != true) { Console.WriteLine("Error - encryptor CanReuseTransform not true"); return false; } if (decryptor.CanReuseTransform != true) { Console.WriteLine("Error - decryptor CanReuseTransform not true"); return false; } if (encryptor.CanTransformMultipleBlocks != true) { Console.WriteLine("Error - encryptor CanTransformMultipleBlocks not true"); return false; } if (decryptor.CanTransformMultipleBlocks != true) { Console.WriteLine("Error - decryptor CanTransformMultipleBlocks not true"); return false; } if (encryptor.InputBlockSize != 16) { Console.WriteLine("Error - encryptor InputBlockSize not 16"); return false; } if (decryptor.InputBlockSize != 16) { Console.WriteLine("Error - decryptor InputBlockSize not 16"); return false; } if (encryptor.OutputBlockSize != 16) { Console.WriteLine("Error - encryptor OutputBlockSize not 16"); return false; } if (decryptor.OutputBlockSize != 16) { Console.WriteLine("Error - decryptor OutputBlockSize not 16"); return false; } return true; }
private ICryptoTransform GetMessageDecryptor( Aes aes, TaskAgentMessage message) { if (Session.EncryptionKey.Encrypted) { // The agent session encryption key uses the AES symmetric algorithm var keyManager = HostContext.GetService<IRSAKeyManager>(); using (var rsa = keyManager.GetKey()) { return aes.CreateDecryptor(rsa.Decrypt(Session.EncryptionKey.Value, RSAEncryptionPadding.OaepSHA1), message.IV); } } else { return aes.CreateDecryptor(Session.EncryptionKey.Value, message.IV); } }
public SegmentReader(Stream _bsstr, Aes rdale, int _fragsize) { _rdale = rdale as AesManaged; basestream = _bsstr; fragsize = _fragsize; reader = rdale.CreateDecryptor(); }
public static Message ToMessage(this MemoryStream inStream, Aes aes = null) { if (inStream.Length == 0) throw new Exceptions.CommunicationException("read stream blank!"); MemoryStream plainStream; inStream.Seek(0, SeekOrigin.Begin); //TODO: clean this up string beforeGreaterThan = StreamUtilities.ReadUntilChar(inStream, '<', 5, true); string beforeExclaimation = StreamUtilities.ReadUntilChar(inStream, '!', 5, true); bool streamEncrypted; if (beforeGreaterThan != null && beforeExclaimation == null) streamEncrypted = false; else if (beforeGreaterThan == null && beforeExclaimation != null) streamEncrypted = true; else if (beforeGreaterThan.Length < beforeExclaimation.Length) streamEncrypted = false; else streamEncrypted = true; if (streamEncrypted) { if (aes == null) throw new Exceptions.CommunicationException("oops! Got an encrypted response, but don't know the key."); string numBytesForIvString = StreamUtilities.ReadUntilChar(inStream, '!', 10, false); //int bleh = StreamUtilities.PeekByte(inStream); //string test2 = StreamUtilities.MemoryStreamToString(inStream); int numBytesForIv; try { numBytesForIv = Convert.ToInt32(numBytesForIvString); } catch { throw new Exceptions.CommunicationException("Error parsing the number of bytes for the Initialization Vector"); } byte[] iv = new byte[numBytesForIv]; int numRead = inStream.Read(iv, 0, numBytesForIv); if (numRead != numBytesForIv) throw new Exceptions.CommunicationException("Error reading the initialization vector."); aes.IV = iv; try { plainStream = StreamUtilities.RunCryptoTransform(inStream, aes.CreateDecryptor(), false); plainStream.Seek(0, SeekOrigin.Begin); //string beforeGreaterThan2 = StreamUtilities.ReadUntilChar(inStream, 'x', 50, true); //string test3 = StreamUtilities.MemoryStreamToString(plainStream); //inStream.Seek(0, SeekOrigin.Begin); } catch (CryptographicException exception) { throw new Exceptions.CommunicationException("Error decrypting response.", exception); } } else { plainStream = inStream; } Message result = new Message(plainStream); if (result.controlValues.Count == 0 && result.Values.Count == 0 && result.Payload.Count == 0) throw new Exceptions.CommunicationException("Blank response."); if (!String.IsNullOrEmpty(result.CommunicationErrorMessage)) throw new Exceptions.CommunicationException(result.CommunicationErrorMessage); return result; }
public byte[] DecodeBytes(string s) { return(Transform(rsa.CreateDecryptor(), Encoding.UTF8.GetBytes(s))); }
public static byte[] Decrypt(this byte[] encrypted, FAesKey key) { return(Provider.CreateDecryptor(key.Key, null).TransformFinalBlock(encrypted, 0, encrypted.Length)); }
public static ICryptoTransform getDecryptor(Aes aes) { return aes.CreateDecryptor(aes.Key, aes.IV); }
internal AesCbcHmacSha2Decryptor( string name, byte[] key, byte[] iv, byte[] associatedData ) { // Split the key to get the AES key, the HMAC key and the HMAC object byte[] aesKey; GetAlgorithmParameters( name, key, out aesKey, out _hmac_key, out _hmac ); // Create the AES provider _aes = Aes.Create(); _aes.Mode = CipherMode.CBC; _aes.Padding = PaddingMode.PKCS7; _aes.KeySize = aesKey.Length * 8; _aes.Key = aesKey; _aes.IV = iv; _inner = _aes.CreateDecryptor(); _associated_data_length = ConvertToBigEndian( associatedData.Length * 8 ); // Prime the hash. _hmac.TransformBlock( associatedData, 0, associatedData.Length, associatedData, 0 ); _hmac.TransformBlock( iv, 0, iv.Length, iv, 0 ); }
public static byte[] GetPaddingBytes(Aes aes, PaddingMode mode, int offset) { byte[] originalData = new byte[BlockSizeBytes + offset]; new Random().NextBytes(originalData); aes.Padding = mode; byte[] encryptedData = aes.CreateEncryptor().TransformFinalBlock(originalData, 0, originalData.Length); aes.Padding = PaddingMode.None; byte[] decryptedData = aes.CreateDecryptor().TransformFinalBlock(encryptedData, 0, encryptedData.Length); byte[] paddingBytes = new byte[decryptedData.Length - BlockSizeBytes - offset]; Array.Copy(decryptedData, BlockSizeBytes + offset, paddingBytes, 0, decryptedData.Length - BlockSizeBytes - offset); return paddingBytes; }
public override ICryptoTransform CreateDecryptor() => _impl.CreateDecryptor();
public static bool TestTransform(Aes aes) { CipherMode[] modes; // AES allows CBC, ECB, and CFB modes. Due to bug in RijndaelManaged, AesManaged does not // allow CFB. // if (aes is AesManaged) modes = new CipherMode[] {CipherMode.CBC, CipherMode.ECB}; else modes = new CipherMode[] {CipherMode.CBC, CipherMode.ECB, CipherMode.CFB}; ICryptoTransform encryptor; ICryptoTransform decryptor; foreach (CipherMode mode in modes) { aes.Mode = mode; encryptor = aes.CreateEncryptor(); decryptor = aes.CreateDecryptor(); if (encryptor.CanReuseTransform != true) { Console.WriteLine("Error - encryptor CanReuseTransform not true"); return false; } if (decryptor.CanReuseTransform != true) { Console.WriteLine("Error - decryptor CanReuseTransform not true"); return false; } if (encryptor.CanTransformMultipleBlocks != true) { Console.WriteLine("Error - encryptor CanTransformMultipleBlocks not true"); return false; } if (decryptor.CanTransformMultipleBlocks != true) { Console.WriteLine("Error - decryptor CanTransformMultipleBlocks not true"); return false; } if (encryptor.InputBlockSize != 16) { Console.WriteLine("Error - encryptor InputBlockSize not 16"); return false; } if (decryptor.InputBlockSize != 16) { Console.WriteLine("Error - decryptor InputBlockSize not 16"); return false; } if (encryptor.OutputBlockSize != 16) { Console.WriteLine("Error - encryptor OutputBlockSize not 16"); return false; } if (decryptor.OutputBlockSize != 16) { Console.WriteLine("Error - decryptor OutputBlockSize not 16"); return false; } } return true; }