static Boolean TestKnownEnc(Aes aes, Byte[] Key, Byte[] IV, Byte[] Plain, Byte[] Cipher)
{
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.CreateEncryptor(Key, IV);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, sse, CryptoStreamMode.Write);
cs.Write(Plain,0,Plain.Length);
cs.FlushFinalBlock();
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 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>
/// Encrypt a message
/// </summary>
/// <param name="messageToEncrypt">The message to be encrypted</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 encrypted message</returns>
public static String Encrypt(String messageToEncrypt, String secretKey, String secretVector)
{
String messageEncrypted = 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.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(memoryStream, iCryptoTransform, CryptoStreamMode.Write))
{
using (StreamWriter streamWriter = new StreamWriter(cryptoStream))
{
streamWriter.Write(messageToEncrypt);
}
messageEncrypted = Convert.ToBase64String(memoryStream.ToArray());
}
}
}
return(messageEncrypted);
}
public RijndaelManaged()
{
LegalBlockSizesValue = new KeySizes[] { new KeySizes(minSize: 128, maxSize: 128, skipSize: 0) };
// This class wraps Aes
_impl = Aes.Create();
}
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());
}
}
}
internal Client(TcpClient c, string u, Aes a)
{
this.c = c;
this.u = u;
this.a = a;
s = c.GetStream();
}
static Aes()
{
Provider = AesProvider.Create();
Provider.Mode = CipherMode.ECB;
Provider.Padding = PaddingMode.None;
Provider.BlockSize = BLOCK_SIZE;
}
private void GetAllLoginsHandler(Request r, Response resp, Aes aes)
{
if (!VerifyRequest(r, aes))
return;
var list = new PwObjectList<PwEntry>();
var root = host.Database.RootGroup;
var parms = MakeSearchParameters();
parms.SearchString = @"^[A-Za-z0-9:/-]+\.[A-Za-z0-9:/-]+$"; // match anything looking like a domain or url
root.SearchEntries(parms, list);
foreach (var entry in list)
{
var name = entry.Strings.ReadSafe(PwDefs.TitleField);
var login = GetUserPass(entry)[0];
var uuid = entry.Uuid.ToHexString();
var e = new ResponseEntry(name, login, null, uuid, null);
resp.Entries.Add(e);
}
resp.Success = true;
resp.Id = r.Id;
SetResponseVerifier(resp, aes);
foreach (var entry in resp.Entries)
{
entry.Name = CryptoTransform(entry.Name, false, true, aes, CMode.ENCRYPT);
entry.Login = CryptoTransform(entry.Login, false, true, aes, CMode.ENCRYPT);
entry.Uuid = CryptoTransform(entry.Uuid, false, true, aes, CMode.ENCRYPT);
}
}
public async Task <Stream> OpenReadAsync(CancellationToken ct)
{
Stream stream = null;
System.Security.Cryptography.Aes aes = null;
ICryptoTransform decryptor = null;
try
{
stream = await _fileInfo.OpenReadAsync(ct);
var header = await AesHeader.ReadAsync(stream, ct);
aes = CreateAes(header.Version);
var key = FileSystem.ComputeKey(header.IV, header.Version);
decryptor = CreateTransform(aes, key, header.IV, AesMode.Decrypt); // disposed by CryptoStream
return(new CryptoStream(stream, decryptor, CryptoStreamMode.Read));
}
catch
{
decryptor?.Dispose();
stream?.Dispose();
throw;
}
finally
{
aes?.Dispose();
}
}
private AESCrypto()
{
var pdb = new Rfc2898DeriveBytes(aesPasswd, aesSalt);
aes = new AesManaged();
aes.Key = pdb.GetBytes(aes.KeySize / 8);
aes.IV = pdb.GetBytes(aes.BlockSize / 8);
}
internal RijndaelImplementation()
{
LegalBlockSizesValue = new KeySizes[] { new KeySizes(minSize: 128, maxSize: 128, skipSize: 0) };
// This class wraps Aes
_impl = Aes.Create();
}
internal void ProcessEncryption(crypto.Aes cipher, CommandLine commandLine)
{
var key = new Rfc2898DeriveBytes(commandLine.Password, commandLine.KeySaltLength, commandLine.KeyIterations);
cipher.GenerateIV();
cipher.Key = key.GetBytes(cipher.KeySize / 8);
Stream inputStream = CreateInputStream(commandLine);
Stream outputStream = CreateOutputStream(commandLine);
// 2 bytes of version
outputStream.Write(Constants.FormatVersionBytes, 0, Constants.FormatVersionBytes.Length);
// stores 16 bytes of IV
outputStream.Write(cipher.IV, 0, cipher.IV.Length);
// stores 2 bytes of salt size (in network order)
short saltLength = IPAddress.HostToNetworkOrder((short)key.Salt.Length);
byte[] saltLengthBytes = BitConverter.GetBytes(saltLength);
outputStream.Write(saltLengthBytes, 0, saltLengthBytes.Length);
// stores n bytes of salt
outputStream.Write(key.Salt, 0, key.Salt.Length);
using (ICryptoTransform encryptor = cipher.CreateEncryptor())
{
using (Stream cryptoStream = new CryptoStream(outputStream, encryptor, CryptoStreamMode.Write))
inputStream.CopyTo(cryptoStream);
}
}
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);
}
private static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV)
{
byte[] encrypted;
// 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 encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (System.IO.MemoryStream msEncrypt = new System.IO.MemoryStream())
{
using (System.Security.Cryptography.CryptoStream csEncrypt = new System.Security.Cryptography.CryptoStream(
msEncrypt, encryptor, System.Security.Cryptography.CryptoStreamMode.Write))
{
using (System.IO.StreamWriter swEncrypt = new System.IO.StreamWriter(csEncrypt))
{
//Write all data to the stream.
swEncrypt.Write(plainText);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream.
return(encrypted);
}
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);
}
public static string EncryptString(string key, string plainText)
{
byte[] iv = new byte[16];
byte[] array;
using (Aes aes = System.Security.Cryptography.Aes.Create())
{
aes.Key = Encoding.UTF8.GetBytes(key);
aes.IV = iv;
ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
using (MemoryStream memoryStream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream((Stream)memoryStream, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter streamWriter = new StreamWriter((Stream)cryptoStream))
{
streamWriter.Write(plainText);
}
array = memoryStream.ToArray();
}
}
}
return(Convert.ToBase64String(array));
}
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
}
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();
}
}
/// <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 void AssociateHandler(Request r, Response resp, Aes aes)
{
if (!TestRequestVerifier(r, aes, r.Key))
return;
// key is good, prompt user to save
using (var f = new ConfirmAssociationForm())
{
var win = host.MainWindow;
win.Invoke((MethodInvoker)delegate
{
ShowNotification("New key association requested", (s, e) => f.Activate());
f.Icon = win.Icon;
f.Key = r.Key;
f.Load += delegate { f.Activate(); };
f.ShowDialog(win);
if (f.KeyId != null)
{
var entry = GetConfigEntry(true);
entry.Strings.Set(ASSOCIATE_KEY_PREFIX + f.KeyId, new ProtectedString(true, r.Key));
entry.Touch(true);
resp.Id = f.KeyId;
resp.Success = true;
SetResponseVerifier(resp, aes);
UpdateUI(null);
}
});
}
}
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);
}
/// <summary>
/// AES加密（BouncyCastle模式）
/// </summary>
/// <param name="aes"></param>
/// <param name="str">待加密的字符串</param>
/// <param name="encoding">待加密的字符串编码格式</param>
/// <param name="algorithm">加密模式、填充算法</param>
/// <param name="key">密钥</param>
/// <param name="iv">向量</param>
/// <returns>base64编码格式加密字符串</returns>
public static string EncryptBC(this System.Security.Cryptography.Aes aes,
string str, Encoding encoding, string algorithm, byte[] key = null, byte[] iv = null)
{
var data = encoding.GetBytes(str);
var result = aes.EncryptBC(data, algorithm, key, iv);
return(Convert.ToBase64String(result));
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="aes"></param>
/// <param name="str">待加密的字符串</param>
/// <param name="encoding">待加密的字符串编码格式</param>
/// <param name="key">加密密钥，为空则使用实体属性Key</param>
/// <param name="mode">加密模式，为空则使用实体属性Mode</param>
/// <param name="padding">填充算法，为空则使用实体属性Padding</param>
/// <returns>base64编码格式加密字符串</returns>
public static string Encrypt(this System.Security.Cryptography.Aes aes,
string str, Encoding encoding, byte[] key = null, CipherMode?mode = null, PaddingMode?padding = null)
{
var data = encoding.GetBytes(str);
var encData = aes.Encrypt(data, key, mode, padding);
return(Convert.ToBase64String(encData));
}
public AesCrypt()
{
aes = Aes.Create();
aes.Mode = CipherMode.CBC;
aes.GenerateIV();
aes.GenerateKey();
aes.Padding = PaddingMode.PKCS7;
}
/// <summary>
/// AES加密（BouncyCastle模式）
/// </summary>
/// <param name="aes"></param>
/// <param name="str">待加密的字符串</param>
/// <param name="encoding">待加密的字符串编码格式</param>
/// <param name="mode">加密模式</param>
/// <param name="padding">填充算法</param>
/// <param name="key">密钥</param>
/// <param name="iv">向量</param>
/// <returns>base64编码格式加密字符串</returns>
public static string EncryptBC(this System.Security.Cryptography.Aes aes,
string str, Encoding encoding, CipherModeBC mode, CipherPaddingBC padding, byte[] key = null, byte[] iv = null)
{
var data = encoding.GetBytes(str);
var result = aes.EncryptBC(data, mode, padding, key, iv);
return(Convert.ToBase64String(result));
}
public AES(byte[] key)
{
rsa = new AesManaged();
rsa.GenerateKey();
rsa.GenerateIV();
_decoder = rsa.CreateDecryptor();
_encoder = rsa.CreateEncryptor();
}
private IEnumerable<PwEntry> FindMatchingEntries(Request r, Aes aes)
{
string submithost = null;
string realm = null;
var list = new PwObjectList<PwEntry>();
string formhost, searchHost;
formhost = searchHost = GetHost(CryptoTransform(r.Url, true, false, aes, CMode.DECRYPT));
if (r.SubmitUrl != null) {
submithost = GetHost(CryptoTransform(r.SubmitUrl, true, false, aes, CMode.DECRYPT));
}
if (r.Realm != null)
realm = CryptoTransform(r.Realm, true, false, aes, CMode.DECRYPT);
var origSearchHost = searchHost;
var parms = MakeSearchParameters();
var root = host.Database.RootGroup;
while (list.UCount == 0 && (origSearchHost == searchHost || searchHost.IndexOf(".") != -1))
{
parms.SearchString = String.Format("^{0}$|/{0}/?", searchHost);
root.SearchEntries(parms, list);
searchHost = searchHost.Substring(searchHost.IndexOf(".") + 1);
if (searchHost == origSearchHost)
break;
}
Func<PwEntry, bool> filter = delegate(PwEntry e)
{
var title = e.Strings.ReadSafe(PwDefs.TitleField);
var entryUrl = e.Strings.ReadSafe(PwDefs.UrlField);
var c = GetEntryConfig(e);
if (c != null)
{
if (c.Allow.Contains(formhost) && (submithost == null || c.Allow.Contains(submithost)))
return true;
if (c.Deny.Contains(formhost) || (submithost != null && c.Deny.Contains(submithost)))
return false;
if (realm != null && c.Realm != realm)
return false;
}
if (title.StartsWith("http://") || title.StartsWith("https://"))
{
var u = new Uri(title);
if (formhost.Contains(u.Host))
return true;
}
if (entryUrl != null && entryUrl.StartsWith("http://") || entryUrl.StartsWith("https://"))
{
var u = new Uri(entryUrl);
if (formhost.Contains(u.Host))
return true;
}
return formhost.Contains(title) || (entryUrl != null && formhost.Contains(entryUrl));
};
return from e in list where filter(e) select e;
}
public AesExtensionsTest()
{
aes = System.Security.Cryptography.Aes.Create();
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.PKCS7;
aes.BlockSize = 128;
aes.GenerateKey(8);
aes.GenerateIV(8);
}
public CrypterAES()
{
this.AES = System.Security.Cryptography.Aes.Create();
this.AES.Mode = CrypterAES.mode;
this.AES.Padding = CrypterAES.padding;
this.AES.KeySize = CrypterAES.keySize;
this.AES.GenerateIV();
this.AES.GenerateKey();
}
public KeePassConnection(string host, int port, string id, byte[] key)
{
this.Host = host;
this.Port = port;
this.Hash = null;
this.Id = id;
this.Key = key;
this.aes = key != null ? new AesManaged {Key = key} : new AesManaged();
}
private static AesFw CreateAes()
{
var aes = AesFw.Create();
aes.BlockSize = 128;
aes.KeySize = 256;
aes.Padding = PaddingMode.Zeros;
return(aes);
}
static MapleAESOFB()
{
AES = Aes.Create();
AES.KeySize = 256;
AES.BlockSize = 128;
AES.Mode = CipherMode.CBC;
Zeroes = new byte[((BlockLength >> 4) + 1) << 4];
}
/**********************************************************************************************************
* 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);
}
/// <summary>
/// Creates AES instance
/// </summary>
/// <param name="key">Key to be set as AES key</param>
/// <param name="iVec">IVec to be set as AES iVec</param>
public AesEncryptor(byte[] key, byte[] iVec)
{
this.key = key;
this.iVec = iVec;
aes = Aes.Create();
aes.IV = iVec;
aes.Key = key;
aes.Padding = PaddingMode.Zeros;
}
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 AESUtils()
{
AesEcb = Aes.Create();
AesEcb.Mode = CipherMode.ECB;
AesEcb.Padding = PaddingMode.None;
AesCbc = Aes.Create();
AesCbc.Mode = CipherMode.CBC;
AesCbc.Padding = PaddingMode.None;
}
/// <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));
}
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);
}
static byte[] AESEncrypt(byte[] key, byte[] iv, Span <byte> dataToEncrypt)
{
using var result = new MemoryStream();
using var aes = Aes.Create();
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.None;
using var cs = new CryptoStream(result, aes.CreateEncryptor(key, iv), CryptoStreamMode.Write);
cs.Write(dataToEncrypt);
cs.FlushFinalBlock();
return(result.ToArray());
}
private bool VerifyRequest(Request r, Aes aes)
{
var entry = GetConfigEntry(false);
if (entry == null)
return false;
var s = entry.Strings.Get(ASSOCIATE_KEY_PREFIX + r.Id);
if (s == null)
return false;
return TestRequestVerifier(r, aes, s.ReadString());
}
/// <summary>
/// ctor
/// </summary>
/// <param name="key"></param>
/// <param name="counterBufferSegment"></param>
/// <param name="aesFactory"></param>
/// <exception cref="ArgumentException">
/// <paramref name="counterBufferSegment"/> needs to have the same length as <see cref="AesConstants.STR_AES_BLOCK_SIZE"/>.
/// </exception>
public AesCtrCryptoTransform(byte[] key, ArraySegment<byte> counterBufferSegment, Func<Aes> aesFactory = null)
{
if (counterBufferSegment.Count != AesConstants.AES_BLOCK_SIZE)
throw new ArgumentException($"{nameof(counterBufferSegment)}.Count must be {AesConstants.STR_AES_BLOCK_SIZE}.", nameof(counterBufferSegment));
_aes = aesFactory?.Invoke() ?? CipherFactory.Aes();
_aes.Mode = CipherMode.ECB;
_aes.Padding = PaddingMode.None;
Buffer.BlockCopy(counterBufferSegment.Array, counterBufferSegment.Offset, _counterBuffer.Value, 0, AesConstants.AES_BLOCK_SIZE);
_cryptoTransform = _aes.CreateEncryptor(rgbKey: key, rgbIV: null);
}
public void Decrypt(String inputFile, String outputFile, Aes aes)
{
if (!IsEncrypted (inputFile)) {
return;
}
this.Logger.LogDebug (String.Format (CultureInfo.CurrentCulture, "Decrypting {0}...", inputFile));
byte[] data = File.ReadAllBytes (inputFile);
byte[] output = Decrypt (data, aes);
File.WriteAllBytes (outputFile, output);
}
/// <summary>ctor</summary>
public AesCtrCryptoTransform(byte[] key, ArraySegment<byte> counterBufferSegment, Func<Aes> aesFactory = null)
{
if (counterBufferSegment.Count != AesConstants.AES_BLOCK_SIZE)
throw new ArgumentException("counterBufferSegment.Count must be " + AesConstants.STR_AES_BLOCK_SIZE + ".");
this.aes = aesFactory == null ? AesFactories.Aes() : aesFactory();
this.aes.Mode = CipherMode.ECB;
this.aes.Padding = PaddingMode.None;
Utils.BlockCopy(counterBufferSegment.Array, counterBufferSegment.Offset, counterBuffer, 0, AesConstants.AES_BLOCK_SIZE);
this.cryptoTransform = aes.CreateEncryptor(rgbKey: key, rgbIV: null);
}// ctor
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));
}
}
}
/// <summary>
/// Creates AES instance
/// </summary>
public AesEncryptor()
{
aes = Aes.Create();
using (var rng = new RNGCryptoServiceProvider())
{
rng.GetBytes(key);
rng.GetBytes(iVec);
}
aes.IV = iVec;
aes.Key = key;
aes.Padding = PaddingMode.Zeros;
}
public override void init(int mode, byte[] key, byte[] iv)
{
for (int i = 0; i < counter.Length; i++)
counter[i] = 0;
for (int i = 0; i < counterBytes.Length; i++)
counterBytes[i] = 0;
aesm = AesManaged.Create();
aesm.BlockSize = blockSize*8;
//aesm.KeySize = blockSize*8;
aesm.Key = key;
aesm.IV = iv;
ms = new MemoryStream(blockSize);
}
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);
}
}
public static byte[] EncryptStringToBytes_AES(string plainText, byte[] Key, byte[] IV)
{
// Check arguments
if (ReferenceEquals(plainText, null) || plainText.Length <= 0)
{
throw (new ArgumentNullException("plainText"));
}
if (ReferenceEquals(Key, null) || Key.Length <= 0)
{
throw (new ArgumentNullException("Key"));
}
if (ReferenceEquals(IV, null) || IV.Length <= 0)
{
throw (new ArgumentNullException("Key"));
}
byte[] encrypted = 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 encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.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);
}
encrypted = msEncrypt.ToArray();
}
}
}
// Return the encrypted bytes from the memory stream
return(encrypted);
}
/// <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>
/// Instantiate a transformation
/// </summary>
/// <param name="key">The key</param>
/// <param name="iv">Initial Vector</param>
/// <param name="cipherMode">Mode of operation, typically CBC</param>
/// <param name="paddingMode">Padding mode, typically PCS7</param>
public AesCrypto(AesKey key, AesIV iv, CipherMode cipherMode, PaddingMode paddingMode)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (iv == null)
{
throw new ArgumentNullException("iv");
}
_aes = new AesManaged();
_aes.Key = key.GetBytes();
_aes.Mode = cipherMode;
_aes.IV = iv.GetBytes();
_aes.Padding = paddingMode;
}
public VelostiScsi()
{
this.Aes = AesManaged.Create();
this.Aes.KeySize = 256;
this.IsBusy = false;
this.Worker = new BackgroundWorker();
this.Worker.WorkerReportsProgress = true;
this.Worker.WorkerSupportsCancellation = true;
this.Worker.DoWork += new DoWorkEventHandler(TaskWorker_DoWork);
this.Worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(TaskWorker_RunWorkerCompleted);
this.timer = new Thread(timer_Elapsed);
this.timer.IsBackground = true;
this.timer.Start();
}
private bool disposedValue = false; // To detect redundant calls
void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
_cryptor.Dispose();
_cryptor = null;
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
disposedValue = true;
}
}
/// <summary>
/// Encrypt the giving <see cref="Byte"> <see cref="Array"/>.
/// </summary>
/// <param name="plainText">The <see cref="Byte"> <see cref="Array"/> that contains data to encrypt.</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 encrypted data.</returns>
public static byte[] Encrypt(byte[] plainText, byte[] Key, byte[] IV)
{
// Check arguments
if (ReferenceEquals(plainText, null) || plainText.Length <= 0)
{
throw (new ArgumentNullException("plainText"));
}
if (ReferenceEquals(Key, null) || Key.Length <= 0)
{
throw (new ArgumentNullException("Key"));
}
if (ReferenceEquals(IV, null) || IV.Length <= 0)
{
throw (new ArgumentNullException("IV"));
}
byte[] encrypted = 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 encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (MemoryStream msEncrypt = new MemoryStream())
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
csEncrypt.Write(plainText, 0, plainText.Length);
csEncrypt.Flush();
csEncrypt.Close();
}
encrypted = msEncrypt.ToArray();
}
}
// Return the encrypted bytes from the memory stream
return(encrypted);
}
/// <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;
}
}
public ScryptAesCtr(byte[] key, long nonce)
{
if (key == null) throw new ArgumentNullException("key");
aes = Aes.Create();
if (aes == null)
{
throw new InvalidOperationException("Can't find an implementation of AES");
}
aes.KeySize = 256;
aes.Key = key;
aes.IV = Enumerable.Repeat((byte)0, 16).ToArray();
aes.Mode = CipherMode.ECB;
aes.Padding = PaddingMode.None;
this.nonce = nonce;
}
public void Start(int port, CryptoAlgoId_Values cryptoAlgoId, byte[] content, EventQueue eventQueue)
{
this.cryptoAlgoId = cryptoAlgoId;
this.content = content;
this.eventQueue = eventQueue;
this.aes = PccrrUtitlity.CreateAes(cryptoAlgoId);
this.iv = new byte[16];
for (int i = 0; i < iv.Length; i++)
{
this.iv[i] = (byte)i;
}
pccrrServer = new PccrrServer(port);
pccrrServer.MessageArrived += new MessageArrivedEventArgs(pccrrServer_MessageArrived);
pccrrServer.StartListening();
}
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;
}