/// <summary>
/// Decrypt the given string using the specified key.
/// </summary>
/// <param name="strEncrypted">The string to be decrypted.</param>
/// <param name="strKey">The decryption key.</param>
/// <returns>The decrypted string.</returns>
public static string Decrypt(string strEncrypted, string strKey)
{
try
{
TripleDESCryptoServiceProvider objDESCrypto = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider objHashMD5 = new MD5CryptoServiceProvider();
byte[] byteHash, byteBuff;
string strTempKey = strKey;
byteHash = objHashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(strTempKey));
objHashMD5 = null;
objDESCrypto.Key = byteHash;
objDESCrypto.Mode = CipherMode.ECB; //CBC, CFB
byteBuff = Convert.FromBase64String(strEncrypted);
string strDecrypted = ASCIIEncoding.ASCII.GetString(objDESCrypto.CreateDecryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length));
objDESCrypto = null;
return strDecrypted;
}
catch (Exception ex)
{
return "Wrong Input. " + ex.Message;
}
}
public static string Decrypt(string encryptedString)
{
string decyprted = null;
byte[] inputBytes = null;
try
{
inputBytes = Convert.FromBase64String(encryptedString);
byte[] pwdhash = null;
MD5CryptoServiceProvider hashmd5;
//generate an MD5 hash from the password.
//a hash is a one way encryption meaning once you generate
//the hash, you cant derive the password back from it.
hashmd5 = new MD5CryptoServiceProvider();
pwdhash = hashmd5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(key));
hashmd5 = null;
// Create a new TripleDES service provider
TripleDESCryptoServiceProvider tdesProvider = new TripleDESCryptoServiceProvider();
tdesProvider.Key = pwdhash;
tdesProvider.Mode = CipherMode.ECB;
decyprted = ASCIIEncoding.ASCII.GetString(
tdesProvider.CreateDecryptor().TransformFinalBlock(inputBytes, 0, inputBytes.Length));
}
catch(Exception e)
{
string str = e.Message;
throw ;
}
return decyprted;
}
public string Decrypt(string cypherString, bool useHasing)
{
byte[] keyArray;
byte[] toDecryptArray = Convert.FromBase64String(cypherString.Replace(' ','+'));
string key = "malkit";
if (useHasing)
{
MD5CryptoServiceProvider hashmd = new MD5CryptoServiceProvider();
keyArray = hashmd.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd.Clear();
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider tDes = new TripleDESCryptoServiceProvider();
tDes.Key = keyArray;
tDes.Mode = CipherMode.ECB;
tDes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tDes.CreateDecryptor();
try
{
byte[] resultArray = cTransform.TransformFinalBlock(toDecryptArray, 0, toDecryptArray.Length);
tDes.Clear();
return UTF8Encoding.UTF8.GetString(resultArray, 0, resultArray.Length);
}
catch (Exception ex)
{
throw ex;
}
}
public static string Decrypt(string cipherString, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
string key = (string)settingsReader.GetValue("search", typeof(String));
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return UTF8Encoding.UTF8.GetString(resultArray);
}
/// <summary>
/// 使用给定密钥解密数据
/// </summary>
/// <param name="encrypted">密文</param>
/// <param name="key">密钥</param>
/// <returns>明文</returns>
public static byte[] Decrypt(byte[] encrypted, byte[] key)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = MakeMD5(key);
des.Mode = CipherMode.ECB;
return des.CreateDecryptor().TransformFinalBlock(encrypted, 0, encrypted.Length);
}
public static string Decrypt(string input, string key)
{
byte[] inputArray = Convert.FromBase64String(input);
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Key = UTF8Encoding.UTF8.GetBytes(key);
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tripleDES.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
tripleDES.Clear();
return UTF8Encoding.UTF8.GetString(resultArray);
}
/// <summary>
/// TripleDes Data DeEncrypt With Out Encrypt Key Operator
/// </summary>
/// <param name="encryptBytes">Encrypt Byte Array</param>
/// <returns>DeEncrypt SourceContent String</returns>
public static string TripleDesDeEncryptWithOutKey(byte[] encryptBytes)
{
if (encryptBytes == null || encryptBytes.Length <= 0)
return string.Empty;
TripleDESCryptoServiceProvider tripleDesProvider = new TripleDESCryptoServiceProvider();
ICryptoTransform deEncryptTransform = tripleDesProvider.CreateDecryptor();
var deEncryptBytes = deEncryptTransform.TransformFinalBlock(encryptBytes, 0, encryptBytes.Length);
var deEncryptFormatStr = Encoding.UTF8.GetString(deEncryptBytes, 0, deEncryptBytes.Length);
return deEncryptFormatStr;
}
public static string Decrypt(string cipherString, bool useHashing)
{
/*
* Reference to: Syed Moshiur - Software Developer
* http://www.codeproject.com/Articles/14150/Encrypt-and-Decrypt-Data-with-C
*
*/
byte[] keyArray;
//get the byte code of the string
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
System.Configuration.AppSettingsReader settingsReader =
new AppSettingsReader();
//Get your key from config file to open the lock!
string key = (string)settingsReader.GetValue("SecurityKey",
typeof(String));
if (useHashing)
{
//if hashing was used get the hash code with regards to your key
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//release any resource held by the MD5CryptoServiceProvider
hashmd5.Clear();
}
else
{
//if hashing was not implemented get the byte code of the key
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//return the Clear decrypted TEXT
return UTF8Encoding.UTF8.GetString(resultArray);
}
/// <summary>
/// Triple DES decryption
/// </summary>
/// <param name="val">Value of decrypted</param>
/// <returns>Returns decrypted value as string<</returns>
public static string DecryptTripleDES(string val)
{
string decrtypted = "";
if (val != "") {
TripleDESCryptoServiceProvider cryptoProvider = new TripleDESCryptoServiceProvider();
//convert from string to byte
byte[] buffer = Convert.FromBase64String(val);
MemoryStream ms = new MemoryStream(buffer);
CryptoStream cs = new CryptoStream(ms, cryptoProvider.CreateDecryptor(KEY_192, IV_192), CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
decrtypted = sr.ReadToEnd();
}
return decrtypted;
}
/// <summary>
/// Triple Des DeEncrypt Operator Use IvKey
/// </summary>
/// <param name="encryptKey">Encrypt key can be null</param>
/// <param name="ivKey">Iv</param>
/// <param name="encryptBytes">EncryptBytes</param>
/// <returns>Return String </returns>
public static string TripleDesDeEncryptUseIvKey(byte[] encryptKey, byte[] ivKey, byte[] encryptBytes)
{
if (encryptBytes == null || encryptBytes.Length <= 0)
return string.Empty;
TripleDESCryptoServiceProvider tripleDesProvider = new TripleDESCryptoServiceProvider();
if (encryptKey == null)
encryptKey = IsolatedStorageCommon.IsolatedStorageSettingHelper.GetIsolateStorageByObj("EncryptKey") as byte[];
ICryptoTransform deEncryptTransform = tripleDesProvider.CreateDecryptor(encryptKey, ivKey);
var DecryptBytes = deEncryptTransform.TransformFinalBlock(encryptBytes, 0, encryptBytes.Length);
string unDecryptFomatStr = Encoding.UTF8.GetString(DecryptBytes, 0, DecryptBytes.Length);
return unDecryptFomatStr;
}
public string Decrypt(string key, string toDecrypt)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
return UTF8Encoding.UTF8.GetString(resultArray);
}
public static string DecryptTripleDES(string hash, string key, bool hashKey = true)
{
var keyArray = HexStringToByteArray(hashKey ? HashMD5(key) : key);
var toEncryptArray = HexStringToByteArray(hash);
var tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
var cTransform = tdes.CreateDecryptor();
var resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return Encoding.UTF8.GetString(resultArray);
}
public static string GiaiMa(string key, string toDecrypt)
{
try
{
byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
byte[] keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(key));
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray));
}
catch
{
return(string.Empty);
}
}
public static string DecryptStringFromBytes(byte[] cipherText)
{
// Check arguments.
if (cipherText == null || cipherText.Length <= 0)
{
throw new ArgumentNullException(nameof(cipherText));
}
// Declare the string used to hold
// the decrypted text.
string plaintext;
// Create an TripleDESCryptoServiceProvider object
// with the specified key and IV.
using (TripleDESCryptoServiceProvider tdsAlg = new TripleDESCryptoServiceProvider())
{
tdsAlg.Key = DesKey;
tdsAlg.IV = DesIv;
// Create a decrytor to perform the stream transform.
ICryptoTransform decryptor = tdsAlg.CreateDecryptor(tdsAlg.Key, tdsAlg.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);
}
public static string Descriptografa(string aDescriptografar)
{
byte[] arrayDeChave;
byte[] arrayADescriptografar = Convert.FromBase64String(aDescriptografar);
//Chave
//string chave = "l}=O4}80AR5X4";
string chave = Properties.Settings.Default.ChaveSeguranca;
//Criando HASH
MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();
arrayDeChave = hashMD5.ComputeHash(UTF8Encoding.UTF8.GetBytes(chave));
//Limpa o hashMD5
hashMD5.Clear();
TripleDESCryptoServiceProvider tDES = new TripleDESCryptoServiceProvider()
{
//Seta a chave secreta para o algoritimo tripleDES
Key = arrayDeChave,
//Modo de operação (Existem 4 outros modos)
//Escolheremos o ECB (Eletronic code Book)
Mode = CipherMode.ECB,
//Modo Padding (Se algum byte extra for adicionado)
Padding = PaddingMode.PKCS7
};
ICryptoTransform cTransform = tDES.CreateDecryptor();
//Transforma uma região especifica de bytes do array para o arrayResultado
byte[] arrayResultado = cTransform.TransformFinalBlock(arrayADescriptografar, 0, arrayADescriptografar.Length);
//Limpa o TDES
tDES.Clear();
//Retorna os dados encriptografados em uma string irreconhecivel
return(UTF8Encoding.UTF8.GetString(arrayResultado));
}
internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
{
ICryptoTransform iCryptoTransform;
switch (this.algorithmId)
{
case EncryptionAlgorithm.Des:
DES dES = new DESCryptoServiceProvider();
dES.Mode = CipherMode.CBC;
dES.Key = bytesKey;
dES.IV = initVec;
iCryptoTransform = dES.CreateDecryptor();
break;
case EncryptionAlgorithm.TripleDes:
TripleDES tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Mode = CipherMode.CBC;
iCryptoTransform = tripleDES.CreateDecryptor(bytesKey, initVec);
break;
case EncryptionAlgorithm.Rc2:
RC2 rC2 = new RC2CryptoServiceProvider();
rC2.Mode = CipherMode.CBC;
iCryptoTransform = rC2.CreateDecryptor(bytesKey, initVec);
break;
case EncryptionAlgorithm.Rijndael:
Rijndael rijndael = new RijndaelManaged();
rijndael.Mode = CipherMode.CBC;
iCryptoTransform = rijndael.CreateDecryptor(bytesKey, initVec);
break;
default:
throw new CryptographicException(String.Concat("Algorithm ID \'", this.algorithmId,
"\' not supported."));
}
return(iCryptoTransform);
}
public static string DecryptDES3(this string content, string key)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
DES.Key = ASCIIEncoding.ASCII.GetBytes(key);
DES.Mode = CipherMode.CBC;
DES.Padding = PaddingMode.PKCS7;
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
string result = "";
try
{
byte[] Buffer = Convert.FromBase64String(content);
result = ASCIIEncoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (Exception e)
{
}
return(result);
}
public static string Decrypt3DES(string a_strString, string a_strKey)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
DES.Key = ASCIIEncoding.ASCII.GetBytes(a_strKey);
DES.Mode = CipherMode.ECB;
DES.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
//DES.Padding = System.Security.Cryptography.PaddingMode.Zeros;
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
string result = "";
try
{
byte[] Buffer = GetBytes(a_strString);
result = ASCIIEncoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (Exception)
{
result = "";
}
return(result);
}
public byte[] DecryptUsingTripleDES(byte[] dataToDecrypt, byte[] key, byte[] initializationVector)
{
using (TripleDESCryptoServiceProvider tripleDesCryptoServiceProvider = new TripleDESCryptoServiceProvider())
{
tripleDesCryptoServiceProvider.Mode = CipherMode.CBC; // CBC = Cypher Block Chaining
tripleDesCryptoServiceProvider.Padding = PaddingMode.PKCS7;
tripleDesCryptoServiceProvider.Key = key;
tripleDesCryptoServiceProvider.IV = initializationVector;
using (MemoryStream memoryStream = new MemoryStream())
{
CryptoStream cryptoStream = new CryptoStream(memoryStream,
tripleDesCryptoServiceProvider.CreateDecryptor(),
CryptoStreamMode.Write);
cryptoStream.Write(dataToDecrypt, 0, dataToDecrypt.Length);
cryptoStream.FlushFinalBlock();
return(memoryStream.ToArray());
}
}
}
public static string Decrypt(string hash, string pass)
{
TripleDESCryptoServiceProvider decry = new TripleDESCryptoServiceProvider();
decry.IV = new byte[8];
PasswordDeriveBytes pdecry = new PasswordDeriveBytes(pass, new byte[0]);
decry.Key = pdecry.CryptDeriveKey("RC2", "MD5", 128, new byte[8]);
byte[] decrypedbytes = Convert.FromBase64String(hash);
MemoryStream ds = new MemoryStream(hash.Length);
CryptoStream decStream = new CryptoStream(ds, decry.CreateDecryptor(),
CryptoStreamMode.Write);
decStream.Write(decrypedbytes, 0, decrypedbytes.Length);
decStream.FlushFinalBlock();
byte[] decryptedBytes = new byte[ds.Length];
ds.Position = 0;
ds.Read(decryptedBytes, 0, (int)ds.Length);
decStream.Close();
return(Encoding.UTF8.GetString(decryptedBytes));
}
public byte[] Decrypt(byte[] data)
{
if (!ModeSignature.Equals("OFB"))
{
using var tdes = new TripleDESCryptoServiceProvider
{
Mode = AlgorithmUtility.GetCipherMode(ModeSignature)
};
using var decryptor = tdes.CreateDecryptor(Key, IV);
using var ms = new MemoryStream(data);
using var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
var decrypted = new byte[data.Length];
var bytesRead = cs.Read(decrypted, 0, data.Length);
return decrypted.Take(bytesRead).ToArray();
}
else
{
byte[] decrypted;
var tdes = CreateTripleDesCipher(false);
try
{
decrypted = new byte[tdes.GetOutputSize(data.Length)];
var len = tdes.ProcessBytes(data, 0, data.Length, decrypted, 0);
tdes.DoFinal(decrypted, len);
return decrypted;
}
catch (CryptoException)
{
}
}
return null;
}
/// <summary>
/// 3DES 解密
/// </summary>
/// <param name="content">内容</param>
/// <param name="secretKey">私钥</param>
/// <param name="ivs">向量</param>
/// <returns></returns>
public static string DESDecrypt(string content, string secretKey, string ivs)
{
SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();
mCSP.Mode = CipherMode.CBC;
mCSP.Padding = PaddingMode.PKCS7;
mCSP.Key = Encoding.UTF8.GetBytes(secretKey);
mCSP.IV = Encoding.UTF8.GetBytes(ivs);
ICryptoTransform ct;
MemoryStream ms;
CryptoStream cs;
byte[] byt;
ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV);
byt = Convert.FromBase64String(content);
ms = new MemoryStream();
cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
cs.Write(byt, 0, byt.Length);
cs.FlushFinalBlock();
cs.Close();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
public static string Decrypt(string toDecrypt, string salt)
{
String key = salt;
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
return(UTF8Encoding.UTF8.GetString(resultArray));
}
/// <summary>
///
/// </summary>
/// <param name="Message"></param>
/// <param name="Passphrase"></param>
/// <returns></returns>
public static string FromEncryptedString(string Message, string Passphrase)
{
byte[] Results;
var UTF8 = new UTF8Encoding();
// Step 1. We hash the passphrase using MD5
// We use the MD5 hash generator as the result is a 128 bit byte array
// which is a valid length for the TripleDES encoder we use below
var HashProvider = new MD5CryptoServiceProvider();
var TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
// Step 2. Create a new TripleDESCryptoServiceProvider object
var TDESAlgorithm = new TripleDESCryptoServiceProvider();
// Step 3. Setup the decoder
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Step 4. Convert the input string to a byte[]
var DataToDecrypt = Convert.FromBase64String(Message);
// Step 5. Attempt to decrypt the string
try
{
var Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
// Clear the TripleDes and Hashprovider services of any sensitive information
TDESAlgorithm.Clear();
HashProvider.Clear();
}
// Step 6. Return the decrypted string in UTF8 format
return(UTF8.GetString(Results));
}
public string DecryptData(string encryptedtext)
{
try
{
// Convert the encrypted text string to a byte array.
byte[] encryptedBytes = Convert.FromBase64String(encryptedtext);
// Create the stream.
System.IO.MemoryStream ms = new System.IO.MemoryStream();
// Create the decoder to write to the stream.
CryptoStream decStream = new CryptoStream(ms, TripleDes.CreateDecryptor(), CryptoStreamMode.Write);
// Use the crypto stream to write the byte array to the stream.
decStream.Write(encryptedBytes, 0, encryptedBytes.Length);
decStream.FlushFinalBlock();
// Convert the plaintext stream to a string.
return(System.Text.Encoding.Unicode.GetString(ms.ToArray()));
}
catch
{ return(null); }
}
public static string Decrypt(string cipherString, string key)
{
if (string.IsNullOrEmpty(cipherString))
{
return("");
}
byte[] keyArray;
//get the byte code of the string
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//if hashing was used get the hash code with regards to your key
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//release any resource held by the MD5CryptoServiceProvider
hashmd5.Clear();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//return the Clear decrypted TEXT
return(UTF8Encoding.UTF8.GetString(resultArray));
}
public static byte[] Decode(byte[] data, byte[] key, byte[] iv, DESCipherMode cipherMode, DESPaddingMode paddingMode)
{
try
{
var tdsp = new TripleDESCryptoServiceProvider
{
Mode = (CipherMode)cipherMode,
Padding = (PaddingMode)paddingMode,
};
using (var stream = new MemoryStream(data))
using (var crypto = new CryptoStream(stream, tdsp.CreateDecryptor(key, iv), CryptoStreamMode.Read))
{
var fromEncrypt = new byte[data.Length];
crypto.Read(fromEncrypt, 0, fromEncrypt.Length);
return(fromEncrypt);
}
}
catch
{
return(null);
}
}
private void button2_Click(object sender, EventArgs e)
{
if (MD5encrypt == true)
{
byte[] data = Convert.FromBase64String(textBox2.Text);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
using (TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider() { Key = keys, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 })
{
ICryptoTransform transform = tripleDes.CreateDecryptor();
byte[] results = transform.TransformFinalBlock(data, 0, data.Length);
textBox3.Text = UTF8Encoding.UTF8.GetString(results);
}
}
}
else
{
MessageBox.Show("Please decrypt using the same method");
}
}
public async Task <string> Descriptografar(string Message, string auxMessagem = null)
{
string v = await Task.Run(() =>
{
if (auxMessagem != Message || auxMessagem == null)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(senha));
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
byte[] DataToDecrypt = Convert.FromBase64String(Message);
try
{
ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return(UTF8.GetString(Results));
}
else
{
return(Message);
}
});
return(v);
}
private string Decrypt(string strEncrypted, string strKey)
{
try
{
TripleDESCryptoServiceProvider objDESCrypto = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider objHashMD5 = new MD5CryptoServiceProvider();
byte[] byteHash, byteBuff;
string strTempKey = strKey;
byteHash = objHashMD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(strTempKey));
objHashMD5 = null;
objDESCrypto.Key = byteHash;
objDESCrypto.Mode = CipherMode.ECB; //CBC, CFB
byteBuff = Convert.FromBase64String(strEncrypted);
string strDecrypted = ASCIIEncoding.ASCII.GetString(objDESCrypto.CreateDecryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length));
objDESCrypto = null;
return(strDecrypted);
}
catch (Exception ex)
{
return("Wrong Input. " + ex.Message);
}
}
/// <summary>
/// Decrypt the given string using the specified key.
/// </summary>
/// <param name="strEncrypted">The string to be decrypted.</param>
/// <param name="strKey">The decryption key.</param>
/// <returns>The decrypted string.</returns>
private static string Decrypt(string strEncrypted, string strKey)
{
try
{
var objDesCrypto = new TripleDESCryptoServiceProvider();
var objHashMd5 = new MD5CryptoServiceProvider();
var strTempKey = strKey;
var byteHash = objHashMd5.ComputeHash(Encoding.Default.GetBytes(strTempKey));
objDesCrypto.Key = byteHash;
objDesCrypto.Mode = CipherMode.ECB;
var byteBuff = Convert.FromBase64String(strEncrypted);
var strDecrypted = Encoding.Default.GetString(objDesCrypto.CreateDecryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length));
return(strDecrypted);
}
catch (Exception ex)
{
return("Wrong Input. " + ex.Message);
}
}
public string Decrypt(string messageToDecrypt)
{
byte[] buffer;
UTF8Encoding utf8 = new UTF8Encoding();
//Step 1. We hash the passphrase using MD5
//We use the MD5 hash generator as the result is a 128 bit byte array
//which is a valid length for the TripleDES encoder we use below
MD5CryptoServiceProvider hashProvider = new MD5CryptoServiceProvider();
byte[] tdesKey = hashProvider.ComputeHash(utf8.GetBytes(password));
TripleDESCryptoServiceProvider tdesAlgorithm = new TripleDESCryptoServiceProvider();
//Step 2. Setup the decoder
tdesAlgorithm.Key = tdesKey;
tdesAlgorithm.Mode = CipherMode.ECB;
tdesAlgorithm.Padding = PaddingMode.PKCS7;
//Step 3. Convert the input string to a byte[]
byte[] dataToDecrypt = Convert.FromBase64String(messageToDecrypt);
//Step 4. Attempt to decrypt the string
try
{
ICryptoTransform decryptor = tdesAlgorithm.CreateDecryptor();
buffer = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length);
}
finally
{
//Clear the TripleDes and Hashprovider services of any sensitive information
tdesAlgorithm.Clear();
hashProvider.Clear();
}
//Step 5. Return the decrypted string in UTF8 format
return(utf8.GetString(buffer));
}
private static string Decrypt(byte[] encrypted, string password, string salt)
{
DeriveBytes rgb = new Rfc2898DeriveBytes(password, Encoding.Unicode.GetBytes(salt), Iterations);
SymmetricAlgorithm algorithm = new TripleDESCryptoServiceProvider();
byte[] rgbKey = rgb.GetBytes(algorithm.KeySize / 8);
byte[] rgbIV = rgb.GetBytes(algorithm.BlockSize / 8);
ICryptoTransform transform = algorithm.CreateDecryptor(rgbKey, rgbIV);
using (var memoryStream = new MemoryStream(encrypted))
{
using (var cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Read))
{
using (var reader = new StreamReader(cryptoStream, Encoding.Unicode))
{
return reader.ReadToEnd();
}
}
}
}
public static StreamReader DecryptFile(string fromFileNamePath, string keyFileNamePath)
{
// The encrypted file
var fsFileIn = File.OpenRead(fromFileNamePath);
// The key
var fsKeyFile = File.OpenRead(keyFileNamePath);
// Prepare the encryption algorithm and read the key from the key file
var cryptAlgorithm = new TripleDESCryptoServiceProvider();
var brFile = new BinaryReader(fsKeyFile);
cryptAlgorithm.Key = brFile.ReadBytes(24);
cryptAlgorithm.IV = brFile.ReadBytes(8);
// The cryptographic stream takes in the unecrypted file
var csEncrypt = new CryptoStream(fsFileIn, cryptAlgorithm.CreateDecryptor(), CryptoStreamMode.Read);
// Write the new unecrypted file
var srCleanStream = new StreamReader(csEncrypt);
return(srCleanStream);
}
/// <summary>
/// Decrypt using triple DES
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
internal static string DecryptData(string encryptedtext, string key)
{
TripleDESCryptoServiceProvider TripleDes = new TripleDESCryptoServiceProvider();
TripleDes.Key = TruncateHash(key, TripleDes.KeySize / 8);
TripleDes.IV = TruncateHash("", TripleDes.BlockSize / 8);
// Convert the encrypted text string to a byte array.
byte[] encryptedBytes = Convert.FromBase64String(encryptedtext);
// Create the stream.
System.IO.MemoryStream ms = new System.IO.MemoryStream();
// Create the decoder to write to the stream.
CryptoStream decStream = new CryptoStream(ms, TripleDes.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write);
// Use the crypto stream to write the byte array to the stream.
decStream.Write(encryptedBytes, 0, encryptedBytes.Length);
decStream.FlushFinalBlock();
// Convert the plaintext stream to a string.
return(System.Text.Encoding.Unicode.GetString(ms.ToArray()));
}
public static string Decrypt(string cipherString)
{
byte[] keyArray;
//get the byte code of the string
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
//System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
////Get your key from config file to open the lock!
//string key = (string)settingsReader.GetValue("SecurityKey", typeof(String));
string key = "doozestanBond1395";
//if hashing was not implemented get the byte code of the key
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.KeySize = 192;
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock
(toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//return the Clear decrypted TEXT
return(UTF8Encoding.UTF8.GetString(resultArray));
}
public static string DecriptarDatos(string dato)
{
byte[] keyArray;
byte[] decriptar = Convert.FromBase64String(dato);
keyArray = Encoding.UTF8.GetBytes(llave);
var tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultado = cTransform.TransformFinalBlock(decriptar, 0, decriptar.Length);
tdes.Clear();
string datosDecriptados = Encoding.UTF8.GetString(resultado);
return(datosDecriptados);
}
/// <summary>
/// Método para desencriptar un texto
/// </summary>
/// <param name="pStrEncoded">
/// Texto encriptado
/// </param>
/// <param name="pStrKey">
/// Contraseña
/// </param>
/// <returns>
/// Texto desencriptado
/// </returns>
public static string Decode(string pStrEncoded, string pStrKey)
{
//arreglo de bytes donde guardaremos la llave
byte[] keyArray;
//convierte el texto en una secuencia de bytes
byte[] Array_a_Descifrar =
Convert.FromBase64String(pStrEncoded);
//se llama a las clases que tienen los algoritmos
//de encriptación se le aplica hashing
//algoritmo MD5
MD5CryptoServiceProvider hashmd5 =
new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(
UTF8Encoding.UTF8.GetBytes(pStrKey));
hashmd5.Clear();
TripleDESCryptoServiceProvider tdes =
new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform =
tdes.CreateDecryptor();
byte[] resultArray =
cTransform.TransformFinalBlock(Array_a_Descifrar,
0, Array_a_Descifrar.Length);
tdes.Clear();
//Se regresa en forma de cadena
return(UTF8Encoding.UTF8.GetString(resultArray));
}
public static string DES3Decrypt(string data, string key)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
DES.Key = Encoding.ASCII.GetBytes(key);
DES.Mode = CipherMode.CBC;
DES.Padding = System.Security.Cryptography.PaddingMode.PKCS7;
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
string result = "";
try
{
byte[] Buffer = Convert.FromBase64String(data);
result = Encoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (Exception e)
{
}
return(result);
}
/// <summary>
/// Decrypts a Byte array from DES with an Encryption Key.
/// </summary>
/// <param name="DecryptBuffer"></param>
/// <param name="EncryptionKey"></param>
/// <returns></returns>
public static byte[] DecryptBytes(byte[] DecryptBuffer, string EncryptionKey)
{
if (DecryptBuffer == null || DecryptBuffer.Length == 0)
{
return(null);
}
if (EncryptionKey == null)
{
EncryptionKey = Key;
}
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
des.Key = hashmd5.ComputeHash(Encoding.ASCII.GetBytes(EncryptionKey));
des.Mode = CipherMode.ECB;
ICryptoTransform Transform = des.CreateDecryptor();
return(Transform.TransformFinalBlock(DecryptBuffer, 0, DecryptBuffer.Length));
}
/// <summary>
/// DES3 解密
/// </summary>
public static string UnDes3(this string source, string keyVal)
{
byte[] byArray = source.Str2Bytes();
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider
{
Key = keyVal.FormatByte(Encoding.UTF8),
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
using (MemoryStream ms = new MemoryStream())
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
{
cs.Write(byArray, 0, byArray.Length);
cs.FlushFinalBlock();
cs.Close();
ms.Close();
return(Encoding.UTF8.GetString(ms.ToArray()));
}
}
}
public static string Desencriptar(string cadenaEncriptada)
{
string key = "fon";
byte[] keyArray;
byte[] arrDescifrar = Convert.FromBase64String(cadenaEncriptada);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(arrDescifrar, 0, arrDescifrar.Length);
tdes.Clear();
return(UTF8Encoding.UTF8.GetString(resultArray));
}
public static string DecryptString(string Message, string passphrase)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(passphrase));
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
byte[] DataToDecrypt = Convert.FromBase64String(Message);
try
{
ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return UTF8.GetString(Results);
}
public static string GetString(string key)
{
// Hide '_key' string.
MD5 md5Hash = MD5.Create();
byte[] hashData = md5Hash.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);
byte[] bytes = Convert.FromBase64String(_value);
// Decrypt '_value' with 3DES.
TripleDES des = new TripleDESCryptoServiceProvider();
des.Key = secret;
des.Mode = CipherMode.ECB;
ICryptoTransform xform = des.CreateDecryptor();
byte[] decrypted = xform.TransformFinalBlock(bytes, 0, bytes.Length);
// decrypte_value as a proper string.
string decryptedString = System.Text.Encoding.UTF8.GetString(decrypted);
return decryptedString;
}
/// <summary>
/// 3des解密字符串
/// </summary>
/// <param name="a_strString">要解密的字符串</param>
/// <param name="a_strKey">密钥</param>
/// <param name="encoding">编码方式</param>
/// <returns>解密后的字符串</returns>
/// <exception cref="">密钥错误</exception>
/// <remarks>静态方法，指定编码方式</remarks>
public string Decrypt3DES(string a_strString, string a_strKey, Encoding encoding)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();
DES.Key = hashMD5.ComputeHash(encoding.GetBytes(a_strKey));
DES.Mode = CipherMode.ECB;
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
string result = "";
try {
byte[] Buffer = Convert.FromBase64String(a_strString);
result = encoding.GetString(DESDecrypt.TransformFinalBlock
(Buffer, 0, Buffer.Length));
} catch (Exception e) {
#if DEBUG
Console.WriteLine("错误：{0}" , e) ;
#endif//DEBUG
throw (new Exception("不是有效的 base64 字符串", e));
}
return result;
}
/// <summary>
/// Decrypts a Byte array from DES with an Encryption Key.
/// </summary>
/// <param name="DecryptBuffer"></param>
/// <param name="EncryptionKey"></param>
/// <returns></returns>
public static byte[] DecryptBytes(byte[] DecryptBuffer, string EncryptionKey)
{
if (DecryptBuffer == null || DecryptBuffer.Length == 0)
return null;
if (EncryptionKey == null)
EncryptionKey = strKey;
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
des.Key = hashmd5.ComputeHash(Encoding.ASCII.GetBytes(EncryptionKey));
des.Mode = CipherMode.ECB;
ICryptoTransform Transform = des.CreateDecryptor();
return Transform.TransformFinalBlock(DecryptBuffer, 0, DecryptBuffer.Length);
}
/// <summary>
/// TripleDES����
/// </summary>
public static string TripleDESDecrypting(string Source)
{
try
{
byte[] bytIn = System.Convert.FromBase64String(Source);
byte[] key = { 42, 16, 93, 156, 78, 4, 218, 32, 15, 167, 44, 80, 26, 20, 155, 112, 2, 94, 11, 204, 119, 35, 184, 197 }; //������Կ
byte[] IV = { 55, 103, 246, 79, 36, 99, 167, 3 }; //����ƫ����
TripleDESCryptoServiceProvider TripleDES = new TripleDESCryptoServiceProvider();
TripleDES.IV = IV;
TripleDES.Key = key;
ICryptoTransform encrypto = TripleDES.CreateDecryptor();
System.IO.MemoryStream ms = new System.IO.MemoryStream(bytIn, 0, bytIn.Length);
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader strd = new StreamReader(cs, Encoding.Default);
return strd.ReadToEnd();
}
catch (Exception ex)
{
throw new Exception("����ʱ����ִ���!������ʾ:\n" + ex.Message);
}
}
public static string Decrypt(string cipherString, bool useHashing)
{
byte[] keyArray;
//get the byte code of the string
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
string key = ConfigurationManager.AppSettings["EncryptKey"];
if (useHashing)
{
//if hashing was used get the hash code with regards to your key
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//release any resource held by the MD5CryptoServiceProvider
hashmd5.Clear();
}
else
{
//if hashing was not implemented get the byte code of the key
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//return the Clear decrypted TEXT
return UTF8Encoding.UTF8.GetString(resultArray);
}
public String decrypt(String strText)
{
ASCIIEncoding textConverter = new ASCIIEncoding();
string roundtrip;
byte[] fromEncrypt;
byte[] encrypted;
//Encrypt the data.
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
ICryptoTransform decryptor = tdes.CreateDecryptor(encKey, initVec);
int discarded;
encrypted = HexEncoding.GetBytes(strText, out discarded);
//Now decrypt the previously encrypted message using the decryptor
// obtained in the above step.
MemoryStream msDecrypt = new MemoryStream(encrypted);
CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);
fromEncrypt = new byte[encrypted.Length];
//Read the data out of the crypto stream.
csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length);
//Convert the byte array back into a string.
roundtrip = textConverter.GetString(fromEncrypt);
return (roundtrip.Replace("\0", ""));
}
public static string Decrypt(string data)
{
byte[] z = new byte[(data.Length / 3)];
for (int i = 0; i <= (data.Length / 3) - 1; i++)
{
z[i] = Convert.ToByte(data.Substring(i * 3, 3));
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = Key;
tdes.IV = IV;
ICryptoTransform decryptor = tdes.CreateDecryptor();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write);
cs.Write(z, 0, z.Length);
cs.FlushFinalBlock();
ms.Position = 0;
byte[] result = new byte[ms.Length];
ms.Read(result, 0, int.Parse(ms.Length.ToString()));
cs.Close();
#region Replace Words
string dataArray = ASCIIEncoding.UTF7.GetString(result);
// data = "";
if (dataArray.Contains("a11d"))
{
dataArray = dataArray.Replace("a11d", "A");
}
if (dataArray.Contains("l22k"))
{
dataArray = dataArray.Replace("l22k", "B");
}
if (dataArray.Contains("o33i"))
{
dataArray = dataArray.Replace("o33i", "C");
}
if (dataArray.Contains("t44r"))
{
dataArray = dataArray.Replace("t44r", "D");
}
if (dataArray.Contains("r55e"))
{
dataArray = dataArray.Replace("r55e", "E");
}
if (dataArray.Contains("u66y"))
{
dataArray = dataArray.Replace("u66y", "F");
}
if (dataArray.Contains("r77e"))
{
dataArray = dataArray.Replace("r77e", "G");
}
if (dataArray.Contains("d88s"))
{
dataArray = dataArray.Replace("d88s", "H");
}
if (dataArray.Contains("t99t"))
{
dataArray = dataArray.Replace("t99t", "I");
}
if (dataArray.Contains("e101w"))
{
dataArray = dataArray.Replace("e101w", "J");
}
if (dataArray.Contains("p111o"))
{
dataArray = dataArray.Replace("p111o", "K");
}
if (dataArray.Contains("y121t"))
{
dataArray = dataArray.Replace("y121t", "L");
}
if (dataArray.Contains("v131c"))
{
dataArray = dataArray.Replace("v131c", "M");
}
if (dataArray.Contains("t141r"))
{
dataArray = dataArray.Replace("t141r", "N");
}
if (dataArray.Contains("l151k"))
{
dataArray = dataArray.Replace("l151k", "O");
}
if (dataArray.Contains("t161r"))
{
dataArray = dataArray.Replace("t161r", "P");
}
if (dataArray.Contains("e171w"))
{
dataArray = dataArray.Replace("e171w", "Q");
}
if (dataArray.Contains("f181d"))
{
dataArray = dataArray.Replace("f181d", "R");
}
if (dataArray.Contains("b191v"))
{
dataArray = dataArray.Replace("b191v", "S");
}
if (dataArray.Contains("n202b"))
{
dataArray = dataArray.Replace("n202b", "T");
}
if (dataArray.Contains("m212n"))
{
dataArray = dataArray.Replace("m212n", "U");
}
if (dataArray.Contains("h222g"))
{
dataArray = dataArray.Replace("h222g", "V");
}
if (dataArray.Contains("f232d"))
{
dataArray = dataArray.Replace("f232d", "W");
}
if (dataArray.Contains("r242e"))
{
dataArray = dataArray.Replace("r242e", "X");
}
if (dataArray.Contains("y252t"))
{
dataArray = dataArray.Replace("y252t", "Y");
}
if (dataArray.Contains("w262q"))
{
dataArray = dataArray.Replace("w262q", "Z");
}
#endregion
return dataArray;
}
public static string Decrypt(string data)
{
byte[] z = new byte[(data.Length / 3)];
for ( int i = 0; i <= (data.Length / 3) - 1; i++)
{
z[i] = Convert.ToByte(data.Substring(i * 3, 3));
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = Key;
tdes.IV = IV;
ICryptoTransform decryptor = tdes.CreateDecryptor();
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write);
cs.Write(z, 0, z.Length);
cs.FlushFinalBlock();
ms.Position = 0;
byte[] result = new byte[ms.Length];
ms.Read(result, 0, int.Parse(ms.Length.ToString()));
cs.Close();
#region Replace Words
string dataArray = ASCIIEncoding.UTF7.GetString(result);
// data = "";
if (dataArray.Contains("a11d") || dataArray.Contains("a11s") || dataArray.Contains("a11m"))
{
dataArray = dataArray.Replace("a11d", "ا");
dataArray = dataArray.Replace("a11s", "أ");
dataArray = dataArray.Replace("a11m", "إ");
}
if (dataArray.Contains("l22k"))
{
dataArray = dataArray.Replace("l22k", "ب");
}
if (dataArray.Contains("o33i"))
{
dataArray = dataArray.Replace("o33i", "ت");
}
if (dataArray.Contains("t44r"))
{
dataArray = dataArray.Replace("t44r", "ث");
}
if (dataArray.Contains("r55e"))
{
dataArray = dataArray.Replace("r55e", "ج");
}
if (dataArray.Contains("u66y"))
{
dataArray = dataArray.Replace("u66y", "ح");
}
if (dataArray.Contains("r77e"))
{
dataArray = dataArray.Replace("r77e", "خ");
}
if (dataArray.Contains("d88s"))
{
dataArray = dataArray.Replace("d88s", "د");
}
if (dataArray.Contains("t99t"))
{
dataArray = dataArray.Replace("t99t", "ذ");
}
if (dataArray.Contains("e101w"))
{
dataArray = dataArray.Replace("e101w", "ر");
}
if (dataArray.Contains("p111o"))
{
dataArray = dataArray.Replace("p111o", "ز");
}
if (dataArray.Contains("y121t"))
{
dataArray = dataArray.Replace("y121t", "س");
}
if (dataArray.Contains("v131c"))
{
dataArray = dataArray.Replace("v131c", "ش");
}
if (dataArray.Contains("t141r"))
{
dataArray = dataArray.Replace("t141r", "ص");
}
if (dataArray.Contains("l151k"))
{
dataArray = dataArray.Replace("l151k", "ض");
}
if (dataArray.Contains("t161r"))
{
dataArray = dataArray.Replace("t161r", "ط");
}
if (dataArray.Contains("e171w"))
{
dataArray = dataArray.Replace("e171w", "ظ");
}
if (dataArray.Contains("f181d"))
{
dataArray = dataArray.Replace("f181d", "ع");
}
if (dataArray.Contains("b191v"))
{
dataArray = dataArray.Replace("b191v", "غ");
}
if (dataArray.Contains("n202b"))
{
dataArray = dataArray.Replace("n202b", "ف");
}
if (dataArray.Contains("m212n"))
{
dataArray = dataArray.Replace("m212n", "ق");
}
if (dataArray.Contains("h222g"))
{
dataArray = dataArray.Replace("h222g", "ك");
}
if (dataArray.Contains("f232d"))
{
dataArray = dataArray.Replace("f232d", "ل");
}
if (dataArray.Contains("r242e"))
{
dataArray = dataArray.Replace("r242e", "م");
}
if (dataArray.Contains("y252t"))
{
dataArray = dataArray.Replace("y252t", "ن");
}
if (dataArray.Contains("w262q"))
{
dataArray = dataArray.Replace("w262q", "ه");
}
if (dataArray.Contains("p272o"))
{
dataArray = dataArray.Replace("p272o", "و");
}
if (dataArray.Contains("p282o") || dataArray.Contains("p282u"))
{
dataArray = dataArray.Replace("p282o", "ي");
dataArray = dataArray.Replace("p282u", "ى");
}
#endregion
return dataArray;
}
public string Decrypt(string SrcStr)
{
string decrypted;
TripleDESCryptoServiceProvider des;
MD5CryptoServiceProvider hashmd5;
byte[] pwdhash, buff;
//generate an MD5 hash from the m_Password.
//a hash is a one way encryption meaning once you generate
//the hash, you cant derive the m_Password back from it.
hashmd5 = new MD5CryptoServiceProvider();
pwdhash = hashmd5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(m_Password));
hashmd5 = null;
//implement DES3 encryption
des = new TripleDESCryptoServiceProvider();
//the key is the secret m_Password hash.
des.Key = pwdhash;
//the mode is the block cipher mode which is basically the
//details of how the encryption will work. There are several
//kinds of ciphers available in DES3 and they all have benefits
//and drawbacks. Here the Electronic Codebook cipher is used
//which means that a given bit of text is always encrypted
//exactly the same when the same m_Password is used.
des.Mode = CipherMode.ECB; //CBC, CFB
//----- encrypt an un-encrypted string ------------
//the SrcStr string, which needs encrypted, must be in byte
//array form to work with the des3 class. everything will because
//most encryption works at the byte level so you'll find that
//the class takes in byte arrays and returns byte arrays and
//you'll be converting those arrays to strings.
buff = ASCIIEncoding.ASCII.GetBytes(SrcStr);
//----- decrypt an encrypted string ------------
//whenever you decrypt a string, you must do everything you
//did to encrypt the string, but in reverse order. To encrypt,
//first a normal string was des3 encrypted into a byte array
//and then base64 encoded for reliable transmission. So, to
//decrypt this string, first the base64 encoded string must be
//decoded so that just the encrypted byte array remains.
buff = Convert.FromBase64String(SrcStr);
//decrypt DES 3 encrypted byte buffer and return ASCII string
decrypted = ASCIIEncoding.ASCII.GetString(des.CreateDecryptor().TransformFinalBlock(buff, 0, buff.Length));
//cleanup
des = null;
return decrypted;
}
/////////////////////////////////////////////////////////////
#region Debug Operations
#if DEBUG
#if !SILVERLIGHT
private static void MicrosoftDESEncrypt(byte[] bufferIn, ref byte[] bufferOut, byte[] Key, bool bEncrypt, bool bDESMode)
{
// Declaration of key and IV
byte[] bufferTemp = new byte[1024];
byte[] IV;
if(bDESMode)
IV = new byte[8];
else
IV = new byte[8*3];
// Declare a crypto object
ICryptoTransform crypto;
if (bDESMode)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Padding = PaddingMode.PKCS7;
if (bEncrypt)
crypto = des.CreateEncryptor(Key, IV);
else
crypto = des.CreateDecryptor(Key, IV);
}
else
{
TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider();
tripleDes.Padding = PaddingMode.PKCS7;
if (bEncrypt)
crypto = tripleDes.CreateEncryptor(Key, IV);
else
crypto = tripleDes.CreateDecryptor(Key, IV);
}
// a memory stream for the cyrpto
using(MemoryStream ms = new MemoryStream())
{
// Create a CryptoStream using the memory stream
using (CryptoStream encStream = new CryptoStream(ms, crypto, CryptoStreamMode.Write))
{
// Encrypt/decrypt and flush
encStream.Write(bufferIn, 0, bufferIn.Length);
encStream.Flush();
encStream.FlushFinalBlock();
encStream.Close();
// Get the data into a buffer
bufferOut = ms.ToArray();
}
}
}
/// <summary>
/// Método responsável por Decriptografar um valor passado como parâmetro
/// </summary>
/// <param name="str">Valor a ser Decriptografado</param>
/// <returns>Valor Decriptografado</returns>
public static string Decriptografar(string str)
{
if (!string.IsNullOrEmpty(str))
{
CryptoStream fluxoCriptografia = null;
MemoryStream fluxoMemoria = null;
try
{
// Vetor de bytes com a string informada
byte[] valor = Convert.FromBase64String(str);
//Crio um algoritimo simétrico utilizando a implementação TripleDESCryptoServiceProvider
SymmetricAlgorithm algoritmoSimetrico = new TripleDESCryptoServiceProvider();
// Substituo o membro CreateDecryptor da classe SymmetricAlgorithm
ICryptoTransform ct = algoritmoSimetrico.CreateDecryptor(chave, iv);
fluxoMemoria = new MemoryStream();
fluxoCriptografia = new CryptoStream(fluxoMemoria, ct, CryptoStreamMode.Write);
fluxoCriptografia.Write(valor, 0, valor.Length);
fluxoCriptografia.FlushFinalBlock();
fluxoCriptografia.Close();
}
catch
{
if (fluxoCriptografia != null) { fluxoCriptografia.Close(); }
}
// Retorno o valor decriptografado
if (fluxoMemoria != null)
{
return Encoding.UTF8.GetString(fluxoMemoria.ToArray());
}
else
{
// Retorno uma string vazia
return string.Empty;
}
}
else
{
// Retorno uma string vazia
return string.Empty;
}
}
