internal static byte[] TripleDESKeyWrapDecrypt(byte[] rgbKey, byte[] rgbEncryptedWrappedKeyData)
{
// Check to see whether the length of the encrypted key is reasonable
if (rgbEncryptedWrappedKeyData.Length != 32 && rgbEncryptedWrappedKeyData.Length != 40 &&
rgbEncryptedWrappedKeyData.Length != 48)
{
throw new CryptographicException(SR.Cryptography_Xml_KW_BadKeySize);
}
TripleDES tripleDES = null;
ICryptoTransform dec1 = null;
ICryptoTransform dec2 = null;
try
{
tripleDES = TripleDES.Create();
// Assume no padding, use CBC mode
tripleDES.Padding = PaddingMode.None;
dec1 = tripleDES.CreateDecryptor(rgbKey, s_rgbTripleDES_KW_IV);
byte[] temp2 = dec1.TransformFinalBlock(rgbEncryptedWrappedKeyData, 0, rgbEncryptedWrappedKeyData.Length);
Array.Reverse(temp2);
// Get the IV and temp1
byte[] rgbIV = new byte[8];
Buffer.BlockCopy(temp2, 0, rgbIV, 0, 8);
byte[] temp1 = new byte[temp2.Length - rgbIV.Length];
Buffer.BlockCopy(temp2, 8, temp1, 0, temp1.Length);
dec2 = tripleDES.CreateDecryptor(rgbKey, rgbIV);
byte[] rgbWKCKS = dec2.TransformFinalBlock(temp1, 0, temp1.Length);
// checksum the key
byte[] rgbWrappedKeyData = new byte[rgbWKCKS.Length - 8];
Buffer.BlockCopy(rgbWKCKS, 0, rgbWrappedKeyData, 0, rgbWrappedKeyData.Length);
using (var sha = SHA1.Create())
{
byte[] rgbCKS = sha.ComputeHash(rgbWrappedKeyData);
for (int index = rgbWrappedKeyData.Length, index1 = 0; index < rgbWKCKS.Length; index++, index1++)
{
if (rgbWKCKS[index] != rgbCKS[index1])
{
throw new CryptographicException(SR.Cryptography_Xml_BadWrappedKeySize);
}
}
return(rgbWrappedKeyData);
}
}
finally
{
dec2?.Dispose();
dec1?.Dispose();
tripleDES?.Dispose();
}
}
public string Decrypt(string data, int vi)
{
MemoryStream ms = new MemoryStream();
Byte[] tb = Convert.FromBase64String(data);
des.Key = Convert.FromBase64String(Keys[vi]);
des.IV = Convert.FromBase64String(IVs[vi]);
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(tb, 0, tb.Length);
cs.Flush();
cs.Close();
return(Encoding.Unicode.GetString(ms.ToArray()));
}
/// <summary>
/// 三重DES解密
/// </summary>
/// <param name="cipherText"></param>
/// <param name="secretKey">由淘宝提供的码商密钥</param>
/// <returns></returns>
public static string TripleDES_Decrypt(string cipherText, string secretKey)
{
if (string.IsNullOrWhiteSpace(cipherText))
{
return(cipherText);
}
string plaintext = cipherText;
using (TripleDES desAlg = TripleDES.Create())
{
desAlg.Key = Encoding.UTF8.GetBytes(secretKey.Substring(0, 24));
desAlg.IV = Encoding.UTF8.GetBytes(secretKey.Substring(0, 8));
ICryptoTransform decryptor = desAlg.CreateDecryptor(desAlg.Key, desAlg.IV);
byte[] bCipherText = Convert.FromBase64String(cipherText);
using (MemoryStream msDecrypt = new MemoryStream(bCipherText))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
plaintext = srDecrypt.ReadToEnd();
}
}
}
}
return(plaintext);
}
public static string ThreeDesDecryptHEX(string input)
{
TripleDES edes = TripleDES.Create();
edes.Mode = CipherMode.CBC;
edes.Padding = PaddingMode.PKCS7;
byte[] rgbKey = new byte[] {
1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4,
5, 6, 1, 2, 3, 4, 5, 6
};
byte[] rgbIV = new byte[] { 1, 2, 3, 4, 5, 6, 1, 2 };
ICryptoTransform transform = edes.CreateDecryptor(rgbKey, rgbIV);
if (input.Length <= 1)
{
throw new Exception("encrypted HEX string is too short!");
}
byte[] buffer = new byte[input.Length / 2];
for (int i = 0; i < buffer.Length; i++)
{
buffer[i] = Convert.ToByte(input.Substring(i * 2, 2), 0x10);
}
MemoryStream stream = new MemoryStream();
CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Write);
stream2.Write(buffer, 0, buffer.Length);
stream2.FlushFinalBlock();
stream2.Close();
return(Encoding.GetEncoding("GB2312").GetString(stream.ToArray()));
}
public static void MultipleBlockDecryptTransform(bool blockAlignedOutput)
{
const string ExpectedOutput = "This is a test";
int outputPadding = blockAlignedOutput ? 0 : 3;
byte[] key = "0123456789ABCDEFFEDCBA9876543210ABCDEF0123456789".HexToByteArray();
byte[] iv = "0123456789ABCDEF".HexToByteArray();
byte[] outputBytes = new byte[iv.Length * 2 + outputPadding];
byte[] input = "A61C8F1D393202E1E3C71DCEAB9B08DB".HexToByteArray();
int outputOffset = 0;
using (TripleDES alg = TripleDESFactory.Create())
using (ICryptoTransform xform = alg.CreateDecryptor(key, iv))
{
Assert.Equal(2 * alg.BlockSize, (outputBytes.Length - outputPadding) * 8);
outputOffset += xform.TransformBlock(input, 0, input.Length, outputBytes, outputOffset);
byte[] overflow = xform.TransformFinalBlock(Array.Empty <byte>(), 0, 0);
Buffer.BlockCopy(overflow, 0, outputBytes, outputOffset, overflow.Length);
outputOffset += overflow.Length;
}
string decrypted = Encoding.ASCII.GetString(outputBytes, 0, outputOffset);
Assert.Equal(ExpectedOutput, decrypted);
}
public static void DecryptorReuse_LeadsToSameResults(CipherMode cipherMode, int feedbackSize)
{
// AppleCCCryptor does not allow calling Reset on CFB cipher.
// this test validates that the behavior is taken into consideration.
var input = "896072ab28e5fdfc9e8b3610627bf27a".HexToByteArray();
var key = "c179d0fdd073a1910e51f1d5fe70047ac179d0fdd073a191".HexToByteArray();
var iv = "b956d5426d02b247".HexToByteArray();
using (TripleDES tdes = TripleDESFactory.Create())
{
tdes.Mode = cipherMode;
tdes.Key = key;
tdes.IV = iv;
tdes.Padding = PaddingMode.None;
if (feedbackSize > 0)
{
tdes.FeedbackSize = feedbackSize;
}
using (ICryptoTransform transform = tdes.CreateDecryptor())
{
byte[] output1 = transform.TransformFinalBlock(input, 0, input.Length);
byte[] output2 = transform.TransformFinalBlock(input, 0, input.Length);
Assert.Equal(output1, output2);
}
}
}
//public static DateTime ConvertToDate(string DateString)
//{
// try
// {
// string[] arrDate = DateString.Split('/');
// return DateTime.Parse(string.Format("{2}/{1}/{0}", arrDate[0], arrDate[1], arrDate[2]));
// }
// catch (Exception ex)
// {
// throw;
// }
//}
#region Symmetric Cryptography (Triple DES)
public static string SymmetricDecrypt(string input)
{
#if DEBUG
try
{
#endif
byte[] clearData;
string result;
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, alg.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(System.Convert.FromBase64String(input), 0, System.Convert.FromBase64String(input).Length);
cs.FlushFinalBlock();
clearData = ms.ToArray();
ms.Close();
cs.Close();
result = Encoding.UTF8.GetString(clearData);
}
}
return(result);
#if DEBUG
}
catch
{
return(input);
}
#endif
}
public static string DecryptTextFromMemory(byte[] Data, byte[] Key, byte[] IV)
{
try
{
// Create a new MemoryStream using the passed
// array of encrypted data.
MemoryStream msDecrypt = new MemoryStream(Data);
// Create a new TripleDES object.
TripleDES tripleDESalg = TripleDES.Create();
// Create a CryptoStream using the MemoryStream
// and the passed key and initialization vector (IV).
CryptoStream csDecrypt = new CryptoStream(msDecrypt,
tripleDESalg.CreateDecryptor(Key, IV),
CryptoStreamMode.Read);
// Create buffer to hold the decrypted data.
byte[] fromEncrypt = new byte[Data.Length];
// Read the decrypted data out of the crypto stream
// and place it into the temporary buffer.
csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length);
//Convert the buffer into a string and return it.
return(new ASCIIEncoding().GetString(fromEncrypt));
}
catch (CryptographicException e)
{
Console.WriteLine("A Cryptographic error occurred: {0}", e.Message);
return(null);
}
}
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);
}
/// <summary>
/// Decrypts an encrypted stream of bytes by using a TripleDES symmetric algorithm.
/// </summary>
/// <param name="cipherValue">The encrypted stream of bytes to be decrypted.</param>
/// <param name="key">Symmetric algorithm key.</param>
/// <returns>A stream of bytes.</returns>
private byte[] Decrypt(byte[] cipherValue, byte[] key)
{
byte[] plainValue = new byte[cipherValue.Length];
TripleDES algorithm = TripleDESCryptoServiceProvider.Create();
MemoryStream memStream = new MemoryStream(cipherValue);
CryptoStream cryptoStream = new CryptoStream(memStream, algorithm.CreateDecryptor(key, IV), CryptoStreamMode.Read);
try
{
cryptoStream.Read(plainValue, 0, plainValue.Length);
}
catch (Exception e)
{
throw new UIPException(Resource.ResourceManager[Resource.Exceptions.RES_ExceptionSecureSqlProviderCantDecrypt] + UIPException.GetFirstExceptionMessage(e), e);
}
finally
{
//Flush the stream buffer
cryptoStream.Close();
}
return(plainValue);
}
/// <summary>
/// DES decrypt
/// </summary>
/// <param name="data">Encrypted data</param>
/// <param name="key">Key, requires 24 bits</param>
/// <returns>Decrypted string</returns>
public static string DESDecrypt(string data, string key)
{
Byte[] encryptedBytes = Convert.FromBase64String(data);
Byte[] bKey = new Byte[24];
Array.Copy(Encoding.UTF8.GetBytes(key.PadRight(bKey.Length)), bKey, bKey.Length);
using (MemoryStream mStream = new MemoryStream(encryptedBytes))
using (TripleDES des = TripleDES.Create())
{
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
des.Key = bKey;
using (CryptoStream cryptoStream = new CryptoStream(mStream, des.CreateDecryptor(), CryptoStreamMode.Read))
try
{
byte[] tmp = new byte[encryptedBytes.Length];
int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length);
byte[] ret = new byte[len];
Array.Copy(tmp, 0, ret, 0, len);
return(Encoding.UTF8.GetString(ret));
}
catch
{
return(null);
}
}
}
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
switch (this.algorithmID)
{
case EncryptionAlgorithm.Des:
DES des = (DES) new DESCryptoServiceProvider();
des.Mode = CipherMode.CBC;
des.Key = bytesKey;
des.IV = this.initVec;
return(des.CreateDecryptor());
case EncryptionAlgorithm.Rc2:
RC2 rc2 = (RC2) new RC2CryptoServiceProvider();
rc2.Mode = CipherMode.CBC;
return(rc2.CreateDecryptor(bytesKey, this.initVec));
case EncryptionAlgorithm.Rijndael:
Rijndael rijndael = (Rijndael) new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
return(rijndael.CreateDecryptor(bytesKey, this.initVec));
case EncryptionAlgorithm.TripleDes:
TripleDES tripleDes = (TripleDES) new TripleDESCryptoServiceProvider();
tripleDes.Mode = CipherMode.CBC;
return(tripleDes.CreateDecryptor(bytesKey, this.initVec));
default:
throw new CryptographicException("Algorithm ID '" + (object)this.algorithmID + "' not supported.");
}
}
/// <summary>
/// Decrypts an salted string
/// </summary>
/// <param name="encryptedString"></param>
public string Decrypt(string encryptedString)
{
string returnValue;
try
{
string itemToDecrypt = encryptedString;
if (this.EncodeForURL)
{
itemToDecrypt = Uri.UnescapeDataString(encryptedString).Replace("%20", "+");
}
using (TripleDES des = CreateDes())
{
ICryptoTransform decryptor = des.CreateDecryptor();
var encryptedByte = Convert.FromBase64String(itemToDecrypt);
var decryptedByte = decryptor.TransformFinalBlock(encryptedByte, 0, encryptedByte.Length);
var decryptedSaltedString = Encoding.Unicode.GetString(decryptedByte);
// Final decryption and return
returnValue = decryptedSaltedString.Remove(decryptedSaltedString.Length - this.Salt.Length);
}
}
catch
{
returnValue = string.Empty;
}
return(returnValue);
}
private byte[] DecryptPBDK2(byte[] edata, byte[] salt, byte[] IV, SecureString secpswd, int iterations)
{
CryptoStream stream = null;
IntPtr zero = IntPtr.Zero;
byte[] destination = new byte[secpswd.Length];
zero = Marshal.SecureStringToGlobalAllocAnsi(secpswd);
Marshal.Copy(zero, destination, 0, destination.Length);
Marshal.ZeroFreeGlobalAllocAnsi(zero);
try
{
Rfc2898DeriveBytes bytes = new Rfc2898DeriveBytes(destination, salt, iterations);
TripleDES edes = TripleDES.Create();
edes.Key = bytes.GetBytes(0x18);
edes.IV = IV;
MemoryStream stream2 = new MemoryStream();
stream = new CryptoStream(stream2, edes.CreateDecryptor(), CryptoStreamMode.Write);
stream.Write(edata, 0, edata.Length);
stream.Flush();
stream.Close();
return(stream2.ToArray());
}
catch (Exception exception)
{
this.Mensaje = "Error al desencriptar la llave. " + exception.Message;
return(null);
}
}
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 static string GetString(string _key)
{
// Hide '_key' string.
byte[] hashData = md5HashMaker.ComputeHash(System.Text.Encoding.UTF8.GetBytes(_key));
string hashKey = System.Text.Encoding.UTF8.GetString(hashData);
// Retrieve encrypted '_value' and Base64 decode it.
string _value = PlayerPrefs.GetString(hashKey);
if (string.IsNullOrEmpty(_value) == true)
{
return(string.Empty);
}
byte[] bytes = Convert.FromBase64String(_value);
// Decrypt '_value' with 3DES.
desMaker.Key = md5HashMaker.ComputeHash(System.Text.Encoding.UTF8.GetBytes(privateKey));;
desMaker.Mode = CipherMode.ECB;
ICryptoTransform xform = desMaker.CreateDecryptor();
byte[] decrypted = xform.TransformFinalBlock(bytes, 0, bytes.Length);
// decrypte_value as a proper string.
string decryptedString = System.Text.Encoding.UTF8.GetString(decrypted);
//Debug.Log("GetString hashKey: " + hashKey + " GetData: " + _value + " Decrypted Data: " + decryptedString);
return(decryptedString);
}
private void tripleDesDecryption(String cipher, String padding, String key)
{
using (TripleDES tDes = TripleDES.Create())
{
tDes.Mode = (CipherMode)Enum.Parse(typeof(CipherMode), cipher, true);
tDes.Padding = (PaddingMode)Enum.Parse(typeof(PaddingMode), padding, true);
tDes.KeySize = 128;
tDes.Key = getBytes(this.KeyTextBox.Text);
byte[] input = File.ReadAllBytes(this.InputTextBox.Text);
string output = null;
ICryptoTransform decryptor = tDes.CreateDecryptor(tDes.Key, tDes.IV);
using (MemoryStream msDecrypt = new MemoryStream(input))
{
using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
{
using (StreamReader srDecrypt = new StreamReader(csDecrypt))
{
output = srDecrypt.ReadToEnd();
}
}
}
File.WriteAllText(this.OutputTextBox.Text, output);
MessageBox.Show("Succesfuly decrypted!");
}
}
private string Decrypt7(byte[] Data, byte[] Key)
{
// Create a new MemoryStream using the passed
// array of encrypted data.
MemoryStream msDecrypt = new MemoryStream(Data);
// Create a new TripleDES object.
TripleDES tripleDESalg = TripleDES.Create();
tripleDESalg.Key = Key;
tripleDESalg.Padding = PaddingMode.None;
// Create a CryptoStream using the MemoryStream
// and the passed key and initialization vector (IV).
CryptoStream csDecrypt = new CryptoStream(msDecrypt,
tripleDESalg.CreateDecryptor(), CryptoStreamMode.Read);
// Create buffer to hold the decrypted data.
byte[] fromEncrypt = new byte[Data.Length];
// Read the decrypted data out of the crypto stream
// and place it into the temporary buffer.
csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length);
//Convert the buffer into a string and return it.
return(UTF8Encoding.UTF8.GetString(fromEncrypt));
}
public int DecryptUserId(string id, string password, string salt)
{
byte[] saltBytes = new UTF8Encoding(false).GetBytes(salt);
Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(password, saltBytes, USER_ID_HASH_ITERATIONS);
TripleDES decryptor = TripleDES.Create();
decryptor.Padding = PaddingMode.PKCS7;
decryptor.Mode = CipherMode.CBC;
byte[] relevantBytes = key.GetBytes(KEY_HASH_BYTES);
PrintBytes(relevantBytes);
decryptor.Key = relevantBytes;
decryptor.IV = key.GetBytes(IV_HASH_BYTES);
int result;
using (MemoryStream mem = new MemoryStream())
{
using (CryptoStream crypt = new CryptoStream(mem, decryptor.CreateDecryptor(), CryptoStreamMode.Write))
{
byte[] base64Data = Convert.FromBase64String(id);
crypt.Write(base64Data, 0, base64Data.Length);
}
byte[] utf8Bytes = mem.ToArray();
PrintBytes(utf8Bytes);
result = int.Parse(new UTF8Encoding(false).GetString(utf8Bytes));
}
return(result);
}
public static void TripleDesCreate()
{
byte[] inputBytes = Encoding.ASCII.GetBytes("This is a secret message and is a sentence that is longer than a block, it ensures that multi-block functions work.");
TripleDES tripleDes = TripleDES.Create();
byte[] encryptedBytes;
using (MemoryStream input = new MemoryStream(inputBytes))
using (CryptoStream cryptoStream = new CryptoStream(input, tripleDes.CreateEncryptor(), CryptoStreamMode.Read))
using (MemoryStream output = new MemoryStream())
{
cryptoStream.CopyTo(output);
encryptedBytes = output.ToArray();
}
Assert.NotEqual(inputBytes, encryptedBytes);
byte[] decryptedBytes;
using (MemoryStream input = new MemoryStream(encryptedBytes))
using (CryptoStream cryptoStream = new CryptoStream(input, tripleDes.CreateDecryptor(), CryptoStreamMode.Read))
using (MemoryStream output = new MemoryStream())
{
cryptoStream.CopyTo(output);
decryptedBytes = output.ToArray();
}
Assert.Equal(inputBytes, decryptedBytes);
}
/// <summary>
/// Decrypts an salted string
/// </summary>
/// <param name="encryptedString"></param>
public string Decrypt(string encryptedString)
{
var returnValue = TypeExtension.DefaultString;
var itemToDecrypt = TypeExtension.DefaultString;
try
{
itemToDecrypt = encryptedString;
if (this.EncodeForURL)
{
itemToDecrypt = UrlEncoder.Decode(encryptedString);
}
TripleDES des = CreateDes();
ICryptoTransform decryptor = des.CreateDecryptor();
var encryptedByte = Convert.FromBase64String(itemToDecrypt);
var decryptedByte = decryptor.TransformFinalBlock(encryptedByte, 0, encryptedByte.Length);
var decryptedSaltedString = Encoding.Unicode.GetString(decryptedByte);
// Final decryption and return
returnValue = decryptedSaltedString.Remove(decryptedSaltedString.Length - this.Salt.Length);
}
catch
{
returnValue = TypeExtension.DefaultString;
}
return(returnValue);
}
/// <summary>
/// ถอดรหัสด้วย TripleDEC
/// </summary>
/// <param name="keyHash">Key ที่ใช้ถอดรหัส</param>
/// <param name="input"></param>
/// <returns></returns>
public static string SymmetricDecrypt(string keyHash, string input)
{
byte[] clearData;
string result;
using (MemoryStream ms = new MemoryStream())
{
using (TripleDES tripleDES = TripleDES.Create())
{
tripleDES.Key = Encoding.ASCII.GetBytes((keyHash + "!@#$%^&*()_+|").PadRight(24, '฿').Substring(0, 24));
tripleDES.Mode = CipherMode.ECB;
using (CryptoStream cs = new CryptoStream(ms, tripleDES.CreateDecryptor(), CryptoStreamMode.Write))
{
byte[] byteInput = System.Convert.FromBase64String(input);
cs.Write(byteInput, 0, byteInput.Length);
cs.FlushFinalBlock();
clearData = ms.ToArray();
ms.Close();
cs.Close();
result = Encoding.ASCII.GetString(clearData);
}
}
}
return(result);
}
public byte[] Des3Decrypt(byte[] data, byte[] key, byte[] iv)
{
try
{
TripleDES edes = TripleDES.Create();
if (iv != null)
{
edes.IV = iv;
}
edes.Key = key;
edes.Mode = CipherMode.ECB;
edes.Padding = PaddingMode.None;
byte[] buffer = new byte[0];
return(edes.CreateDecryptor().TransformFinalBlock(data, 0, data.Length));
}
catch (CryptographicException exception)
{
logger.ErrorFormat("A Cryptographic error occurred: {0}, Data={1}, Length={2}", new object[] { exception.Message, data.Length, data.Length });
return(null);
}
catch (Exception exception2)
{
logger.ErrorFormat("A exception occurred: {0}", new object[] { exception2.Message });
return(null);
}
}
public static void TransformWithTooShortOutputBuffer(bool encrypt, bool blockAlignedOutput)
{
using (TripleDES alg = TripleDESFactory.Create())
using (ICryptoTransform xform = encrypt ? alg.CreateEncryptor() : alg.CreateDecryptor())
{
// 1 block, plus maybe three bytes
int outputPadding = blockAlignedOutput ? 0 : 3;
byte[] output = new byte[alg.BlockSize / 8 + outputPadding];
// 3 blocks of 0x00
byte[] input = new byte[3 * (alg.BlockSize / 8)];
Type exceptionType = typeof(ArgumentOutOfRangeException);
// TripleDESCryptoServiceProvider doesn't throw the ArgumentOutOfRangeException,
// giving a CryptographicException when CAPI reports the destination too small.
if (PlatformDetection.IsNetFramework)
{
exceptionType = typeof(CryptographicException);
}
Assert.Throws(
exceptionType,
() => xform.TransformBlock(input, 0, input.Length, output, 0));
Assert.Equal(new byte[output.Length], output);
}
}
static void Main()
{
Console.WriteLine("ENTER KEY");
string key = Console.ReadLine();
TripleDES des = CreateDES(key);
//encrypt
Console.WriteLine("ENCRYPT (e) OR DECRYPT (d)?");
string answer = Console.ReadLine();
if (answer == "e")
{
Console.WriteLine("Type in your string");
ICryptoTransform ct = des.CreateEncryptor();
byte[] input = utf8.GetBytes(Console.ReadLine());
byte[] encrypted = ct.TransformFinalBlock(input, 0, input.Length);
Console.WriteLine(Convert.ToBase64String(encrypted));
}
//decrypt
else if (answer == "d")
{
Console.WriteLine("Type in your string");
string CypherText = Console.ReadLine();
byte[] b = Convert.FromBase64String(CypherText);
ICryptoTransform ct = des.CreateDecryptor();
byte[] input = ct.TransformFinalBlock(b, 0, b.Length);
string decrypted = utf8.GetString(input);
Console.WriteLine(decrypted);
}
else
{
Console.WriteLine("GEEN OPTIE.");
}
Console.ReadLine();
}
/// <summary>
/// DES decrypt
/// </summary>
/// <param name="data">Encrypted data</param>
/// <param name="key">Key, requires 24 bits</param>
/// <returns>Decrypted byte array</returns>
public static byte[] DESDecrypt(byte[] data, string key)
{
Check.Argument.IsNotEmpty(data, nameof(data));
Check.Argument.IsNotEmpty(key, nameof(key));
Check.Argument.IsNotOutOfRange(key.Length, 24, 24, nameof(key));
Byte[] encryptedBytes = data;
Byte[] bKey = new Byte[24];
Array.Copy(Encoding.UTF8.GetBytes(key.PadRight(bKey.Length)), bKey, bKey.Length);
using (MemoryStream Memory = new MemoryStream(encryptedBytes))
{
using (TripleDES des = TripleDES.Create())
{
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
des.Key = bKey;
using (CryptoStream cryptoStream = new CryptoStream(Memory, des.CreateDecryptor(), CryptoStreamMode.Read))
{
try
{
byte[] tmp = new byte[encryptedBytes.Length];
int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length);
byte[] ret = new byte[len];
Array.Copy(tmp, 0, ret, 0, len);
return(ret);
}
catch
{
return(null);
}
}
}
}
}
public static byte[] DecryptPBDK2(
byte[] edata,
byte[] salt,
byte[] IV,
SecureString secpswd,
int iterations)
{
IntPtr zero = IntPtr.Zero;
byte[] numArray = new byte[secpswd.Length];
IntPtr globalAllocAnsi = Marshal.SecureStringToGlobalAllocAnsi(secpswd);
Marshal.Copy(globalAllocAnsi, numArray, 0, numArray.Length);
Marshal.ZeroFreeGlobalAllocAnsi(globalAllocAnsi);
try
{
Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(numArray, salt, iterations);
TripleDES tripleDes = TripleDES.Create();
tripleDes.Key = rfc2898DeriveBytes.GetBytes(24);
tripleDes.IV = IV;
MemoryStream memoryStream = new MemoryStream();
CryptoStream cryptoStream = new CryptoStream((Stream)memoryStream, tripleDes.CreateDecryptor(), CryptoStreamMode.Write);
cryptoStream.Write(edata, 0, edata.Length);
cryptoStream.Flush();
cryptoStream.Close();
return(memoryStream.ToArray());
}
catch (Exception ex)
{
Console.WriteLine("Problem decrypting: {0}", (object)ex.Message);
return((byte[])null);
}
}
public static void InvalidCFBFeedbackSizes(int feedbackSize, bool discoverableInSetter)
{
using (TripleDES tdes = TripleDESFactory.Create())
{
tdes.GenerateKey();
tdes.Mode = CipherMode.CFB;
if (discoverableInSetter)
{
// there are some key sizes that are invalid for any of the modes,
// so the exception is thrown in the setter
Assert.Throws <CryptographicException>(() =>
{
tdes.FeedbackSize = feedbackSize;
});
}
else
{
tdes.FeedbackSize = feedbackSize;
// however, for CFB only few sizes are valid. Those should throw in the
// actual AES instantiation.
Assert.Throws <CryptographicException>(() => tdes.CreateDecryptor());
Assert.Throws <CryptographicException>(() => tdes.CreateEncryptor());
}
}
}
// ------ Uses PBKD2 to derive a 3DES key and decrypts data --------
public static byte[] DecryptPBDK2(byte[] edata, byte[] salt, byte[] IV, SecureString secpswd, int iterations)
{
CryptoStream decrypt = null;
IntPtr unmanagedPswd = IntPtr.Zero;
byte[] psbytes = new byte[secpswd.Length];
unmanagedPswd = Marshal.SecureStringToGlobalAllocAnsi(secpswd);
Marshal.Copy(unmanagedPswd, psbytes, 0, psbytes.Length);
Marshal.ZeroFreeGlobalAllocAnsi(unmanagedPswd);
try
{
Rfc2898DeriveBytes kd = new Rfc2898DeriveBytes(psbytes, salt, iterations);
TripleDES decAlg = TripleDES.Create();
decAlg.Key = kd.GetBytes(24);
decAlg.IV = IV;
MemoryStream memstr = new MemoryStream();
decrypt = new CryptoStream(memstr, decAlg.CreateDecryptor(), CryptoStreamMode.Write);
decrypt.Write(edata, 0, edata.Length);
decrypt.Flush();
decrypt.Close(); // this is REQUIRED.
byte[] cleartext = memstr.ToArray();
return(cleartext);
}
catch (Exception e)
{
Console.WriteLine("Problem decrypting: {0}", e.Message);
return(null);
}
}
public static string desencriptaPHP(string _key24, string _iv, string _data)
{
byte[] key = Encoding.ASCII.GetBytes(_key24);
byte[] iv = Encoding.ASCII.GetBytes(_iv);
byte[] data = Convert.FromBase64String(_data);
byte[] enc = new byte[0];
TripleDES tdes = TripleDES.Create();
tdes.Mode = CipherMode.CBC;
tdes.Padding = PaddingMode.Zeros;
tdes.IV = iv;
tdes.Key = key;
ICryptoTransform ict = tdes.CreateDecryptor();
enc = ict.TransformFinalBlock(data, 0, data.Length);
string retorno = Encoding.ASCII.GetString(enc);
retorno = retorno.Replace("\0", "");
return(retorno);
}
// Check a TripleDES instance against a particular key and plaintext.
// We do this by comparing against what DES would do, if applied manually.
// This assumes that DES has already been tested and found to be OK.
private static void CheckTripleDES(TripleDES alg, byte[] key,
byte[] plaintext)
{
// Set up the algorithm the way we want.
alg.Mode = CipherMode.ECB;
alg.Padding = PaddingMode.None;
// Create an encryptor and determine the output ciphertext.
ICryptoTransform encryptor = alg.CreateEncryptor(key, null);
byte[] ciphertext = new byte [plaintext.Length * 2];
byte[] tail;
int len = encryptor.TransformBlock
(plaintext, 0, plaintext.Length,
ciphertext, 0);
AssertEquals("ECB encrypt length mismatch",
len, plaintext.Length);
tail = encryptor.TransformFinalBlock
(plaintext, 0, 0);
AssertNotNull("ECB encrypt tail should be non-null");
AssertEquals("ECB encrypt tail should be zero length",
tail.Length, 0);
// Create a decryptor and run the test backwards.
ICryptoTransform decryptor = alg.CreateDecryptor(key, null);
byte[] original = new byte [plaintext.Length * 2];
len = decryptor.TransformBlock
(ciphertext, 0, plaintext.Length, original, 0);
AssertEquals("ECB decrypt length mismatch",
len, plaintext.Length);
tail = decryptor.TransformFinalBlock
(ciphertext, 0, 0);
AssertNotNull("ECB decrypt tail should be non-null");
AssertEquals("ECB decrypt tail should be zero length",
tail.Length, 0);
if(!IdenticalBlock(plaintext, 0, original, 0,
plaintext.Length))
{
Fail("did not decrypt to the original plaintext");
}
// Now see what DES would say on the same input to make
// sure that TripleDES is giving the correct behaviour.
DES des = DES.Create();
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.None;
ICryptoTransform encrypt1;
ICryptoTransform decrypt2;
ICryptoTransform encrypt3;
if(key.Length == 16)
{
encrypt1 = des.CreateEncryptor(SubKey(key, 0, 8), null);
decrypt2 = des.CreateDecryptor(SubKey(key, 8, 8), null);
encrypt3 = des.CreateEncryptor(SubKey(key, 0, 8), null);
}
else
{
encrypt1 = des.CreateEncryptor(SubKey(key, 0, 8), null);
decrypt2 = des.CreateDecryptor(SubKey(key, 8, 8), null);
encrypt3 = des.CreateEncryptor(SubKey(key, 16, 8), null);
}
byte[] block = new byte [plaintext.Length];
encrypt1.TransformBlock
(plaintext, 0, plaintext.Length, block, 0);
tail = encrypt1.TransformFinalBlock
(plaintext, 0, 0);
decrypt2.TransformBlock
(block, 0, plaintext.Length, block, 0);
tail = decrypt2.TransformFinalBlock
(block, 0, 0);
encrypt3.TransformBlock
(block, 0, plaintext.Length, block, 0);
tail = encrypt3.TransformFinalBlock
(block, 0, 0);
if(!IdenticalBlock(ciphertext, 0, block, 0, plaintext.Length))
{
Fail("TripleDES does not have the correct behaviour");
}
}
