protected override void Dispose(bool disposing)
{
if (!m_disposed)
{
// note: we ALWAYS zeroize keys (disposing or not)
// clear our copy of the secret key
if (KeyValue != null)
{
Array.Clear(KeyValue, 0, KeyValue.Length);
}
// clear the secret key (inside TripleDES)
if (tdes != null)
{
tdes.Clear();
}
if (disposing)
{
// disposed managed stuff
KeyValue = null;
tdes = null;
}
// ancestor
base.Dispose(disposing);
m_disposed = true;
}
}
private byte[] desDecrypt(byte[] image, String pin)
{
//get hashed pincode to byte array
byte[] keyBytes = Encoding.UTF8.GetBytes(pin);
//make sure the keybytes are 24 bytes and copy the first 24 bytes
byte[] newBytes = new byte[24];
Array.Copy(keyBytes, 0, newBytes, 0, 24);
//create new IV byte array
byte[] IV = new byte[8];
//Create C# TRiple DES algorithm
TripleDES tdes = TripleDES.Create();
//create the Triple DES parameters and the modes of Triple DES
tdes.Key = newBytes;
tdes.Mode = CipherMode.CBC;
tdes.Padding = PaddingMode.PKCS7;
tdes.IV = IV;
//create Decryptor
var Encryptor = tdes.CreateDecryptor();
//encrypt the image bytes
byte[] outpur = Encryptor.TransformFinalBlock(image, 0, image.Length);
tdes.Clear();
return(outpur);
}
public string EncryptData(string inputtedData, string password)
{
string encryptedData;
//Turn password to byte[]
byte[] buffer = Encoding.UTF8.GetBytes(password);
//Copy to key
Array.Copy(buffer, 0, _key, 0, buffer.Length);
//Turn Data to byte[]
byte[] data = Encoding.UTF8.GetBytes(inputtedData);
using (MemoryStream memoryStream = new MemoryStream())
{
TripleDES tripleDes = TripleDES.Create();
tripleDes.Key = _key;
tripleDes.Mode = CipherMode.ECB;
using (
CryptoStream crytoStream = new CryptoStream(memoryStream, tripleDes.CreateEncryptor(),
CryptoStreamMode.Write))
{
crytoStream.Write(data, 0, data.Length);
crytoStream.FlushFinalBlock();
byte[] cipherBytes = memoryStream.ToArray();
byte[] newBuffer = new byte[cipherBytes.Length + 4];
Array.Copy(cipherBytes, 0, newBuffer, 0, cipherBytes.Length);
Array.Copy(Crc32.Compute(cipherBytes), 0, newBuffer, cipherBytes.Length, 4);
encryptedData = Convert.ToBase64String(newBuffer);
}
tripleDes.Clear();
}
return(encryptedData);
}
public override byte[] Transform(byte[] data, TransformType type)
{
MemoryStream memoryStream = (MemoryStream)null;
ICryptoTransform transform = (ICryptoTransform)null;
TripleDES tripleDes = TripleDES.Create();
try
{
memoryStream = new MemoryStream();
tripleDes.Key = this.Key;
tripleDes.IV = this.IV;
transform = type != TransformType.ENCRYPT ? tripleDes.CreateDecryptor() : tripleDes.CreateEncryptor();
if (data == null || data.Length == 0)
{
return((byte[])null);
}
CryptoStream cryptoStream = new CryptoStream((Stream)memoryStream, transform, CryptoStreamMode.Write);
cryptoStream.Write(data, 0, data.Length);
cryptoStream.FlushFinalBlock();
return(memoryStream.ToArray());
}
catch (CryptographicException ex)
{
throw new CryptographicException(ex.Message);
}
finally
{
tripleDes?.Clear();
transform?.Dispose();
memoryStream.Close();
}
}
public void Clear()
{
if (algValue != null)
{
algValue.Clear();
}
else
{
throw new Exception("No TripleDES key was found to clear.");
}
}
public static string Encryption(string textPass, string desKey)
{
TripleDES des = CreateDES(desKey);
ICryptoTransform ct = des.CreateEncryptor();
byte[] input = Encoding.Unicode.GetBytes(textPass);
var bytePass = ct.TransformFinalBlock(input, 0, input.Length);
des.Clear();
return(Convert.ToBase64String(bytePass, 0, bytePass.Length));
}
//public XmlDocument Doc { set { docValue = value; } get { return docValue; } }
//public TripleDES Alg { set { tripleDES = value; } get { return tripleDES; } }
public void Clear()
{
if (tripleDES != null)
{
tripleDES.Clear();
}
else
{
throw new Exception("No TripleDES key was found to clear.");
}
}
/// <summary>
/// public override byte[] Transform(byte[] data, TransformType type)
/// </summary>
/// <param name="data"></param>
/// <param name="type"></param>
/// <returns></returns>
public override byte[] Transform(byte[] data, TransformType type)
{
MemoryStream ms = null;
CryptoStream cs = null;
ICryptoTransform transform = null;
TripleDES triple = TripleDES.Create();
try
{
ms = new MemoryStream();
triple.Key = Key;
triple.IV = IV;
if (type == TransformType.ENCRYPT)
{
transform = triple.CreateEncryptor();
}
else
{
transform = triple.CreateDecryptor();
}
if (data != null && data.Length > 0)
{
cs = new CryptoStream(ms, transform, CryptoStreamMode.Write);
cs.Write(data, 0, data.Length);
cs.FlushFinalBlock();
return(ms.ToArray());
}
else
{
return(null);
}
}
catch (CryptographicException e)
{
throw new CryptographicException(e.Message);
}
finally
{
if (triple != null)
{
triple.Clear();
}
if (transform != null)
{
transform.Dispose();
}
ms.Close();
}
}
/// <summary>
/// 对称加密-->TripleDES解密
/// </summary>
/// <param name="data">加密后的字符串</param>
/// <param name="key">密匙，长度可以为：128位(byte[16])，192位(byte[24])</param>
/// <param name="iv">iv向量，长度必须为64位(byte[8])</param>
/// <returns>待加密的字符数据</returns>
public static string DeTripleDES(this string data, byte[] key, byte[] iv)
{
byte[] tmp = Convert.FromBase64String(data);
string result = string.Empty;
TripleDES tripleDES = TripleDES.Create();
ICryptoTransform decryptor = tripleDES.CreateDecryptor(key, iv);
using (MemoryStream ms = new MemoryStream(tmp))
{
using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
{
StreamReader reader = new StreamReader(cs);
result = reader.ReadLine();
}
}
tripleDES.Clear();
return(result);
}
public static string Decrypt11(string key, string dataen)
{
byte[] toEncryptArray = Convert.FromBase64String(dataen);
byte[] keydata = Encoding.ASCII.GetBytes(key);
string md5String = BitConverter.ToString(new MD5CryptoServiceProvider().ComputeHash(keydata)).Replace("-", "").ToLower();
byte[] tripleDesKey = Encoding.ASCII.GetBytes(md5String.Substring(0, 24));
TripleDES tripdes = TripleDESCryptoServiceProvider.Create();
tripdes.Mode = CipherMode.ECB;
tripdes.Padding = PaddingMode.PKCS7;
tripdes.Key = tripleDesKey;
tripdes.GenerateIV();
ICryptoTransform ict = tripdes.CreateDecryptor();
byte[] resultArray = ict.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tripdes.Clear();
return(Encoding.ASCII.GetString(resultArray));
}
byte[] TripleDesDecrypt(byte[] data)
{
TripleDES des = TripleDES.Create();
MD5 md5 = MD5.Create();
byte[] finalKey = md5.ComputeHash(TripleDesKey);
byte[] finalIV = md5.ComputeHash(TripleDesIV);
md5.Clear();
MemoryStream getvals = new MemoryStream(data);
byte[] retval = new byte[data.Length];
using (CryptoStream cs = new CryptoStream(getvals, des.CreateDecryptor(finalKey, finalIV), CryptoStreamMode.Read))
{
cs.Read(retval, 0, retval.Length);
}
des.Clear();
return(retval);
}
byte[] TripleDesCrypt(byte[] data)
{
TripleDES des = TripleDES.Create();
MD5 md5 = MD5.Create();
byte[] finalKey = md5.ComputeHash(TripleDesKey);
byte[] finalIV = md5.ComputeHash(TripleDesIV);
md5.Clear();
MemoryStream retvals = new MemoryStream();
using (CryptoStream cs = new CryptoStream(retvals, des.CreateEncryptor(finalKey, finalIV), CryptoStreamMode.Write))
{
cs.Write(data, 0, data.Length);
cs.FlushFinalBlock();
}
des.Clear();
return(retvals.ToArray());
}
/// <summary>
/// шифрует строку
/// </summary>
/// <param name="inputString">строка для шифрования</param>
/// <param name="dwKeySize">размер ключа</param>
/// <param name="privateKey">ключевого секретное слово для генерации ключа</param>
/// <returns></returns>
public static string EncryptString(string inputString, int dwKeySize, string privateKey)
{
TripleDES alg = TripleDES.Create();
var pdb = new PasswordDeriveBytes(privateKey, null); //класс, позволяющий генерировать ключи на базе паролей
pdb.HashName = "SHA512"; //будем использовать SHA512
alg.KeySize = dwKeySize; //устанавливаем размер ключа
alg.Key = pdb.GetBytes(dwKeySize >> 3); //получаем ключ из пароля
alg.Mode = CipherMode.CBC; //используем режим CBC
alg.IV = new Byte[alg.BlockSize >> 3]; //и пустой инициализационный вектор
ICryptoTransform tr = alg.CreateEncryptor(); //создаем encryptor
byte[] bytes = Encoding.UTF8.GetBytes(inputString);
var instream = new MemoryStream(bytes);
var stringBuilder = new StringBuilder();
int buflen = ((2 << 16) / alg.BlockSize) * alg.BlockSize;
var inbuf = new byte[buflen];
var outbuf = new byte[buflen];
int len;
while ((len = instream.Read(inbuf, 0, buflen)) == buflen)
{
int enclen = tr.TransformBlock(inbuf, 0, buflen, outbuf, 0); //собственно шифруем
Array.Reverse(outbuf);
// Why convert to base 64?
// Because it is the largest power-of-two base printable using only ASCII characters
stringBuilder.Append(Convert.ToBase64String(outbuf));
}
instream.Close();
outbuf = tr.TransformFinalBlock(inbuf, 0, len); //шифруем финальный блок
//Array.Reverse(outbuf);
// Why convert to base 64?
// Because it is the largest power-of-two base printable using only ASCII characters
stringBuilder.Append(Convert.ToBase64String(outbuf));
alg.Clear();
return(stringBuilder.ToString());
}
/// <summary>
/// дешифрует строку
/// </summary>
/// <param name="inputString">зашифрованная строка</param>
/// <param name="dwKeySize">размер ключа</param>
/// <param name="privateKey">ключевого секретное слово для генерации ключа</param>
/// <returns></returns>
public static string DecryptString(string inputString, int dwKeySize, string privateKey)
{
TripleDES alg = TripleDES.Create();
var pdb = new PasswordDeriveBytes(privateKey, null);
pdb.HashName = "SHA512";
alg.KeySize = dwKeySize;
dwKeySize >>= 3;
alg.Key = pdb.GetBytes(dwKeySize);
alg.Mode = CipherMode.CBC;
alg.IV = new Byte[alg.BlockSize >> 3];
ICryptoTransform tr = alg.CreateDecryptor();
//!!!! minas для очень длинных строк надо получить bytes по кускам
byte[] encryptedBytes = Convert.FromBase64String(inputString);
var instream = new MemoryStream(encryptedBytes);
//FileStream outstream = new FileStream(outFile.Text, FileMode.Create, FileAccess.Write, FileShare.None);
int buflen = ((2 << 16) / alg.BlockSize) * alg.BlockSize;
var inbuf = new byte[buflen];
var outbuf = new byte[buflen];
int len;
var arrayList = new ArrayList();
while ((len = instream.Read(inbuf, 0, buflen)) == buflen)
{
int declen = tr.TransformBlock(inbuf, 0, buflen, outbuf, 0);
//Array.Reverse(outbuf);
arrayList.AddRange(outbuf);
}
instream.Close();
outbuf = tr.TransformFinalBlock(inbuf, 0, len);
//Array.Reverse(outbuf);
arrayList.AddRange(outbuf);
alg.Clear();
return(Encoding.UTF8.GetString(arrayList.ToArray(Type.GetType("System.Byte")) as byte[]));
}
public bool DecryptData(string inputtedData, string password)
{
_result = null;
//Get Encrypted data and convert to byte[]
byte[] encryptedData = Convert.FromBase64String(inputtedData);
//Get actual data
byte[] realData = new byte[encryptedData.Length - 4];
Array.Copy(encryptedData, 0, realData, 0, realData.Length);
//Get checksum
byte[] checksum = new byte[4];
Array.Copy(encryptedData, realData.Length, checksum, 0, checksum.Length);
byte[] check = Crc32.Compute(realData);
//compare the new computed data to the version on the encrypted data
if (!check.SequenceEqual(checksum))
{
return(false);
}
//If all is valid Get password
byte[] buffer = Encoding.UTF8.GetBytes(password);
Array.Copy(buffer, 0, _key, 0, buffer.Length);
//Get ready to decrypt
TripleDES tripleDes = TripleDES.Create();
tripleDes.Key = _key;
tripleDes.Mode = CipherMode.ECB;
ICryptoTransform icryptoTransform = tripleDes.CreateDecryptor();
byte[] resultArray = icryptoTransform.TransformFinalBlock(realData, 0, realData.Length);
_result = Encoding.UTF8.GetString(resultArray);
tripleDes.Clear();
return(true);
}
