public InsecureManager(CryptManager cryptManager)
{
this.cryptManager = cryptManager;
md5HashGenerator =
new Implementations.Hash.Insecure.MD5HashAdapter();
symmetricRC4CryptGenerator =
new Implementations.Crypt.Insecure.RC4Adapter();
}
public static byte[] DecryptThenMacWithAESDotNet(byte[] keyBytes, byte[] allBytes, byte[] associatedData)
{
using (Aes crypto = new AesManaged()
{
Mode = CipherMode.CBC,
Padding = PaddingMode.PKCS7
}) {
HMACSHA256 mac = new HMACSHA256();
mac.Key = keyBytes;
byte[] iv = new byte[crypto.BlockSize / 8];
byte[] macBytes = new byte[mac.HashSize / 8];
byte[] cipherBytes = new byte[allBytes.Length - iv.Length - macBytes.Length];
using (MemoryStream ms = new MemoryStream(allBytes, /*writable*/ false)) {
ms.Read(iv, 0, iv.Length);
ms.Read(cipherBytes, 0, cipherBytes.Length);
ms.Read(macBytes, 0, macBytes.Length);
}
crypto.Key = keyBytes;
crypto.IV = iv;
byte[] maccable = new byte[iv.Length + cipherBytes.Length];
iv.CopyTo(maccable, 0);
cipherBytes.CopyTo(maccable, iv.Length);
byte[] hBytes = maccable;
if (associatedData != null)
{
hBytes = new byte[maccable.Length + associatedData.Length];
maccable.CopyTo(hBytes, 0);
associatedData.CopyTo(hBytes, maccable.Length);
}
byte[] mBytes = mac.ComputeHash(hBytes);
// Need to question why the slowEquals here
if (!CryptManager.SlowEquals(mBytes, macBytes))
{
throw new InvalidOperationException("Cannot decrypt the content");
}
MemoryStream output = new MemoryStream();
using (CryptoStream cs = new CryptoStream(output, crypto.CreateDecryptor(), CryptoStreamMode.Write)) {
cs.Write(cipherBytes, 0, cipherBytes.Length);
}
output.Close();
return(output.ToArray());
}
}
/// <summary>
/// Creates a Decryptor CryptoStream based on the AES 128 OFB algorithm.
/// </summary>
/// <param name="inputStream">The input stream.</param>
/// <param name="key">The Key.</param>
/// <param name="iv"></param>
/// <returns>the Decryptor CryptoStream</returns>
private static CryptoStream GetAES128DecryptorStream(Stream inputStream, string key, string iv)
{
// Pre: iv is a 16bytes base64 encoded string
return(CryptManager.Instance.GetAES128DecryptorStream(inputStream, CryptManager.DecodeBase64ToBytes(key),
CryptManager.DecodeBase64ToBytes(iv)));
}
public static string DecryptThenMacWithAES(string key, string ciphertext)
{
return(Encoding.UTF8.GetString(DecryptThenMacWithAES(CryptManager.DecodeBase64ToBytes(key), CryptManager.DecodeBase64ToBytes(ciphertext), null)));
}
public static string EncryptThenMacWithAES(string key, string plaintext)
{
string result = CryptManager.EncodeBase64(EncryptThenMacWithAES(CryptManager.DecodeBase64ToBytes(key), Encoding.UTF8.GetBytes(plaintext), null));
return(result);
}
public static string DeriveKeyFromSecret(string secret, int keySizeInBytes)
{
var keyGenerator = new Rfc2898DeriveBytes(secret, RFC_2898_DERIVE_BYTES_SALT);
return(CryptManager.EncodeBase64(keyGenerator.GetBytes(keySizeInBytes)));
}
internal string HashUsingUTF16(string bytes)
{
return(CryptManager.HashUsingUTF16(bytes, md5HashGenerator));
}
internal string HashUsingDefaultEncoding(string plain)
{
return(CryptManager.HashUsingDefaultEncoding(plain, md5HashGenerator));
}
internal string Hash(byte[] bytes)
{
return(CryptManager.Hash(bytes, md5HashGenerator));
}
internal byte[] HashToBytes(byte[] bytes)
{
return(CryptManager.HashToBytes(bytes, md5HashGenerator));
}
internal string HexDeriveUsingUTF16(string plainText, string salt)
{
return(CryptManager.HexDeriveUsingUTF16(plainText, salt, md5HashGenerator));
}
internal string GenerateToBase64UsingDefaultEncoding(string text)
{
return(CryptManager.GenerateToBase64UsingDefaultEncoding(text, md5HashGenerator));
}
internal Guid ToGuidWithSaltAndUTF16(string data, string salt)
{
return(CryptManager.ToGuidWithSaltAndUTF16(data, salt, md5HashGenerator));
}
internal Guid ToGuidUsingDefaultEncoding(string text)
{
return(CryptManager.ToGuidUsingDefaultEncoding(text, md5HashGenerator));
}
internal Guid ToGuid(byte[] data)
{
return(CryptManager.ToGuid(data, md5HashGenerator));
}
