private string Encrypt(string plain)
{
string encryptString = null;
using (SymmetricAlgorithm algorithm = AesCryptoServiceProvider.Create())
{
byte[] key = Convert.FromBase64String(_aesKey);
byte[] iv = Convert.FromBase64String(_aesIv);
algorithm.Key = key;
algorithm.IV = iv;
ICryptoTransform encryptor = algorithm.CreateEncryptor(key, iv);
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
{
using (StreamWriter sw = new StreamWriter(cs))
{
sw.Write(plain);
}
byte[] encryptBytes = ms.ToArray();
encryptString = Convert.ToBase64String(encryptBytes);
}
}
}
return(encryptString);
}
public static string Decrypt(string str)
{
var bytes = new byte[16];
for (var i = 0; i < 16; i++)
{
var b = byte.Parse((str.Substring(i * 2, 2)),
System.Globalization.NumberStyles.HexNumber);
bytes[i] = b;
}
var aes = AesCryptoServiceProvider.Create();
aes.BlockSize = 128;
aes.KeySize = 128;
aes.Key = Key;
aes.IV = IV;
var ms = new MemoryStream(bytes);
var decryptor = aes.CreateDecryptor();
var cryptoStream = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
var sr = new StreamReader(cryptoStream);
var strOut = sr.ReadToEnd();
cryptoStream.Close();
ms.Close();
sr.Close();
return(strOut);
}
public static string GenerateKey()
{
SymmetricAlgorithm algorithm = null;
algorithm = AesCryptoServiceProvider.Create();
return(algorithm == null ? string.Empty : ASCIIEncoding.ASCII.GetString(algorithm.Key));
}
void encrypt(Stream inStream, Stream outStream)
{
using (SymmetricAlgorithm algorithm = AesCryptoServiceProvider.Create())
{
algorithm.GenerateKey();
algorithm.GenerateIV();
byte[] iv = algorithm.IV;
byte[] key = algorithm.Key;
using (ICryptoTransform encryptor = algorithm.CreateEncryptor(key, iv))
{
using (CryptoStream cs = new CryptoStream(outStream, encryptor, CryptoStreamMode.Write))
{
BinaryWriter bw = new BinaryWriter(outStream);
bw.Write(iv);
byte[] readBuffer = new byte[1];
BinaryReader br = new BinaryReader(inStream);
while (br.Read(readBuffer, 0, readBuffer.Length) != 0)
{
cs.Write(readBuffer, 0, 1);
}
}
}
}
inStream.Close();
outStream.Close();
}
private string Decrypt(string encryptString)
{
byte[] encryptBytes = Convert.FromBase64String(encryptString);
string plain = null;
using (SymmetricAlgorithm algorithm = AesCryptoServiceProvider.Create())
{
byte[] key = Convert.FromBase64String(_aesKey);
byte[] iv = Convert.FromBase64String(_aesIv);
algorithm.Key = key;
algorithm.IV = iv;
ICryptoTransform decryptor = algorithm.CreateDecryptor(key, iv);
using (MemoryStream ms = new MemoryStream(encryptBytes))
{
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
{
using (StreamReader sr = new StreamReader(cs))
{
plain = sr.ReadToEnd();
}
}
}
}
return(plain);
}
public Encryptor()
{
aes = AesCryptoServiceProvider.Create();
aes.Mode = CipherMode.ECB;
aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
createAESKey();
}
public static string EncryptAESBase64(byte[] bytesPlain, byte[] bytesKey)
{
if (bytesPlain == null)
{
return(null);
}
Aes des = AesCryptoServiceProvider.Create();
des.Mode = CipherMode.CBC;
des.GenerateIV();
byte[] bytesIV = des.IV;
StringBuilder sb = new StringBuilder();
MemoryStream ms = new MemoryStream();
CryptoStream encStream = new CryptoStream(ms, des.CreateEncryptor(bytesKey, bytesIV), CryptoStreamMode.Write);
// Encrypt the data using default encoding
int remainder = bytesPlain.Length % des.BlockSize;
byte[] bytesToEncrypt = new byte[bytesPlain.Length + remainder];
bytesPlain.CopyTo(bytesToEncrypt, 0);
encStream.Write(bytesToEncrypt, 0, bytesPlain.Length);
encStream.FlushFinalBlock();
encStream.Close();
byte[] cryptText = ms.ToArray();
sb.Append(Base64FromBytes(cryptText, cryptText.Length));
sb.Append(_Base64MARKER);
sb.Append(Base64FromBytes(bytesIV, bytesIV.Length));
return(sb.ToString());
}
// Generate a secret key
public static string GenerateKey()
{
SymmetricAlgorithm symmAlgorithm = null;
symmAlgorithm = AesCryptoServiceProvider.Create();
return(ASCIIEncoding.ASCII.GetString(symmAlgorithm.Key));
}
public static byte[] Encrypt(byte[] input, byte[] key, byte[] salt, string algorithm)
{
if (input == null || input.Length < 1 ||
key == null || key.Length < 1 ||
salt == null || salt.Length < 1)
{
throw new ArgumentException();
}
System.Security.Cryptography.SymmetricAlgorithm sAlgorithm;
switch (algorithm.ToUpperInvariant())
{
case "DES":
sAlgorithm = DESCryptoServiceProvider.Create();
break;
case "3DES":
case "TDES":
case "TRIPLEDES":
sAlgorithm = TripleDESCryptoServiceProvider.Create();
break;
case "AES":
sAlgorithm = AesCryptoServiceProvider.Create();
break;
case "RC2":
sAlgorithm = RC2CryptoServiceProvider.Create();
break;
case "RIJNDAEL":
sAlgorithm = new RijndaelManaged();
break;
default:
throw new NotSupportedException();
}
DeriveBytes rdb = new Rfc2898DeriveBytes(key, salt, 1024);
sAlgorithm.Key = rdb.GetBytes(sAlgorithm.KeySize / 8);
sAlgorithm.IV = rdb.GetBytes(sAlgorithm.BlockSize / 8);
byte[] reslut;
using (ICryptoTransform encryptor = sAlgorithm.CreateEncryptor(sAlgorithm.Key, sAlgorithm.IV))
{
using (MemoryStream stream = new MemoryStream())
{
using (CryptoStream cryptoStream = new CryptoStream(stream, encryptor, CryptoStreamMode.Write))
{
cryptoStream.Write(input, 0, input.Length);
cryptoStream.FlushFinalBlock();
cryptoStream.Clear();
}
reslut = stream.ToArray();
}
}
sAlgorithm.Clear();
return(reslut);
}
/// <summary>
/// Decrypts the given string of cipher text with the given key string. The IV for the
/// cipher text is assumed to be appended to the cipher text after a MARKER character, e.g.
/// 123544151-43234324. This method uses DES as the crypto provider and assumes also
/// that the cipher text is hexadecimal encodes.
/// </summary>
/// <param name="strData">The cipher text + the IV</param>
/// <param name="strKey">The cipher key</param>
/// <returns>The original plain text as an array of bytes</returns>
public static byte[] DecryptAESToBytes(string strData, string strKey)
{
if (strData == null)
{
return(null);
}
Aes des = AesCryptoServiceProvider.Create();
des.Mode = CipherMode.CBC;
byte[] bytesKey = MakeCipherKey(strKey, des);
return(DecryptAESToBytes(strData, bytesKey));
}
/// Encrypts the given byte array using the given key. The resulting
/// cipher text is then converted to base-64 encoding.
/// </summary>
/// <param name="bytesPlain"></param>
/// <param name="strKey"></param>
/// <returns></returns>
public static string EncryptAES(byte[] bytesPlain, string strKey)
{
if (bytesPlain == null)
{
return(null);
}
Aes des = AesCryptoServiceProvider.Create();
des.Mode = CipherMode.CBC;
byte[] bytesKey = MakeCipherKey(strKey, des);
return(EncryptAES(bytesPlain, bytesKey));
}
public static string GenerateKey()
{
SymmetricAlgorithm algorithm = AesCryptoServiceProvider.Create();
if (algorithm == null)
{
return(String.Empty);
}
else
{
return(ASCIIEncoding.ASCII.GetString(algorithm.Key));
}
}
/// <summary>
/// Method for decrypting data
/// </summary>
/// <param name="encrypter">What encryption is used</param>
/// <param name="message">The message to decrypt</param>
/// <param name="key">The encryption key</param>
/// <param name="iv">the encryption iv</param>
/// <returns>Returns a decrypted byte[]</returns>
public static void DecryptFolder(Encrypters encrypter, byte[] key, byte[] iv)
{
watch = new Stopwatch();
watch.Start();
SymmetricAlgorithm algorithm = null;
switch (encrypter)
{
case Encrypters.DES:
algorithm = DESCryptoServiceProvider.Create();
break;
case Encrypters.TRIPLEDES:
algorithm = TripleDESCryptoServiceProvider.Create();
break;
case Encrypters.AES:
algorithm = AesCryptoServiceProvider.Create();
break;
}
algorithm.Mode = CipherMode.CBC;
algorithm.Padding = PaddingMode.PKCS7;
try
{
algorithm.Key = key;
algorithm.IV = iv;
}
catch (FormatException e)
{
Console.WriteLine("Make sure to use the correct encryption method");
throw e;
}
using (var memoryStream = new MemoryStream())
{
var cryptoStream = new CryptoStream(memoryStream, algorithm.CreateDecryptor(),
CryptoStreamMode.Write);
foreach (string file in Directory.GetFiles(Environment.CurrentDirectory, "*.txt"))
{
byte[] fileText = File.ReadAllBytes(file);
cryptoStream.Write(fileText, 0, fileText.Length);
cryptoStream.FlushFinalBlock();
File.WriteAllBytes(file, memoryStream.ToArray());
}
watch.Stop();
Console.WriteLine("Stopwatch took " + watch.ElapsedMilliseconds + "ms to decrypt");
}
}
/// <summary>
/// Set up an Aes instance with the correct mode, key and IV
/// </summary>
/// <param name="Key">Encryption key</param>
/// <param name="IV">Initialization Vector, if left blank one will be generated.</param>
/// <returns></returns>
private static Aes GetAes(byte[] Key, string IV)
{
var aesAlg = AesCryptoServiceProvider.Create();
aesAlg.KeySize = KeySizeShort * 8; // key size in bits
aesAlg.Mode = CipherMode.CBC;
aesAlg.Padding = PaddingMode.None;
aesAlg.Key = Key;
if (IV != "")
{
aesAlg.IV = HexToByte(IV);
}
return(aesAlg);
}
/// <summary>
/// Set up an Aes instance with the correct mode, key and IV
/// </summary>
/// <param name="Key">Encryption key</param>
/// <param name="IV">Initialization Vector, if left blank one will be generated.</param>
/// <returns></returns>
private static Aes GetAes(string Key, string IV)
{
var aesAlg = AesCryptoServiceProvider.Create();
aesAlg.KeySize = KeySize * 8; // key size in bits
aesAlg.Mode = CipherMode.CBC;
aesAlg.Padding = PaddingMode.None;
aesAlg.Key = Encoding.UTF8.GetBytes(AddPadding(Key));
if (IV != "")
{
aesAlg.IV = HexToByte(IV);
}
return(aesAlg);
}
/// <summary>
/// Method for encrypting txt files in current directory
/// </summary>
/// <param name="encrypter">Method for encryption</param>
/// <param name="key">The key used to encrypt with</param>
/// <param name="iv">The iv used to encrypt with</param>
public static void EncryptFolder(Encrypters encrypter, byte[] key, byte[] iv)
{
watch = new Stopwatch();
watch.Start();
SymmetricAlgorithm algorithm = null;
switch (encrypter)
{
case Encrypters.DES:
algorithm = DESCryptoServiceProvider.Create();
break;
case Encrypters.TRIPLEDES:
algorithm = TripleDESCryptoServiceProvider.Create();
break;
case Encrypters.AES:
algorithm = AesCryptoServiceProvider.Create();
break;
}
algorithm.Mode = CipherMode.CBC;
algorithm.Padding = PaddingMode.PKCS7;
algorithm.Key = key;
algorithm.IV = iv;
using (var memoryStream = new MemoryStream())
{
var cryptoStream = new CryptoStream(memoryStream, algorithm.CreateEncryptor(),
CryptoStreamMode.Write);
foreach (string file in Directory.GetFiles(Environment.CurrentDirectory, "*.txt"))
{
byte[] fileText = File.ReadAllBytes(file);
cryptoStream.Write(fileText, 0, fileText.Length);
cryptoStream.FlushFinalBlock();
File.WriteAllBytes(file, memoryStream.ToArray());
}
watch.Stop();
Console.WriteLine("Stopwatch took: " + watch.ElapsedMilliseconds + "ms to complete \n" +
"Remember to save the key and IV somewhere");
Console.WriteLine("Key:" + Convert.ToBase64String(algorithm.Key) + "\n" +
"IV: " + Convert.ToBase64String(algorithm.IV));
}
}
public static byte[] EncryptChunkdata(byte[] data, byte[] key)
{
var aes = AesCryptoServiceProvider.Create();
aes.Mode = CipherMode.CBC;
aes.KeySize = 128;
aes.Padding = PaddingMode.PKCS7;
MemoryStream result = new MemoryStream();
using (CryptoStream cs = new CryptoStream(result, aes.CreateEncryptor(key, key), CryptoStreamMode.Write))
{
new MemoryStream(data).CopyTo(cs);
cs.FlushFinalBlock();
return(result.ToArray());
}
}
public static byte[] DecryptChunkdata(byte[] data, byte[] key, int size)
{
var aes = AesCryptoServiceProvider.Create();
aes.Mode = CipherMode.CBC;
aes.KeySize = 128;
aes.Padding = PaddingMode.PKCS7;
MemoryStream input = new MemoryStream(data);
input.Seek(0, 0);
using (CryptoStream cs = new CryptoStream(input, aes.CreateDecryptor(key, key), CryptoStreamMode.Read))
{
MemoryStream m = new MemoryStream();
cs.CopyTo(m, size);
return(m.ToArray());
}
}
/// <summary>
/// 根据KEY生成DES
/// </summary>
/// <param name="key">密钥.</param>
/// <returns>Aes</returns>
public static Aes CreateAES(string key)
{
Aes _aes = new AesCryptoServiceProvider();
AesCryptoServiceProvider _desCrypto = (AesCryptoServiceProvider)AesCryptoServiceProvider.Create();
if (!string.IsNullOrEmpty(key))
{
MD5 _md5 = new MD5CryptoServiceProvider();
_aes.Key = _md5.ComputeHash(Encoding.UTF8.GetBytes(key));
}
else
{
_aes.Key = _desCrypto.Key;
}
_aes.IV = _aes.IV;
return(_aes);
}
/// <summary>
/// 対称アルゴリズムによる
/// 暗号化サービスプロバイダを生成
/// </summary>
/// <param name="esa">
/// 対称アルゴリズムによる
/// 暗号化サービスプロバイダの種類
/// </param>
/// <returns>
/// 対称アルゴリズムによる
/// 暗号化サービスプロバイダ
/// </returns>
private static SymmetricAlgorithm CreateSymmetricAlgorithm(EnumSymmetricAlgorithm esa)
{
SymmetricAlgorithm sa = null;
// AesCryptoServiceProvider, AesManagedは3.5からの提供。
if (esa == EnumSymmetricAlgorithm.AesCryptoServiceProvider)
{
// AesCryptoServiceProviderサービスプロバイダ
sa = AesCryptoServiceProvider.Create(); // devps(1703)
}
else if (esa == EnumSymmetricAlgorithm.AesManaged)
{
// AesManagedサービスプロバイダ
sa = AesManaged.Create(); // devps(1703)
}
else if (esa == EnumSymmetricAlgorithm.DESCryptoServiceProvider)
{
// DESCryptoServiceProviderサービスプロバイダ
sa = DESCryptoServiceProvider.Create(); // devps(1703)
}
else if (esa == EnumSymmetricAlgorithm.RC2CryptoServiceProvider)
{
// RC2CryptoServiceProviderサービスプロバイダ
sa = RC2CryptoServiceProvider.Create(); // devps(1703)
}
else if (esa == EnumSymmetricAlgorithm.RijndaelManaged)
{
// RijndaelManagedサービスプロバイダ
sa = RijndaelManaged.Create(); // devps(1703)
}
else if (esa == EnumSymmetricAlgorithm.TripleDESCryptoServiceProvider)
{
// TripleDESCryptoServiceProviderサービスプロバイダ
sa = TripleDESCryptoServiceProvider.Create(); // devps(1703)
}
else
{
throw new ArgumentException(
PublicExceptionMessage.ARGUMENT_INJUSTICE, "EnumSymmetricAlgorithm esa");
}
return(sa);
}
/// <summary>
/// Decrypts the given string of cipher text with the given key string. The IV for the
/// cipher text is assumed to be appended to the cipher text after a MARKER character, e.g.
/// 123544151-43234324. This method uses DES as the crypto provider and assumes also
/// that the cipher text is hexadecimal encodes.
/// </summary>
/// <param name="strData">The cipher text + the IV</param>
/// <param name="strKey">The cipher key</param>
/// <returns>The original plain text as an array of bytes</returns>
public static byte[] DecryptAESBase64ToBytes(string strData, string strKey)
{
if (strData == null)
{
return(null);
}
int ldx = strData.LastIndexOf(_Base64MARKER);
if (ldx < 1)
{
ldx = strData.LastIndexOf('-');
}
if (ldx < 1)
{
throw (new SecurityException("Missing IV from cipher text"));
}
string strIV = strData.Substring(ldx + 1);
strData = strData.Substring(0, ldx);
Aes des = AesCryptoServiceProvider.Create();
des.Mode = CipherMode.CBC;
byte[] bytesKey = MakeCipherKey(strKey, des);
byte[] bytesIV = Base64ToBytes(strIV);
CryptoStream decStream = new CryptoStream(new MemoryStream(Base64ToBytes(strData)),
des.CreateDecryptor(bytesKey, bytesIV),
CryptoStreamMode.Read);
MemoryStream ms = new MemoryStream();
byte[] buf = new byte[4096];
while (true)
{
int amt = decStream.Read(buf, 0, buf.Length);
if (amt < 1)
{
break;
}
ms.Write(buf, 0, amt);
}
return(ms.ToArray());
}
public void Complete(string token)
{
//generate aes key and iv
AesCryptoServiceProvider aes = (AesCryptoServiceProvider)AesCryptoServiceProvider.Create();
aes.GenerateIV();
aes.GenerateKey();
aes.Padding = PaddingMode.PKCS7;
//encrypt the token and encode as hex
byte[] unencryptedTokenBytes = System.Text.Encoding.UTF8.GetBytes(token);
using (ICryptoTransform encrypt = aes.CreateEncryptor())
{
byte[] encryptedTokenBytes = encrypt.TransformFinalBlock(unencryptedTokenBytes, 0, unencryptedTokenBytes.Length);
EncryptedToken = encryptedTokenBytes.ToHexString();
}
//hex decode the public rsa key xml
string publicRSAKeyXML = PublicRSAKey.StringFromHexString();
//create an initialise an instance of the rsa provider
RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)RSACryptoServiceProvider.Create();
rsa.FromXmlString(publicRSAKeyXML);
//encrypt and hex encode the key
byte[] encryptedAESKeyBytes = rsa.Encrypt(aes.Key, RSAEncryptionPadding.Pkcs1);
string encryptedAESKey = encryptedAESKeyBytes.ToHexString();
//hex encode the IV
string iv = aes.IV.ToHexString();
//concatenate the iv and encrypted key
EncryptedAESKey = String.Format("{0}.{1}", iv, encryptedAESKey);
State = "complete";
}
public static byte[] EncryptData(X509Certificate2 certificate, String message)
{
AesCryptoServiceProvider cryptoProvider = new AesCryptoServiceProvider();
cryptoProvider.Padding = PaddingMode.Zeros;
cryptoProvider.Key = AesCryptoServiceProvider.Create().Key;
cryptoProvider.Mode = CipherMode.CBC;
cryptoProvider.GenerateIV();
MemoryStream ms = new MemoryStream();
ICryptoTransform aesEncrypt = cryptoProvider.CreateEncryptor();
CryptoStream cryptoStream;
byte[] keyPlusIV = new byte[cryptoProvider.Key.Length + cryptoProvider.IV.Length];
keyPlusIV = cryptoProvider.Key.Concat(cryptoProvider.IV).ToArray();
RSACryptoServiceProvider rsaCSP = certificate.PublicKey.Key as RSACryptoServiceProvider;
byte[] keyPlusIVEncrypted = new byte[256];
keyPlusIVEncrypted = rsaCSP.Encrypt(keyPlusIV, true);
byte[] messageEncrypted;
using (cryptoStream = new CryptoStream(ms, aesEncrypt, CryptoStreamMode.Write))
{
cryptoStream.Write(Encoding.ASCII.GetBytes(message), 0, message.Length);
cryptoStream.FlushFinalBlock();
messageEncrypted = ms.ToArray();
}
byte[] fullEncryptedMessage = keyPlusIVEncrypted.Concat(messageEncrypted).ToArray();
String toReturn = Encoding.ASCII.GetString(fullEncryptedMessage);
return(fullEncryptedMessage);
}
public static string Encrypt(string str)
{
var input = Encoding.UTF8.GetBytes(str);
var aes = AesCryptoServiceProvider.Create();
aes.BlockSize = 128;
aes.KeySize = 128;
aes.Key = Key;
aes.IV = IV;
var encryptor = aes.CreateEncryptor();
var ms = new MemoryStream();
var cryptoStream = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
cryptoStream.Write(input, 0, input.Length);
cryptoStream.FlushFinalBlock();
var bytesOut = ms.ToArray();
ms.Close();
cryptoStream.Close();
return(String.Concat(from b in bytesOut select b.ToString("X2")));
}
public static String EncryptPassword(String Password)
{
if ((Password == null) || (Password.Length == 0))
{
return(null);
}
// neeed to replace with this on next issue:
Aes AESAlg = AesCryptoServiceProvider.Create();
AESAlg.IV = BaseIV;
AESAlg.Key = BaseKey;
// Declare streams used to encrypt to an in memory array of bytes.
MemoryStream msEncrypt = null;
CryptoStream csEncrypt = null;
StreamWriter swEncrypt = null;
try
{
// Create a encrytor to perform the stream transform.
ICryptoTransform encryptor =
AESAlg.CreateEncryptor(AESAlg.Key, AESAlg.IV);
// Create the streams used for encryption.
msEncrypt = new MemoryStream();
csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);
swEncrypt = new StreamWriter(csEncrypt);
// Write all data to the stream.
swEncrypt.Write(Password);
}
catch
{
return("");
}
finally
{
// Close the streams.
if (swEncrypt != null)
{
swEncrypt.Close();
}
if (csEncrypt != null)
{
csEncrypt.Close();
}
if (msEncrypt != null)
{
msEncrypt.Close();
}
// Clear the AES Managed object.
if (AESAlg != null)
{
AESAlg.Clear();
}
}
// Return the encrypted bytes from the memory stream.
StringBuilder st = new StringBuilder();
foreach (Byte bt in msEncrypt.ToArray())
{
st.AppendFormat("{0:x2}", bt);
}
//return msEncrypt.ToArray();
return(st.ToString());
}
public static String Decrypt(String EncryptedValue)
{
String DecryptedValue;
if (EncryptedValue == null)
{
return("");
}
if (EncryptedValue.Length <= 1) // need at least two characters
{
return("");
}
// convert the stream of numbers to byte array
int NumberChars = EncryptedValue.Length;
byte[] ToDecrypt = new byte[NumberChars / 2];
for (int i = 0; i < NumberChars; i += 2)
{
ToDecrypt[i / 2] = Convert.ToByte(EncryptedValue.Substring(i, 2), 16);
}
// Create a new Rijndael object
Aes AESAlg = AesCryptoServiceProvider.Create();
AESAlg.IV = BaseIV;
AESAlg.Key = BaseKey;
// Declare streams used to encrypt to an in memory array of bytes.
MemoryStream msDecrypt = null;
CryptoStream csDecrypt = null;
StreamReader srDecrypt = null;
try
{
// Use a decrytor to perform the stream transform.
ICryptoTransform decryptor =
AESAlg.CreateDecryptor(AESAlg.Key, AESAlg.IV);
// Create the streams used for decryption.
msDecrypt = new MemoryStream(ToDecrypt);
csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);
srDecrypt = new StreamReader(csDecrypt);
// Read the decrypted bytes from the decrypting stream as string.
DecryptedValue = srDecrypt.ReadToEnd();
}
catch (Exception ex)
{
String mess = ex.Message;
return("");
}
finally
{
// Close the streams.
if (srDecrypt != null)
{
srDecrypt.Close();
}
if (csDecrypt != null)
{
csDecrypt.Close();
}
if (msDecrypt != null)
{
msDecrypt.Close();
}
// Clear the RijndaelAlg object.
if (AESAlg != null)
{
AESAlg.Clear();
}
}
// and done
return(DecryptedValue);
}
private void Encode_Click(object sender, RoutedEventArgs e)
{
Passphrase pass = new Passphrase();
pass.Owner = this;
pass.ShowDialog();
SymmetricAlgorithm sa;
byte[] iv = new byte[8];
CipherMode mode;
PaddingMode padding = PaddingMode.Zeros;
int n = 0;
if (rbEnAES.IsChecked == true)
{
sa = AesCryptoServiceProvider.Create();
n = 32;
}
else
{
sa = TripleDESCryptoServiceProvider.Create();
n = 24;
}
if (n == 32)
{
iv = new byte[16];
}
byte[] key = new byte[n];
if (rbEnCBC.IsChecked == true)
{
mode = CipherMode.CBC;
}
else
{
if (rbEnCFB.IsChecked == true)
{
mode = CipherMode.CFB;
}
else
{
mode = CipherMode.CTS;
}
}
byte[] entrophy = new byte[32];
/* RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
* rng.GetBytes(entrophy);*/
SHA256 sha256 = new SHA256Cng();
entrophy = sha256.ComputeHash(Encoding.UTF8.GetBytes(pass.pbPass.Password));//114 174 3
byte[] salt = Encoding.UTF8.GetBytes("saltsaltsalt");
// File.WriteAllBytes(@"D:\OSU\ЗПиД\ЗПиД6\Энтропия.txt", entrophy);
if (rbGeneration.IsChecked == true)
{
Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(pass.pbPass.Password, salt, 10000);
key = pbkdf2.GetBytes(n);
}
else
{
Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(pbKeyPhrase.Password, salt, 10000);
key = pbkdf2.GetBytes(n);
}
byte[] encrypted = Encrypt(dataText, sa, key, iv, mode, padding);
using (
FileStream fs = new FileStream(@"D:\OSU\ЗПиД\ЗПиД6\Шифр.txt",
FileMode.Create))
{
fs.Write(encrypted, 0, encrypted.Length);
}
byte[] keyTemp = Encoding.UTF8.GetBytes(pass.pbPass.Password);
// SHA256 sha256 = new SHA256Managed();
keyTemp = sha256.ComputeHash(keyTemp);
byte[] keyForkey = new byte[n];
Array.Copy(keyTemp, keyForkey, n);
// byte[] en = Encrypt(key, sa, keyForkey, iv, mode, padding);
byte[] en = ProtectedData.Protect(key, entrophy, DataProtectionScope.CurrentUser);
using (
FileStream fs_key = new FileStream(@"D:\OSU\ЗПиД\ЗПиД6\Пароль.txt",
FileMode.Create))
{
fs_key.Write(en, 0, en.Length);
}
MessageBox.Show("Выполнено!");
tbEnOpenDialog.Text = "";
rbGeneration.IsChecked = true;
pbKeyPhrase.Password = "";
rbGeneration_Checked(sender, e);
}
// Create is static on Aes base class
//
public static bool TestCreate()
{
if (!(Aes.Create() is AesCryptoServiceProvider))
{
Console.WriteLine("Error - Aes.Create() is wrong type ({0})", Aes.Create().ToString());
return(false);
}
if (!(AesCryptoServiceProvider.Create() is AesCryptoServiceProvider))
{
Console.WriteLine("Error - AesCSP.Create() is wrong type ({0})", AesCryptoServiceProvider.Create().ToString());
return(false);
}
if (!(AesManaged.Create() is AesCryptoServiceProvider))
{
Console.WriteLine("Error - AesManaged.Create() is wrong type ({0})", AesManaged.Create().ToString());
return(false);
}
if (!(Aes.Create("AES") is AesCryptoServiceProvider))
{
Console.WriteLine("Error - Aes.Create(AES) is wrong type ({0})", Aes.Create("AES").ToString());
return(false);
}
if (!(Aes.Create("AesCryptoServiceProvider") is AesCryptoServiceProvider))
{
Console.WriteLine("Error - Aes.Create(AesCryptoServiceProvider) is wrong type ({0})", Aes.Create("AesCryptoServiceProvider").ToString());
return(false);
}
if (!(Aes.Create("System.Security.Cryptography.AesCryptoServiceProvider") is AesCryptoServiceProvider))
{
Console.WriteLine("Error - Aes.Create(System.Security.Cryptography.AesCryptoServiceProvider) is wrong type ({0})", Aes.Create("System.Security.Cryptography.AesCryptoServiceProvider").ToString());
return(false);
}
if (!(Aes.Create("AesManaged") is AesManaged))
{
Console.WriteLine("Error - Aes.Create(AesManaged) is wrong type ({0})", Aes.Create("AesManaged").ToString());
return(false);
}
if (!(Aes.Create("System.Security.Cryptography.AesManaged") is AesManaged))
{
Console.WriteLine("Error - Aes.Create(System.Security.Cryptography.AesManaged) is wrong type ({0})", Aes.Create("System.Security.Cryptography.AesManaged").ToString());
return(false);
}
if (!(Aes.Create("sYSTEM.sECURITY.cRYPTOGRAPHY.aESmANAGED") is AesManaged))
{
Console.WriteLine("Error - Aes.Create(sYSTEM.sECURITY.cRYPTOGRAPHY.aESmANAGED) is wrong type ({0})", Aes.Create("System.Security.Cryptography.AesManaged").ToString());
return(false);
}
if (Aes.Create("Rijndael") != null)
{
Console.WriteLine("Error - Aes.Create(Rijndael) not null");
return(false);
}
try
{
Aes.Create(null);
Console.WriteLine("Error - Aes.Create(null) did not throw ArgumentNullException");
return(false);
}
catch (ArgumentNullException)
{
}
if (Aes.Create("Blah") != null)
{
Console.WriteLine("Error - Aes.Create(Blah) not null");
return(false);
}
return(true);
}
private void btDecode_Click(object sender, RoutedEventArgs e)
{
Passphrase pass = new Passphrase();
pass.Owner = this;
pass.ShowDialog();
byte[] decrypted;
using (FileStream fileStream = File.OpenRead(file))
{
decrypted = new byte[fileStream.Length];
fileStream.Read(decrypted, 0, decrypted.Length);
}
SymmetricAlgorithm sa;
CipherMode mode;
PaddingMode padding = PaddingMode.None;
byte[] keyT = Encoding.UTF8.GetBytes(pass.pbPass.Password);
SHA256 sha256 = new SHA256Cng();
keyT = sha256.ComputeHash(keyT);
int n = 0;
if (rbDeAES.IsChecked == true)
{
sa = AesCryptoServiceProvider.Create();
n = 32;
}
else
{
sa = TripleDESCryptoServiceProvider.Create();
n = 24;
}
byte[] key = new byte[n];
Array.Copy(keyT, key, n);
byte[] iv = new byte[8];
if (n == 24)
{
iv = new byte[8];
}
else
{
iv = new byte[16];
}
if (rbEnCBC.IsChecked == true)
{
mode = CipherMode.CBC;
}
else
{
if (rbEnCFB.IsEnabled)
{
mode = CipherMode.CFB;
}
else
{
mode = CipherMode.CTS;
}
}
byte[] entrophy = sha256.ComputeHash(Encoding.UTF8.GetBytes(pass.pbPass.Password)); //File.ReadAllBytes(@"D:\OSU\ЗПиД\ЗПиД6\Энтропия.txt");//113 183
// SHA256 sha256 = new SHA256Cng();
// entrophy = sha256.ComputeHash(entrophy);
using (FileStream fstream = File.OpenRead(@"D:\OSU\ЗПиД\ЗПиД6\Пароль.txt"))
{
byte[] keyTemp = new byte[fstream.Length];
fstream.Read(keyTemp, 0, keyTemp.Length);
key = ProtectedData.Unprotect(keyTemp, entrophy, DataProtectionScope.CurrentUser);
// keyT = Decrypt(temp, sa, key, iv, mode, padding);
}
//Array.Copy(keyT, key, n);
byte[] decr = Decrypt(decrypted, sa, key, iv, mode, padding);
string result = Encoding.UTF8.GetString(decr);
File.WriteAllText(@"C:\Users\Nastya\Desktop\Университет\ЗПиД\ЗПиД6\Результат.txt", result, Encoding.UTF8);
MessageBox.Show("Выполнено!");
tbDeOpenDialog.Text = "";
}
/// <summary>対称アルゴリズム暗号化サービスプロバイダ生成</summary>
/// <param name="esa">EnumSymmetricAlgorithm</param>
/// <param name="cm">CipherMode</param>
/// <param name="pm">PaddingMode</param>
/// <returns>SymmetricAlgorithm</returns>
private SymmetricAlgorithm CreateSymmetricAlgorithm(EnumSymmetricAlgorithm esa, CipherMode cm, PaddingMode pm)
{
#region Constructor
SymmetricAlgorithm sa = null;
#region Aes
if (esa.HasFlag(EnumSymmetricAlgorithm.AES_CSP))
{
// AesCryptoServiceProviderサービスプロバイダ
sa = AesCryptoServiceProvider.Create(); // devps(1703)
}
else if (esa.HasFlag(EnumSymmetricAlgorithm.AES_M))
{
// AesManagedサービスプロバイダ
sa = AesManaged.Create(); // devps(1703)
}
#if NET45 || NET46
#else
else if (esa.HasFlag(EnumSymmetricAlgorithm.AES_CNG))
{
// AesCngサービスプロバイダ
sa = AesCng.Create(); // devps(1703)
}
#endif
#endregion
#region TripleDES
else if (esa.HasFlag(EnumSymmetricAlgorithm.TDES_CSP))
{
// TripleDESCryptoServiceProviderサービスプロバイダ
sa = TripleDESCryptoServiceProvider.Create(); // devps(1703)
}
#if NET45 || NET46
#else
else if (esa.HasFlag(EnumSymmetricAlgorithm.TDES_CNG))
{
// TripleDESCngサービスプロバイダ
sa = TripleDESCng.Create(); // devps(1703)
}
#endif
#endregion
#region Others
else if (esa.HasFlag(EnumSymmetricAlgorithm.DES_CSP))
{
// DESCryptoServiceProviderサービスプロバイダ
sa = DESCryptoServiceProvider.Create(); // devps(1703)
}
else if (esa.HasFlag(EnumSymmetricAlgorithm.RC2_CSP))
{
// RC2CryptoServiceProviderサービスプロバイダ
sa = RC2CryptoServiceProvider.Create(); // devps(1703)
}
else if (esa.HasFlag(EnumSymmetricAlgorithm.Rijndael_M))
{
// RijndaelManagedサービスプロバイダ
sa = RijndaelManaged.Create(); // devps(1703)
}
#endregion
else
{
throw new ArgumentException(
PublicExceptionMessage.ARGUMENT_INCORRECT, "EnumSymmetricAlgorithm esa");
}
#endregion
#region Options
// cmが設定されている場合。
if (cm != 0)
{
sa.Mode = cm;
}
// pmが設定されている場合。
if (pm != 0)
{
sa.Padding = pm;
}
#endregion
return(sa);
}
