public static void TripleDESRoundTrip192BitsNoneCBC()
{
byte[] key = "b43eaf0260813fb47c87ae073a146006d359ad04061eb0e6".HexToByteArray();
byte[] iv = "5fbc5bc21b8597d8".HexToByteArray();
using (var alg = new TripleDESCryptoServiceProvider())
{
alg.Key = key;
alg.IV = iv;
alg.Padding = PaddingMode.None;
alg.Mode = CipherMode.CBC;
byte[] plainText = "79a86903608e133e020e1dc68c9835250c2f17b0ebeed91b".HexToByteArray();
byte[] cipher = alg.Encrypt(plainText);
byte[] expectedCipher = "dea36279600f19c602b6ed9bf3ffdac5ebf25c1c470eb61c".HexToByteArray();
Assert.Equal<byte>(expectedCipher, cipher);
byte[] decrypted = alg.Decrypt(cipher);
byte[] expectedDecrypted = "79a86903608e133e020e1dc68c9835250c2f17b0ebeed91b".HexToByteArray();
Assert.Equal<byte>(expectedDecrypted, decrypted);
}
}
public string Encrypt(string ToEncrypt, bool useHasing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(ToEncrypt);
string Key = "malkit";
if (useHasing)
{
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.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tDes.Clear();
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
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 Encrypt(string toEncrypt, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
// Get the key from config file
string key = (string)settingsReader.GetValue("SecurityKey", typeof(String));
//System.Windows.Forms.MessageBox.Show(key);
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.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
//md5 encrypt
public static string MD5Encrypt(string toEncrypt, string securityKey, bool useHashing)
{
string retVal = string.Empty;
try {
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes (toEncrypt);
ValidateInput (toEncrypt);
ValidateInput (securityKey);
if (useHashing) {
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider ();
keyArray = hashmd5.ComputeHash (UTF8Encoding.UTF8.GetBytes (securityKey));
hashmd5.Clear ();
} else {
keyArray = UTF8Encoding.UTF8.GetBytes (securityKey);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider ();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor ();
byte[] resultArray = cTransform.TransformFinalBlock (toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear ();
retVal = Convert.ToBase64String (resultArray, 0, resultArray.Length);
} catch (Exception ex) {
Debug.Log (ex.Message);
}
return retVal;
}
public static byte[] Get3DesSignatureInBytes(byte[] data, byte[] sharedSecret)
{
HashAlgorithm hash = new SHA1Managed();
byte[] hashedData = hash.ComputeHash(data);
byte[] decryptedSignature = new byte[24];
for (int i = 0; i < hashedData.Length; i++)
{
decryptedSignature[i] = hashedData[i];
}
for (int i = 20; i < decryptedSignature.Length; i++)
{
decryptedSignature[i] = (byte)0xFF;
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = sharedSecret;
byte[] iv = new byte[8];
for (int i = 0; i < iv.Length; i++)
{
iv[i] = (byte)0x00;
}
tdes.IV = iv;
tdes.Mode = CipherMode.CBC;
ICryptoTransform transform = tdes.CreateEncryptor();
byte[] signature = new byte[24];
transform.TransformBlock(decryptedSignature, 0, decryptedSignature.Length, signature, 0);
return signature;
}
/// <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 Encrypt(string plainText )
{
string encrypted = null;
try
{
byte[] inputBytes = ASCIIEncoding.ASCII.GetBytes(plainText);
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;
byte [] edata = tdesProvider.CreateEncryptor().TransformFinalBlock(inputBytes, 0, inputBytes.Length);
encrypted = Convert.ToBase64String( edata );
}
catch(Exception e)
{
string str = e.Message;
throw ;
}
return encrypted;
}
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);
}
public static void TestShims()
{
using (var alg = new TripleDESCryptoServiceProvider())
{
alg.BlockSize = 64;
Assert.Equal(64, alg.BlockSize);
var emptyIV = new byte[8];
alg.IV = emptyIV;
Assert.Equal(emptyIV, alg.IV);
alg.GenerateIV();
Assert.NotEqual(emptyIV, alg.IV);
alg.KeySize = 64 * 3;
Assert.Equal(64 * 3, alg.KeySize);
var knownKey = new byte[]
{
/* k1 */ 0, 1, 2, 3, 4, 5, 6, 7,
/* k2 */ 0, 0, 0, 2, 4, 6, 0, 1,
/* k3 */ 0, 1, 2, 3, 4, 5, 6, 7,
};
alg.Key = knownKey;
Assert.Equal(knownKey, alg.Key);
alg.GenerateKey();
Assert.NotEqual(knownKey, alg.Key);
alg.Mode = CipherMode.ECB;
Assert.Equal(CipherMode.ECB, alg.Mode);
alg.Padding = PaddingMode.PKCS7;
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
}
public static string DecryptString(string input, string cryptographicProvider_PublicKey, string cryptographicProvider_IV)
{
try
{
input = input.Replace(CryptographicProviderKey, String.Empty);
using (var dataString = new MemoryStream())
{
var service = new TripleDESCryptoServiceProvider().CreateDecryptor(Encoding.UTF8.GetBytes(cryptographicProvider_PublicKey),
Encoding.UTF8.GetBytes(cryptographicProvider_IV));
using (var cryptoStream = new CryptoStream(dataString, service, CryptoStreamMode.Write))
{
var inputData = Convert.FromBase64String(input);
cryptoStream.Write(inputData, 0, inputData.Length);
cryptoStream.FlushFinalBlock();
var dataResult = dataString.ToArray();
var resultString = Encoding.UTF8.GetString(Convert.FromBase64String(Convert.ToBase64String(dataResult)));
cryptoStream.Close();
return resultString;
}
}
}
catch (Exception e)
{
return e.ToString();
}
}
/// <summary>
/// 使用给定密钥加密
/// </summary>
/// <param name="original">明文</param>
/// <param name="key">密钥</param>
/// <returns>密文</returns>
public static byte[] Encrypt(byte[] original, byte[] key)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = MakeMD5(key);
des.Mode = CipherMode.ECB;
return des.CreateEncryptor().TransformFinalBlock(original, 0, original.Length);
}
/// <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 void VerifyDefaults()
{
using (var alg = new TripleDESCryptoServiceProvider())
{
Assert.Equal(64, alg.BlockSize);
Assert.Equal(192, alg.KeySize);
Assert.Equal(CipherMode.CBC, alg.Mode);
Assert.Equal(PaddingMode.PKCS7, alg.Padding);
}
}
public static string Encrypt(string input, string key)
{
byte[] inputArray = UTF8Encoding.UTF8.GetBytes(input);
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Key = UTF8Encoding.UTF8.GetBytes(key);
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tripleDES.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
tripleDES.Clear();
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
/// <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);
}
public string Encrypt(string key, string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
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.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
/// <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;
}
/// <summary>
/// Encodes a stream of bytes using DES encryption with a pass key. Lowest level method that
/// handles all work.
/// </summary>
/// <param name="InputString"></param>
/// <param name="EncryptionKey"></param>
/// <returns></returns>
public static byte[] EncryptBytes(byte[] InputString, string EncryptionKey)
{
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.CreateEncryptor();
byte[] Buffer = InputString;
return Transform.TransformFinalBlock(Buffer, 0, Buffer.Length);
}
public string Encrypt(string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.BigEndianUnicode.GetBytes(toEncrypt);
bool useHashing = false;
//System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
// Get the key from config file
//string key = (string)settingsReader.GetValue("SecurityKey", typeof(String));
string key = "MPcrypto";
//System.Windows.Forms.MessageBox.Show(key);
//If hashing use get hashcode regards to your key
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.BigEndianUnicode.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.BigEndianUnicode.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.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resultArray =
cTransform.TransformFinalBlock(toEncryptArray, 0,
toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//Return the encrypted data into unreadable string format
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
/// <summary>
/// TripleDes Data Encrypt Use IVKey Operator
/// </summary>
/// <param name="sourceContent">Source Content</param>
/// <param name="encryptKey">Encrypt Key</param>
/// <returns>Encrypt Bytes Array</returns>
public static byte[] TripleDesEncryptUseIvKey(string sourceContent, byte[] encryptIVKey)
{
if (string.IsNullOrEmpty(sourceContent) || encryptIVKey == null || encryptIVKey.Length <= 0)
return null;
var toEncryptSourceStr = Encoding.UTF8.GetBytes(sourceContent);
TripleDESCryptoServiceProvider tripleDesProvider = new TripleDESCryptoServiceProvider();
//No Seting Pading
var key = tripleDesProvider.Key; //Save Key
IsolatedStorageCommon.IsolatedStorageSettingHelper.AddIsolateStorageObj("EncryptKey", key);
ICryptoTransform encryptTransform = tripleDesProvider.CreateEncryptor(key, encryptIVKey);
var encryptBytes = encryptTransform.TransformFinalBlock(toEncryptSourceStr, 0, toEncryptSourceStr.Length);
return encryptBytes;
}
public static string EncryptTripleDES(string phrase, string key, bool hashKey = true)
{
var keyArray = HexStringToByteArray(hashKey ? HashMD5(key) : key);
var toEncryptArray = Encoding.UTF8.GetBytes(phrase);
var tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
var cTransform = tdes.CreateEncryptor();
var resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return ByteArrayToHexString(resultArray);
}
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;
}
public static string EncryptData(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[] DataToEncrypt = UTF8.GetBytes(Message);
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return Convert.ToBase64String(Results);
}
public static string DecryptStringWith3DES(string data, string key, string iv)
{
UnicodeEncoding unicode = new UnicodeEncoding();
Byte[] Bytes = Convert.FromBase64String(data);
MemoryStream mem = new MemoryStream(100);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
Byte[] KeyBytes = unicode.GetBytes(key);
Byte[] tmpBytes = new Byte[16];
Array.Copy(KeyBytes, tmpBytes, KeyBytes.Length < 16 ? KeyBytes.Length : 16);
KeyBytes = tmpBytes;
if (tdes.ValidKeySize(KeyBytes.Length * 8))
{
System.Diagnostics.Debug.WriteLine("Key size valid");
}
if (TripleDESCryptoServiceProvider.IsWeakKey(KeyBytes))
{
System.Diagnostics.Debug.WriteLine("Key weak");
}
CryptoStream CrStream = new CryptoStream(mem, tdes.CreateDecryptor(KeyBytes, unicode.GetBytes(iv)), CryptoStreamMode.Write);
for (int i = 0; i < Bytes.Length; i++)
{
CrStream.WriteByte(Bytes[i]);
}
CrStream.FlushFinalBlock();
string result = unicode.GetString(mem.GetBuffer(), 0, (int)mem.Length);
CrStream.Dispose();
return(result);
}
//Ma hoa dung HashMD5 và TripleDES
public string Encrypt(string i_strEncrypt, bool i_blUseHashing)
{
byte[] v_arrKey;
byte[] v_arrEncrypt = new byte[(int)i_strEncrypt.Length];
try
{
v_arrEncrypt = UTF8Encoding.UTF8.GetBytes(i_strEncrypt);
}
catch (Exception v_ex)
{
throw v_ex;
}
string v_strKey = "fatherofbill";
if (i_blUseHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
v_arrKey = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(v_strKey));
hashmd5.Clear();
}
else
{
v_arrKey = UTF8Encoding.UTF8.GetBytes(v_strKey);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = v_arrKey;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(v_arrEncrypt, 0, v_arrEncrypt.Length);
tdes.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/// <summary>
/// Encrypt the given string using the specified key.
/// </summary>
/// <param name="strToEncrypt">The string to be encrypted.</param>
/// <param name="strKey">The encryption key.</param>
/// <returns>The encrypted string.</returns>
public static string Encrypt(string strToEncrypt)
{
try
{
TripleDESCryptoServiceProvider objDESCrypto = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider objHashMD5 = new MD5CryptoServiceProvider();
byte[] byteHash, byteBuff;
string strTempKey = Vaukey;
byteHash = objHashMD5.ComputeHash(ASCIIEncoding.UTF8.GetBytes(strTempKey));
objHashMD5 = null;
objDESCrypto.Key = byteHash;
// CBC, CFB
objDESCrypto.Mode = CipherMode.CBC;
byteBuff = ASCIIEncoding.UTF8.GetBytes(strToEncrypt);
return
(Convert.ToBase64String(
objDESCrypto.CreateEncryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length)));
}
catch (Exception ex)
{
return("Wrong Input. " + ex.Message);
}
}
public static string ToDecryptDES(this string target)
{
//get the byte code of the string
// byte[] toEncryptArray = Convert.FromBase64String(cipherString);
var toEncryptArray = HexToBytes(target);
//if hashing was used get the hash code with regards to your key
var hashmd5 = new MD5CryptoServiceProvider();
var keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(KeySecure));
//release any resource held by the MD5CryptoServiceProvider
hashmd5.Clear();
var tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
//set the secret key for the tripleDES algorithm
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
//padding mode(if any extra byte added)
var cTransform = tdes.CreateDecryptor();
var resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//return the Clear decrypted TEXT
return(Encoding.UTF8.GetString(resultArray));
}
public byte[] Decrypt(byte[] dataToDecrypt, byte[] key, byte[] iv)
{
using (var des = new TripleDESCryptoServiceProvider())
{
des.Mode = CipherMode.CBC;
des.Padding = PaddingMode.PKCS7;
des.Key = key;
des.IV = iv;
using (var memoryStream = new MemoryStream())
{
var cryptoStream = new CryptoStream(memoryStream, des.CreateDecryptor(),
CryptoStreamMode.Write);
cryptoStream.Write(dataToDecrypt, 0, dataToDecrypt.Length);
cryptoStream.FlushFinalBlock();
var decryptBytes = memoryStream.ToArray();
return(decryptBytes);
}
}
}
public string Decrypt(string toDecrypt, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(toDecrypt);
if (useHashing)
{
var hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes("tutm"));
}
else
{
keyArray = Encoding.UTF8.GetBytes("tutm");
}
var 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));
}
private void button2_Click(object sender, EventArgs e)
{
try
{
byte[] data = Convert.FromBase64String(txtEncrypt.Text);
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
byte[] keys = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hash));
using (TripleDESCryptoServiceProvider tripDes = new TripleDESCryptoServiceProvider()
{
Key = keys, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
})
{
ICryptoTransform transform = tripDes.CreateDecryptor();
byte[] results = transform.TransformFinalBlock(data, 0, data.Length);
txtDecrypt.Text = UTF8Encoding.UTF8.GetString(results);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "디코드 할 문자열을 다시 한번 확인해주시기 바랍니다.", "Error(ISD01)", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public static string Encrypt(string key, string toEncrypt, bool useHashing = true)
{
byte[] resultArray = null;
try
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
if (useHashing)
{
using (MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider())
{
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
}
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
using (TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider())
{
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
}
}
catch (Exception ex)
{
SimpleLogger.Log(ex);
}
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
public static string Decipher(string textToDecipher)
{
try
{
textToDecipher = Base64SafeDecoding(textToDecipher);
var arrayToDecipher = Convert.FromBase64String(textToDecipher);
// Are used the classes for cipher MD5
var hashMd5 = new MD5CryptoServiceProvider();
var keyArray = hashMd5.ComputeHash(Encoding.UTF8.GetBytes(Key));
hashMd5.Clear();
//Algorithm TripleDES
var tripleDes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
var cTransform = tripleDes.CreateDecryptor();
var resultArray = cTransform.TransformFinalBlock(arrayToDecipher, 0, arrayToDecipher.Length);
tripleDes.Clear();
// return result in string form
textToDecipher = Encoding.UTF8.GetString(resultArray);
}
catch (Exception)
{
textToDecipher = "";
}
return(textToDecipher);
}
/// <summary>
/// Encrypt string by key with TripleDES
/// </summary>
/// <param name="inputString">input string</param>
/// <param name="key">encryption key</param>
/// <returns>TripleDES-encrypted string in Base64 encoding</returns>
public string Encrypt(string inputString, string key)
{
if (string.IsNullOrWhiteSpace(inputString))
{
throw new ArgumentNullException("inputString");
}
if (string.IsNullOrWhiteSpace(key))
{
throw new ArgumentNullException("key");
}
byte[] buffer = Encoding.ASCII.GetBytes(inputString);
TripleDESCryptoServiceProvider tripleDes = new TripleDESCryptoServiceProvider
{
Key = Encoding.ASCII.GetBytes(key),
Mode = CipherMode.ECB
};
ICryptoTransform transform = tripleDes.CreateEncryptor();
var _utf8 = new UTF8Encoding();
var output = transform.TransformFinalBlock(buffer, 0, buffer.Length);
var res = HttpServerUtility.UrlTokenEncode(output);
return(res);
}
/// <summary>
/// 3DES解密
/// </summary>
/// <param name="text">加密的字符串</param>
/// <param name="password">密钥</param>
/// <param name="iv">解密矢量：只有在CBC解密模式下才适用</param>
/// <param name="cMode">运算模式</param>
/// <returns>解密的字符串</returns>
public static byte[] Decrypt3DES(string text, string password, CipherMode cMode = CipherMode.ECB, PaddingMode pMode = PaddingMode.Zeros, string iv = "")
{
try
{
using (var des = new TripleDESCryptoServiceProvider
{
Key = Encoding.UTF8.GetBytes(password),
Mode = cMode,
Padding = pMode
})
{
if (cMode == CipherMode.CBC)
{
des.IV = Encoding.UTF8.GetBytes(iv);
}
var buffer = Convert.FromBase64String(text);
return(des.CreateDecryptor().TransformFinalBlock(buffer, 0, buffer.Length));
}
}
catch
{
throw new Exception();
}
}
public static void SetString(string key, string value)
{
// 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);
// Encrypt '_value' into a byte array
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(value);
// Eecrypt '_value' with 3DES.
TripleDES des = new TripleDESCryptoServiceProvider();
des.Key = secret;
des.Mode = CipherMode.ECB;
ICryptoTransform xform = des.CreateEncryptor();
byte[] encrypted = xform.TransformFinalBlock(bytes, 0, bytes.Length);
// Convert encrypted array into a readable string.
string encryptedString = Convert.ToBase64String(encrypted);
// Set the ( key, encrypted value ) pair in regular PlayerPrefs.
PlayerPrefs.SetString(hashKey, encryptedString);
}
// Encrypts given file with 3DES algorithm
public void EncryptFile(string fileName, string outName, CipherMode cipherMode)
{
var outNameNoExtension = Path.GetFileNameWithoutExtension(outName);
var path = Path.GetDirectoryName(fileName);
var tdesKey = LoadTripleDESKey();
var tdesIV = LoadTripleDESIV();
using (var xmlOutputStream = new FileStream(Path.Combine(path, outNameNoExtension + ".xml"), FileMode.OpenOrCreate, FileAccess.Write))
{
var tdes = new TripleDESCryptoServiceProvider
{
Mode = cipherMode
};
var encryptedText = EncryptFileToXml(tdes, fileName);
var fileExtension = Path.GetExtension(fileName);
XmlComposer.CreateXml(new List <UserModel> {
new UserModel("asd", "123")
}, Convert.ToBase64String(tdesIV), Convert.ToString(cipherMode),
tdes.BlockSize, tdes.KeySize, "TripleDES", encryptedText, fileExtension).Save(xmlOutputStream);
}
}
public static string FicMetDataEncrypt(string FicData)
{
try
{
string key = "elchico69eva78jGH5"; //llave para encriptar datos
byte[] keyArray;
byte[] Arreglo_a_Cifrar = UTF8Encoding.UTF8.GetBytes(FicData);
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.CreateEncryptor();
byte[] ArrayResultado = cTransform.TransformFinalBlock(Arreglo_a_Cifrar, 0, Arreglo_a_Cifrar.Length);
tdes.Clear();
return(Convert.ToBase64String(ArrayResultado, 0, ArrayResultado.Length));
}
catch (Exception)
{
return("ERROR");
}
}//This method is used to Encrypt data
/// <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>
/// 解密数据
/// </summary>
/// <param name="text">待解密的字符串</param>
/// <param name="sKey">解密密钥</param>
/// <returns></returns>
public static string Decrypt(string text, string sKey)
{
defaultIV = "4R38WE5E";
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV = ASCIIEncoding.ASCII.GetBytes(defaultIV);
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
ICryptoTransform DESDecrypt = des.CreateDecryptor();
string result = string.Empty;
try
{
byte[] Buffer = Convert.FromBase64String(text);
result = ASCIIEncoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
}
catch (System.Exception ex)
{
throw ex;
}
return(result);
}
/// <summary>
/// 3des解密字符串
/// </summary>
/// <param name="text">要解密的字符串</param>
/// <param name="key">密钥</param>
/// <param name="encoding">编码方式</param>
/// <returns>解密后的字符串</returns>
/// <remarks>静态方法，指定编码方式</remarks>
public static string Decrypt(string text, string key, Encoding encoding)
{
TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashMD5 = new MD5CryptoServiceProvider();
DES.Key = hashMD5.ComputeHash(encoding.GetBytes(key));
DES.Mode = CipherMode.ECB;
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
string result = string.Empty;
try
{
byte[] Buffer = Convert.FromBase64String(text);
result = encoding.GetString(DESDecrypt.TransformFinalBlock
(Buffer, 0, Buffer.Length));
}
catch (Exception e)
{
throw (new Exception("Invalid Key or input string is not a valid base64 string", e));
}
return(result);
}
public void Desencriptar(string filename)
{
string text = Convert.ToBase64String(File.ReadAllBytes(filename), 0, File.ReadAllBytes(filename).Length);
byte[] plano = Convert.FromBase64String(text);
using (var md5 = new MD5CryptoServiceProvider())
{
byte[] code = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
md5.Clear();
using (var des = new TripleDESCryptoServiceProvider())
{
des.Key = code;
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
using (var memo = new MemoryStream())
{
ICryptoTransform crypt = des.CreateDecryptor();
try
{
byte[] array = crypt.TransformFinalBlock(plano, 0, plano.Length);
des.Clear();
File.WriteAllText(filename, UTF8Encoding.UTF8.GetString(array));
}
catch
{
Encriptar(filename);
byte[] array = crypt.TransformFinalBlock(plano, 0, plano.Length);
des.Clear();
File.WriteAllText(filename, UTF8Encoding.UTF8.GetString(array));
}
}
}
}
}
public static string Encrypt(string toEncrypt, string key, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
public void Encrypt(string source, string key)
{
TripleDESCryptoServiceProvider desCryptoProvider = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashMD5Provider = new MD5CryptoServiceProvider();
byte[] byteHash;
byte[] byteBuff;
byteHash = hashMD5Provider.ComputeHash(Encoding.UTF8.GetBytes(key));
desCryptoProvider.Key = byteHash;
if (comboBox1.Text == "ECB")
{
desCryptoProvider.Mode = CipherMode.ECB;
}
else if (comboBox1.Text == "CBC")
{
desCryptoProvider.Mode = CipherMode.CBC;
}
else if (comboBox1.Text == "CFB")
{
desCryptoProvider.Mode = CipherMode.CFB;
}
else
{
MessageBox.Show("Pasirinkite Modą");
}
byteBuff = Encoding.UTF8.GetBytes(source);
string encoded = Convert.ToBase64String(desCryptoProvider.CreateEncryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length));
richTextBox1.Invoke((MethodInvoker)(() => richTextBox1.Text = (encoded)));
using (var writer = File.AppendText("ENCRYPTED.txt"))
{
writer.WriteLine(encoded);
}
}
public static string GetEncryptedValue(string inputValue)
{
MemoryStream mStream = null;
CryptoStream cStream = null;
try
{
TripleDESCryptoServiceProvider provider = GetCryptoProvider();
mStream = new MemoryStream();
cStream = new CryptoStream(mStream, provider.CreateEncryptor(), CryptoStreamMode.Write);
byte[] toEncrypt = new UTF8Encoding().GetBytes(inputValue);
cStream.Write(toEncrypt, 0, toEncrypt.Length);
cStream.FlushFinalBlock();
byte[] ret = mStream.ToArray();
return(Convert.ToBase64String(ret));
}
catch
{
return(string.Empty);
}
finally
{
if (mStream != null)
{
mStream.Close();
}
if (cStream != null)
{
cStream.Close();
}
}
}
/// <summary>
/// TripeDes加密
/// </summary>
/// <param name="code">被加密字符串</param>
/// <param name="Key">密匙</param>
/// <param name="mode">块密码模式</param>
/// <param name="type">填充</param>
/// <returns>加密字符串</returns>
public static byte[] TripeDesEncryptByte(byte[] code, string Key, CipherMode mode = CipherMode.CBC, PaddingMode type = PaddingMode.PKCS7)
{
try
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
byte[] inputByteArray = null;
if (CharSet.Trim() == "")
{
inputByteArray = code;
des.Key = ASCIIEncoding.Default.GetBytes(Key);
des.IV = ASCIIEncoding.Default.GetBytes(Key);
}
else
{
inputByteArray = code;
des.Key = ASCIIEncoding.GetEncoding(CharSet).GetBytes(Key);
des.IV = ASCIIEncoding.GetEncoding(CharSet).GetBytes(Key);
}
des.Mode = mode;
des.Padding = type;
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
byte[] res = ms.ToArray();
cs.Close();
des.Clear();
ms.Close();
return(res);
}
catch (Exception ex)
{
ErrMsg = ex.Message;
return(null);
}
}
/// <summary>
/// 根据对称加密类型获取需要的对称加密对象实例
/// </summary>
/// <param name="saType">对称加密类型</param>
/// <returns></returns>
private SymmetricAlgorithm GetCryptoServiceProvider(SymmetricAlgorithmType saType)
{
SymmetricAlgorithm tmpSa = null;
switch (saType)
{
case SymmetricAlgorithmType.AES:
tmpSa = new AesCryptoServiceProvider();
break;
case SymmetricAlgorithmType.DES:
tmpSa = new DESCryptoServiceProvider();
break;
case SymmetricAlgorithmType.RC2:
tmpSa = new RC2CryptoServiceProvider();
break;
case SymmetricAlgorithmType.TripleDES:
tmpSa = new TripleDESCryptoServiceProvider();
break;
}
return(tmpSa);
}
public string Desencriptar(string textoEncriptado)
{
byte[] llaveArray;
//convierte el texto en una secuencia de bytes
byte[] Array_a_Descifrar =
Convert.FromBase64String(textoEncriptado);
//se llama a las clases que tienen los algoritmos
//de encriptación se le aplica hashing
//algoritmo MD5
MD5CryptoServiceProvider hashmd5 =
new MD5CryptoServiceProvider();
llaveArray = hashmd5.ComputeHash(
UTF8Encoding.UTF8.GetBytes(llave));
hashmd5.Clear();
TripleDESCryptoServiceProvider tdes =
new TripleDESCryptoServiceProvider();
tdes.Key = llaveArray;
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 void Encriptar(string filename)
{
byte[] plano = Encoding.UTF8.GetBytes(File.ReadAllText(filename));
using (var md5 = new MD5CryptoServiceProvider())
{
byte[] code = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
md5.Clear();
using (var des = new TripleDESCryptoServiceProvider())
{
des.Key = code;
des.Mode = CipherMode.ECB;
des.Padding = PaddingMode.PKCS7;
using (var memo = new MemoryStream())
{
ICryptoTransform crypt = des.CreateEncryptor();
byte[] encrypt = crypt.TransformFinalBlock(plano, 0, plano.Length);
des.Clear();
File.WriteAllBytes(filename, encrypt.ToArray());
}
}
}
}
/// <summary>
/// 3DES加密
/// </summary>
/// <param name="originalValue">加密数据</param>
/// <param name="key">24位字符的密钥字符串</param>
/// <returns></returns>
public static string DESEncrypt(string originalValue, string key)
{
if (string.IsNullOrEmpty(originalValue))
{
return(originalValue);
}
try
{
var DES = new TripleDESCryptoServiceProvider()
{
Key = ASCIIEncoding.ASCII.GetBytes(key),
Mode = CipherMode.ECB,
Padding = PaddingMode.Zeros
};
ICryptoTransform DESEncrypt = DES.CreateEncryptor();
byte[] Buffer = originalValue.ToHexBytes();
var bytes = DESEncrypt.TransformFinalBlock(Buffer, 0, Buffer.Length);
return(bytes.ToHexString());
}
catch (Exception ex)
{
return(ex.Message);
}
}
/// <summary>
/// 3DES解密
/// </summary>
/// <param name="data">解密数据</param>
/// <param name="key">24位字符的密钥字符串(需要和加密时相同)</param>
/// <returns></returns>
public static string DESDecrypst(string data, string key)
{
if (string.IsNullOrEmpty(data))
{
return(data);
}
try
{
var DES = new TripleDESCryptoServiceProvider()
{
Key = ASCIIEncoding.ASCII.GetBytes(key),
Mode = CipherMode.ECB,
Padding = PaddingMode.Zeros
};
ICryptoTransform DESDecrypt = DES.CreateDecryptor();
byte[] Buffer = data.ToHexBytes();
var bytes = DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length);
return(bytes.ToHexString());
}
catch
{
return(string.Empty);
}
}
public string dencryptus(string x, string keyai)
{
try
{
string y = x.Replace("\0", null);
byte[] etext = Convert.FromBase64String(y);
string key = keyai;
MD5CryptoServiceProvider mdhash = new MD5CryptoServiceProvider();
byte[] keyarray = mdhash.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
TripleDESCryptoServiceProvider tds = new TripleDESCryptoServiceProvider();
tds.Key = keyarray;
tds.Mode = CipherMode.ECB;
tds.Padding = PaddingMode.PKCS7;
ICryptoTransform itransform = tds.CreateDecryptor();
byte[] result = itransform.TransformFinalBlock(etext, 0, etext.Length);
string dencryptresult = UTF8Encoding.UTF8.GetString(result);
return(dencryptresult.ToString());
}
catch (Exception ex)
{
return(ex.Message + "Possible Reason,Password problem");
}
}
public void EncryptDecryptStringTest()
{
var raw = "We the People of the United States, in Order to form a more perfect Union, establish Justice, insure domestic Tranquility, provide for the common defense, promote the general Welfare, and secure the Blessings of Liberty to ourselves and our Posterity, do ordain and establish this Constitution for the United States of America.";
try
{
// Create 3DES that generates a new key and initialization vector (IV).
// Same key must be used in encryption and decryption
using (var tdes = new TripleDESCryptoServiceProvider())
{
// Encrypt string
var encrypted = EncryptionHelper.TripleDESEncrypt(raw, tdes.Key, tdes.IV);
// Decrypt the bytes to a string.
var decrypted = EncryptionHelper.TripleDESDecrypt(encrypted, tdes.Key, tdes.IV);
Assert.AreEqual(raw, decrypted);
}
}
catch (Exception ex)
{
Assert.Fail($"Encryption/ Description test failed. {ex.Message}");
}
}
/// <summary>
/// Decrypts a serialized query string
/// </summary>
private string decrypt(string encryptedQueryString)
{
try
{
byte[] buffer = Convert.FromBase64String(encryptedQueryString);
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider MD5 = new MD5CryptoServiceProvider();
des.Key = MD5.ComputeHash(ASCIIEncoding.ASCII.GetBytes(cryptoKey));
des.IV = IV;
//modified for mozilla url issue
return(EncryptionHelper.Decode64BitString(encryptedQueryString));
}
catch (CryptographicException)
{
return("");
//throw new InvalidFormatException();
}
catch (FormatException)
{
return("");
//throw new InvalidFormatException();
}
}
public static string DecryptTripleDES(string str)
{
TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
//Put the input string into the byte array
byte[] inputByteArray = new byte[str.Length / 2];
for (int x = 0; x < str.Length / 2; x++)
{
int i = (Convert.ToInt32(str.Substring(x * 2, 2), 16));
inputByteArray[x] = (byte)i;
}
//建立加密对象的密钥和偏移量，此值重要，不能修改
des.Key = key_192;
des.IV = iv_192;
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
//Flush the data through the crypto stream into the memory stream
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return(System.Text.Encoding.Unicode.GetString(ms.ToArray()));
}
private static string EncryptString(string Message, string Passphrase)
{
UTF8Encoding utf8Encoding = new UTF8Encoding();
MD5CryptoServiceProvider md5CryptoServiceProvider = new MD5CryptoServiceProvider();
byte[] key = md5CryptoServiceProvider.ComputeHash(utf8Encoding.GetBytes(Passphrase));
TripleDESCryptoServiceProvider tripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider();
tripleDESCryptoServiceProvider.Key = key;
tripleDESCryptoServiceProvider.Mode = CipherMode.ECB;
tripleDESCryptoServiceProvider.Padding = PaddingMode.PKCS7;
byte[] bytes = utf8Encoding.GetBytes(Message);
byte[] inArray;
try
{
inArray = tripleDESCryptoServiceProvider.CreateEncryptor().TransformFinalBlock(bytes, 0, bytes.Length);
}
finally
{
tripleDESCryptoServiceProvider.Clear();
md5CryptoServiceProvider.Clear();
}
return(Convert.ToBase64String(inArray));
}
