public static string Encrypt(string toEncrypt, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
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.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 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);
}
/// <summary>
/// DeCrypt a string using dual encryption method. Return a DeCrypted clear string
/// </summary>
/// <param name="cipherString">encrypted string</param>
/// <param name="useHashing">Did you use hashing to encrypt this data? pass true is yes</param>
/// <returns></returns>
public static string Decrypt(string cipherString, bool useHashing)
{
byte[] keyArray;
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("Security key", 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);
}
//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 string Encrypt(string toEncrypt, string securityKey, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
string key = securityKey;
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.CBC;
//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 Encrypt()
{
mCSP = new TripleDESCryptoServiceProvider();
strKey = "5EAGLES";
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(strKey));
hashmd5.Clear();
mCSP.Key = keyArray;
mCSP.Mode = CipherMode.ECB;
mCSP.Padding = PaddingMode.PKCS7;
}
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>
/// Md5 加密算法
/// </summary>
/// <param name="sDataIn">需要加密的内容</param>
/// <returns>加密后的结果</returns>
public static string GetMD5(string sDataIn)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] bytValue, bytHash;
bytValue = System.Text.Encoding.UTF8.GetBytes(sDataIn);
bytHash = md5.ComputeHash(bytValue);
md5.Clear();
string sTemp = "";
for (int i = 0; i < bytHash.Length; i++)
{
sTemp += bytHash[i].ToString("X").PadLeft(2, '0');
}
return sTemp.ToLower();
}
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);
}
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 static string Encrypt(string text)
{
//1、创建MD5对象
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
//2、将字符编码为一个字节序列
byte[] data = Encoding.Default.GetBytes(text);
//3、计算data字节数组的哈希值
byte[] md5data = md5.ComputeHash(data);
//4、释放MD5对象中的所有资源
md5.Clear();
//5、创建字符存储器并初始化
StringBuilder str = new StringBuilder();
str.Append(string.Empty);
//6、存储加密字符
for (int i = 0; i < md5data.Length - 1; i++)
{
str.Append(md5data[i].ToString("x").PadLeft(2, '0'));
}
//7、返回经过MD5加密过后的字符串
return str.ToString();
}
public static string Encrypt(string Message, string Passphrase)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
// Step 1. MD5 해쉬를 사용해서 암호화하고,
// MD5 해쉬 생성기를 사용해서 결과는 128 비트 바이트 배열인데,
// 3DES 인코딩을 위한 올바른 길이가 됨.
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
// Step 2. TripleDESCryptoServiceProvider object 생성
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
// Step 3. Encoder 설정
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Step 4. 암호화할 문자열을 Byte[]로 변환
byte[] DataToEncrypt = UTF8.GetBytes(Message);
// Step 5. 실제로 문자열을 암호화
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
}
finally
{
// 중요한 3DES, Hashprovider의 속성을 해제
TDESAlgorithm.Clear();
HashProvider.Clear();
}
// Step 6. 암호화된 문자열을 Base64로 변환하여 리턴
return(Convert.ToBase64String(Results));
}
public static Byte[] Encrypt(Byte[] toEncryptArray, Int32 count, String key, bool useHashing)
{
byte[] keyArray = null;
//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.UTF8.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
{
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.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, count);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//Return the encrypted data into unreadable string format
return(resultArray);
}
/// <summary>
/// Encrypts the specified to encrypt.
/// </summary>
/// <param name="toEncrypt">To encrypt.</param>
/// <param name="useHashing">if set to <c>true</c> [use hashing].</param>
/// <returns>
/// The encrypted String to be stored in the Database
/// </returns>
public static String Encrypt(String encryptionKey, String toEncrypt, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
//If hashing use get hashcode regards to your key
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(encryptionKey));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(encryptionKey);
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);
}
public string fnGetEncrypt(string pStr)
{
{
string strResultado = "";
try
{
string key = this._keybase; //llave para encriptar datos
byte[] keyArray;
byte[] Arreglo_a_Cifrar = UTF8Encoding.UTF8.GetBytes(pStr);
//Se utilizan las clases de encriptación MD5
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
//Algoritmo TripleDES
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();
//se regresa el resultado en forma de una cadena
strResultado = Convert.ToBase64String(ArrayResultado, 0, ArrayResultado.Length);
}
catch (Exception)
{
return("");
}
return(strResultado);
}
}
public string EncryptString(string Message)
{
string Passphrase = "maianh";
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
// Step 1: using MD5
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
// Step 2. Create new object TripleDESCryptoServiceProvider
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
// Step 3. Setting Encoder
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Step 4. Convert string (Message) to byte[]
byte[] DataToEncrypt = UTF8.GetBytes(Message);
// Step 5. String encoding
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
}
finally
{
// Delete all info related to Triple DES and HashProvider
TDESAlgorithm.Clear();
HashProvider.Clear();
}
// Step 6. return string encoded by Base64
return(Convert.ToBase64String(Results));
}
public static string Decrypt(string text, string key)
{
byte[] results;
System.Text.UTF8Encoding encoding = new System.Text.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[] sKey = hashProvider.ComputeHash(encoding.GetBytes(key));
// Step 2. Create a new TripleDESCryptoServiceProvider object
TripleDESCryptoServiceProvider algorithm = new TripleDESCryptoServiceProvider();
// Step 3. Setup the decoder
algorithm.Key = sKey;
algorithm.Mode = CipherMode.ECB;
algorithm.Padding = PaddingMode.PKCS7;
// Step 4. Convert the input string to a byte[]
byte[] dataToDecrypt = Convert.FromBase64String(text);
// Step 5. Attempt to decrypt the string
try
{
ICryptoTransform decryptor = algorithm.CreateDecryptor();
results = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length);
}
finally
{
// Clear the TripleDes and Hashprovider services of any sensitive information
algorithm.Clear();
hashProvider.Clear();
}
// Step 6. Return the decrypted string in UTF8 format
return(encoding.GetString(results));
}
public static string Decrypt(string textoEncriptado, string key)
{
if (!string.IsNullOrEmpty(textoEncriptado))
{
byte[] keyArray;
//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();
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(Array_a_Descifrar,
0, Array_a_Descifrar.Length);
tdes.Clear();
//se regresa en forma de cadena
return(UTF8Encoding.UTF8.GetString(resultArray));
}
return(string.Empty);
}
public static string Encrypt(string toEncrypt, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
string key = "GetDunkedOnScrub";
//Console.WriteLine(key.Length.ToString());
try
{
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data
//of the Cryptographic service provide. Best Practice
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));
}
}
catch (Exception e)
{
Console.WriteLine("Something am broke in Encrypt");
Console.WriteLine(e.Message);
}
return("Nope");
}
public string Encryptword(string Encryptval)
{
byte[] SrctArray;
//get the byte code of the string and key
byte[] EnctArray = UTF8Encoding.UTF8.GetBytes(Encryptval);
SrctArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider objt = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider objcrpt = new MD5CryptoServiceProvider();
SrctArray = objcrpt.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
objcrpt.Clear();
//set the secret key for the tripleDES algorithm
objt.Key = SrctArray;
//mode of operation - ECB(Electronic code Book)
objt.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
objt.Padding = PaddingMode.PKCS7;
ICryptoTransform crptotrns = objt.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resArray = crptotrns.TransformFinalBlock(EnctArray, 0, EnctArray.Length);
//Release resources held by TripleDes Encryptor
objt.Clear();
//Return the encrypted data into unreadable string format
return(Convert.ToBase64String(resArray, 0, resArray.Length));
}
public string Encrypt(string messageToEncrypt)
{
byte[] buffer;
UTF8Encoding utf8 = new UTF8Encoding();
messageToEncrypt = (messageToEncrypt ?? String.Empty);
//Step 1. We hash the password 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 encoder
tdesAlgorithm.Key = tdesKey;
tdesAlgorithm.Mode = CipherMode.ECB;
tdesAlgorithm.Padding = PaddingMode.PKCS7;
//Step 3. Convert the input string to a byte[]
byte[] dataToEncrypt = utf8.GetBytes(messageToEncrypt);
//Step 4. Attempt to encrypt the string
try
{
ICryptoTransform encryptor = tdesAlgorithm.CreateEncryptor();
buffer = encryptor.TransformFinalBlock(dataToEncrypt, 0, dataToEncrypt.Length);
}
finally
{
//Clear the TripleDes and Hashprovider services of any sensitive information
tdesAlgorithm.Clear();
hashProvider.Clear();
}
//Step 5. Return the encrypted string as a base64 encoded string
return(Convert.ToBase64String(buffer));
}
public static string Encriptar(string texto)
{
try
{
string key = "qualityinfosolutions"; //llave para encriptar datos
byte[] keyArray;
// byte[] Arreglo_a_Cifrar = UTF8Encoding.UTF8.GetBytes(texto);
byte[] Arreglo_a_Cifrar = UTF8Encoding.BigEndianUnicode.GetBytes(texto);
//Se utilizan las clases de encriptación MD5
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
// keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
keyArray = hashmd5.ComputeHash(UTF8Encoding.BigEndianUnicode.GetBytes(key));
hashmd5.Clear();
//Algoritmo TripleDES
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);
byte[] ArrayResultado = cTransform.TransformFinalBlock(Arreglo_a_Cifrar, 0, Arreglo_a_Cifrar.Length);
tdes.Clear();
//se regresa el resultado en forma de una cadena
texto = Convert.ToBase64String(ArrayResultado, 0, ArrayResultado.Length);
}
catch (Exception)
{
}
return(texto);
}
public static string Decrypt(string cipherString, bool useHashing, string key)
{
byte[] keyArray;
//get the byte code of the string
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
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.ISO10126;
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));
}
// first encription
public static string Encrypt(string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = StringToByteArray(toEncrypt);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = StringToByteArray(mysecurityKey);
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
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.None;
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
var hexString = ByteArrayToHexString(resultArray);
return(ConvertToBase64String(hexString.ToUpper()));
}
public static string EncriptarPassword(string txtPassword)
{
//arreglo de bytes donde guardaremos la llave
string key = "WonderCrisKeySeguridad";
byte[] keyArray;
//arreglo de bytes donde guardaremos el texto
//que vamos a encriptar
byte[] Arreglo_a_Cifrar = UTF8Encoding.UTF8.GetBytes(txtPassword);
//se utilizan las clases de encriptación
//provistas por el Framework
//Algoritmo MD5
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
//se guarda la llave para que se le realice
//hashing
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
//Algoritmo 3DAS
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
//se empieza con la transformación de la cadena
ICryptoTransform cTransform = tdes.CreateEncryptor();
//arreglo de bytes donde se guarda la
//cadena cifrada
byte[] ArrayResultado = cTransform.TransformFinalBlock(Arreglo_a_Cifrar, 0, Arreglo_a_Cifrar.Length);
tdes.Clear();
//se regresa el resultado en forma de una cadena
return(Convert.ToBase64String(ArrayResultado, 0, ArrayResultado.Length));
}
public static string Encrypt(string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
// Get the key from config file
string key = "aceka#holding+-";
//System.Windows.Forms.MessageBox.Show(key);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
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>
/// 计算32位MD5码
/// </summary>
/// <param name="word">字符串</param>
/// <param name="toUpper">返回哈希值格式 true：英文大写，false：英文小写</param>
/// <returns></returns>
public static string MD5_32(string word, bool toUpper = true)
{
try
{
MD5CryptoServiceProvider MD5CSP = new MD5CryptoServiceProvider();
byte[] bytValue = Encoding.UTF8.GetBytes(word);
byte[] bytHash = MD5CSP.ComputeHash(bytValue);
MD5CSP.Clear();
//根据计算得到的Hash码翻译为MD5码
string sHash = "", sTemp = "";
for (int counter = 0; counter < bytHash.Length; counter++)
{
long i = bytHash[counter] / 16;
if (i > 9)
{
sTemp = ((char)(i - 10 + 0x41)).ToString();
}
else
{
sTemp = ((char)(i + 0x30)).ToString();
}
i = bytHash[counter] % 16;
if (i > 9)
{
sTemp += ((char)(i - 10 + 0x41)).ToString();
}
else
{
sTemp += ((char)(i + 0x30)).ToString();
}
sHash += sTemp;
}
//根据大小写规则决定返回的字符串
return(toUpper ? sHash : sHash.ToLower());
}
catch (Exception ex)
{
throw ex;
}
}
//DESENCRIPTA CONTRASEÑA
public static string DecryptKeyMD5(string clave)
{
string key = "ABCDEFG54669525PQRSTUVWXYZabcdef852846opqrstuvwxyz";
byte[] keyArray;
//convierte el texto en una secuencia de bytes
byte[] Array_a_Descifrar = Convert.FromBase64String(clave);
//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(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(Array_a_Descifrar, 0, Array_a_Descifrar.Length);
tdes.Clear();
//se regresa en forma de cadena
return(UTF8Encoding.UTF8.GetString(resultArray));
}
/// <summary>
/// MD5:32位加密
/// </summary>
/// <param name="EncryptString">要加密的字符串</param>
/// <returns>加密后的密文</returns>
public static string MD5Encrypt32(string EncryptString)
{
if (string.IsNullOrEmpty(EncryptString))
{
throw (new Exception("明文不得为空！"));
}
string m_strEncrypt = "";
MD5 m_ClassMD5 = new MD5CryptoServiceProvider();
try
{
byte[] s = m_ClassMD5.ComputeHash(Encoding.Default.GetBytes(EncryptString));
for (int i = 0; i < s.Length; i++)
{
var v = s[i].ToString("X");
if (v.Length == 1)
{
v = "0" + v;
}
m_strEncrypt = m_strEncrypt + v;
}
}
catch (ArgumentException ex)
{
throw ex;
}
catch (CryptographicException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
finally
{
m_ClassMD5.Clear();
}
return(m_strEncrypt);
}
/// <summary>Encrypt a string into a web safe string.</summary>
/// <param name="StringValue">The string being processed <see cref="string"/></param>
/// <param name="passphrase">A passphrase to use to encrypt with. Can only be decrypted using the same passphrase <see cref="string"/></param>
/// <returns>Encrypted String result <see cref="string"/></returns>
public static string EncryptStringWebSafe(this string StringValue, string passphrase = "Theres no fate but what we make.")
{
byte[] results;
var utf8 = new System.Text.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();
byte[] tdesKey = hashProvider.ComputeHash(utf8.GetBytes(passphrase));
// Step 2. Create a new TripleDESCryptoServiceProvider object
var tdesAlgorithm = new TripleDESCryptoServiceProvider
{
// Step 3. Setup the encoder
Key = tdesKey,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
// Step 4. Convert the input string to a byte[]
var dataToEncrypt = utf8.GetBytes(StringValue);
// Step 5. Attempt to encrypt the string
try
{
var encryptor = tdesAlgorithm.CreateEncryptor();
results = encryptor.TransformFinalBlock(dataToEncrypt, 0, dataToEncrypt.Length);
}
finally
{
// Clear the TripleDes and Hashprovider services of any sensitive information
tdesAlgorithm.Clear();
hashProvider.Clear();
}
// Step 6. Return the encrypted string as a base64 encoded string
return(Convert.ToBase64String(results));
}
public static string DecryptString(string Message)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.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("OriBTech@2014"));
// Step 2. Create a new TripleDESCryptoServiceProvider object
TripleDESCryptoServiceProvider 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[]
byte[] DataToDecrypt = Convert.FromBase64String(Message);
// Step 5. Attempt to decrypt the string
try
{
ICryptoTransform 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 Encrypt(String toEncrypt, bool useHashing)
{
String toUse = toEncrypt;
String error = "";
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
System.Configuration.AppSettingsReader settingsReader = new AppSettingsReader();
String key = (String)settingsReader.GetValue("SecurityKey", typeof(String));
try
{
if (useHashing == true)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
}
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider cServiceProvider = new TripleDESCryptoServiceProvider();
cServiceProvider.Key = keyArray;
cServiceProvider.Mode = CipherMode.ECB;
cServiceProvider.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = cServiceProvider.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
cServiceProvider.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
catch (Exception ex)
{
error = "Something went wrong." + ex;
return(error);
}
}
/// <summary>
/// 获取文件的MD5值
/// </summary>
/// <param name="fileName"> 文件名 </param>
/// <returns> 32位MD5 </returns>
public static string GetFileMd5(string fileName)
{
using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read))
{
const int bufferSize = 1024 * 1024;
byte[] buffer = new byte[bufferSize];
using (MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider())
{
md5.Initialize();
long offset = 0;
while (offset < fs.Length)
{
long readSize = bufferSize;
if (offset + readSize > fs.Length)
{
readSize = fs.Length - offset;
}
fs.Read(buffer, 0, (int)readSize);
if (offset + readSize < fs.Length)
{
md5.TransformBlock(buffer, 0, (int)readSize, buffer, 0);
}
else
{
md5.TransformFinalBlock(buffer, 0, (int)readSize);
}
offset += bufferSize;
}
fs.Close();
byte[] result = md5.Hash;
md5.Clear();
StringBuilder sb = new StringBuilder(32);
foreach (byte b in result)
{
sb.Append(b.ToString("X2"));
}
return(sb.ToString());
}
}
}
public string DecryptString(string Message)
{
string Passphrase = ConfigurationManager.AppSettings["PassPhraseDecryt"];
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
// Step 1. Bam chuoi su dung MD5
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(Passphrase));
// Step 2. Tao doi tuong TripleDESCryptoServiceProvider moi
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
// Step 3. Cai dat bo giai ma
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Step 4. Convert chuoi (Message) thanh dang byte[]
byte[] DataToDecrypt = Convert.FromBase64String(Message);
// Step 5. Bat dau giai ma chuoi
try
{
ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
// Xoa moi thong tin ve Triple DES va HashProvider de dam bao an toan
TDESAlgorithm.Clear();
HashProvider.Clear();
}
// Step 6. Tra ve ket qua bang dinh dang UTF8
return(UTF8.GetString(Results));
}
private byte[] EncryptDecrypt(byte[] arCryptoBytes, CryptographicDirection theDirection)
{
byte[] arOutputBytes;
//get our cryptographic providers out
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
TripleDESCryptoServiceProvider my3DES = new TripleDESCryptoServiceProvider();
ICryptoTransform myTransform = null;
try
{
//hash the key
my3DES.Key = hashmd5.ComputeHash(BaseKey);
my3DES.Mode = CipherMode.ECB;
my3DES.Padding = PaddingMode.PKCS7;
switch (theDirection)
{
case CryptographicDirection.Encrypt:
myTransform = my3DES.CreateEncryptor();
break;
case CryptographicDirection.Decrypt:
myTransform = my3DES.CreateDecryptor();
break;
}
arOutputBytes = myTransform.TransformFinalBlock(arCryptoBytes, 0, arCryptoBytes.Length);
}
finally
{
//clear down the objects
//the are managed wrappers to unmanaged objects so best to dispose of them properly
hashmd5.Clear();
my3DES.Clear();
myTransform.Dispose();
}
return(arOutputBytes);
}
private static string Decrypt(string cipherString, bool useHashing)
{
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("pass",typeof(String)); // SecurityKey
string key = "8312@Sorol";
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>
/// Encrypt the given string using AES. The string can be decrypted using
/// </summary>
/// <param name="plainText">The text to encrypt.</param>
private static string EncryptStringAES(string plainText)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
// Hash the passphrase using MD5
// use the MD5 hash generator as the result is a 128 bit byte array
// which is a valid length for the TripleDES encoder that use below
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes(_password));
// Create a new TripleDESCryptoServiceProvider object
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
// Setup the encoder
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Convert the input string to a byte[]
byte[] DataToEncrypt = UTF8.GetBytes(plainText);
// Attempt to encrypt the string
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
Results = Encryptor.TransformFinalBlock(DataToEncrypt, 0, DataToEncrypt.Length);
}
finally
{
// Clear the TripleDes and Hashprovider services of any sensitive information
TDESAlgorithm.Clear();
HashProvider.Clear();
}
// Return the encrypted string as a base64 encoded string
return(Convert.ToBase64String(Results));
}
private string Decrypt(string cipherString)
{
try
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
//Di default disabilito l'hashing
bool useHashing = false;
//La chiave deve essere di 24 caratteri
string key = "ValueTeamDocsPa3Services";
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));
}
catch (Exception)
{
throw;
}
}
public static string EncryptString(string Message, string Passphrase)
{
byte[] EncryResults;
System.Text.UTF8Encoding UTF8Encoding = new System.Text.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 Md5HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = Md5HashProvider.ComputeHash(UTF8Encoding.GetBytes(Passphrase));
// Step 2. Create a new TripleDESCryptoServiceProvider object
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
// Step 3. Setup the encoder
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
// Step 4. Converting the input string to a byte[]
byte[] DataToEncrypt = UTF8Encoding.GetBytes(Message);
// Step 5. Attempt to encrypt the string
try
{
ICryptoTransform Encryptor = TDESAlgorithm.CreateEncryptor();
EncryResults = Encryptor.TransformFinalBlock(DataToEncrypt, 0, Message.Length);
}
finally
{
// Clear the TripleDes and Hashprovider services of any sensitive information
TDESAlgorithm.Clear();
Md5HashProvider.Clear();
}
// Step 6. Return the encrypted string as a base64 encoded string
return(Convert.ToBase64String(EncryResults));
}
}// end of method Encrypt
/// <summary>
/// DeCrypt a string using dual encryption method. Return a DeCrypted clear string
/// </summary>
/// <param name="cipherString">encrypted string</param>
/// <param name="useHashing">Did you use hashing to encrypt this data? pass true is yes</param>
/// <returns></returns>
public static string Decrypt(string cipherString, string hexKey, bool useHashing)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(hexKey));
hashmd5.Clear();
}// end of if block
else
{
keyArray = UTF8Encoding.UTF8.GetBytes(hexKey);
}// end of else block
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = null;
try
{
resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
}// end of try block
catch (Exception e)
{
UtilityMethod.LogMessage(UtilityMethod.LogLevel.SEVERE, e.Message,
$"{TAG}::Decrypt [line: {UtilityMethod.GetExceptionLineNumber(e)}]");
}// end of catch block
tdes.Clear();
return(UTF8Encoding.UTF8.GetString(resultArray));
}// end of method Decrypt
/// <summary>
/// This method is used to convert the plain text to Encrypted/Un-Readable Text format.
/// </summary>
/// <param name="PlainText">Plain Text to Encrypt before transferring over the network.</param>
/// <returns>Cipher Text</returns>
public static string Encrypt(string PlainText)
{
//Getting the bytes of Input String.
byte[] toEncryptedArray = UTF8Encoding.UTF8.GetBytes(PlainText);
MD5CryptoServiceProvider objMD5CryptoService = new MD5CryptoServiceProvider();
//Gettting the bytes from the Security Key and Passing it to compute the Corresponding Hash Value.
byte[] securityKeyArray = objMD5CryptoService.ComputeHash(UTF8Encoding.UTF8.GetBytes(_securityKey));
//De-allocatinng the memory after doing the Job.
objMD5CryptoService.Clear();
var objTripleDESCryptoService = new TripleDESCryptoServiceProvider();
//Assigning the Security key to the TripleDES Service Provider.
objTripleDESCryptoService.Key = securityKeyArray;
//Mode of the Crypto service is Electronic Code Book.
objTripleDESCryptoService.Mode = CipherMode.ECB;
//Padding Mode is PKCS7 if there is any extra byte is added.
objTripleDESCryptoService.Padding = PaddingMode.PKCS7;
var objCrytpoTransform = objTripleDESCryptoService.CreateEncryptor();
//Transform the bytes array to resultArray
byte[] resultArray = objCrytpoTransform.TransformFinalBlock(toEncryptedArray, 0, toEncryptedArray.Length);
//Releasing the Memory Occupied by TripleDES Service Provider for Encryption.
objTripleDESCryptoService.Clear();
//Convert and return the encrypted data/byte into string format.
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
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 Encrypt(string toEncrypt, bool useHashing)
{
/*
* Reference to: Syed Moshiur - Software Developer
* http://www.codeproject.com/Articles/14150/Encrypt-and-Decrypt-Data-with-C
*
*/
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));
//If hashing use get hashcode regards to your key
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
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.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);
}
public static string DecryptString(string passphrase, string Message)
{
byte[] Results;
UTF8Encoding UTF8 = new 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);
}
catch (Exception ex)
{
TDESAlgorithm.Clear();
HashProvider.Clear();
return ex.ToString();
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return UTF8.GetString(Results);
}
/*Sub Header***********************************************************
Function Name: Encrypt
Functionality: This function will upload files to location specified by concating id with the file.
Input: FileUpload,string,int
Output: int
Use format: href='<%# Eval("WebPage") + "?ServiceTypeID=" + HttpUtility.UrlEncode(BLL.CommonFunctions.Encrypt(Eval("ServiceTypeID").ToString()))
Note: Any Special comment
*********************************************************************/
public static string Encrypt(string toEncrypt)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
string key = ")(*&";
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data of the Cryptographic service provide. Best Practice
hashmd5.Clear();
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>
/// 计算字符串的MD5值
/// </summary>
public static string md5(string source)
{
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
byte[] data = System.Text.Encoding.UTF8.GetBytes(source);
byte[] md5Data = md5.ComputeHash(data, 0, data.Length);
md5.Clear();
string destString = "";
for (int i = 0; i < md5Data.Length; i++)
{
destString += System.Convert.ToString(md5Data[i], 16).PadLeft(2, '0');
}
destString = destString.PadLeft(32, '0');
return destString;
}
/// <summary>
/// HashString(string Value)用于将密码加密
/// 将Value用MD5加密，返回加密后的字串
/// </summary>
public static string HashString(string Value)
{
byte[] bytValue;
byte[] bytHash;
MD5CryptoServiceProvider mhash;
mhash = new MD5CryptoServiceProvider();
// Convert the original string to array of Bytes
bytValue = System.Text.Encoding.UTF8.GetBytes(Value);
// Compute the Hash, returns an array of Bytes
bytHash = mhash.ComputeHash(bytValue);
mhash.Clear();
// Return a base 64 encoded string of the Hash value
return Convert.ToBase64String(bytHash);
}
/// <summary>
///[作废] 游戏数据 -> 报账码
/// </summary>
/// <param name="gainTotal"></param>
/// <param name="gainCurrent"></param>
/// <param name="tableIdx"></param>
/// <param name="numPrint"></param>
/// <param name="codeComfirm"></param>
/// <returns></returns>
//public static uint DataToPrintCode(int gainTotal,int gainCurrent, uint tableIdx,uint numPrint, uint codeComfirm)
//{
// List<byte> dataCollect = new List<byte>();
// byte[] byteBuf = BitConverter.GetBytes(gainTotal);
// foreach (byte b in byteBuf)
// dataCollect.Add(b);
// byteBuf = BitConverter.GetBytes(gainCurrent);
// foreach (byte b in byteBuf)
// dataCollect.Add(b);
// byteBuf = BitConverter.GetBytes(tableIdx);
// foreach (byte b in byteBuf)
// dataCollect.Add(b);
// byteBuf = BitConverter.GetBytes(numPrint);
// foreach (byte b in byteBuf)
// dataCollect.Add(b);
// byteBuf = BitConverter.GetBytes(codeComfirm);
// foreach (byte b in byteBuf)
// dataCollect.Add(b);
// MD5 md5 = new MD5CryptoServiceProvider();
// byte[] md5data = md5.ComputeHash(dataCollect.ToArray());//计算data字节数组的哈希值
// md5.Clear();
// for (int i = 0; i != 4; ++i)
// md5data[i+12] = (byte)(md5data[i] ^ md5data[i + 4] ^ md5data[i + 8] ^ md5data[i + 12]);
// uint outCode = BitConverter.ToUInt32(md5data, 12);//取最后12位
// outCode %= 100000000;//得出8位码
// return outCode;
//}
/// <summary>
/// 生成四位验证码
/// </summary>
/// <param name="gainTotal">总盈利数</param>
/// <param name="gainCurrent">当期盈利数</param>
/// <param name="lineIdx">线号</param>
/// <param name="tableIdx">台号</param>
/// <param name="numPrint">打码次数</param>
/// <param name="formulaCode">公式码</param>
/// <param name="gameIdx">游戏索引</param>
/// <remarks>
/// 注意:
/// 1.为兼容以前版本,当判断 (formulaCode==0xffffffff && gameIdx==0xffffffff)时,则忽略formulaCode,gameIdx两个参数
/// </remarks>
/// <returns></returns>
public static uint GenerateComfirmCode(int gainTotal, int gainCurrent, int lineIdx, uint tableIdx, uint numPrint, uint formulaCode, uint gameIdx)
{
int[] code;
if (formulaCode == 0xffffffff && gameIdx == 0xffffffff)//为兼容以前版本
{
code = new int[] { gainTotal, gainCurrent, lineIdx, (int)tableIdx, (int)numPrint };
}
else
{
code = new int[] { gainTotal, gainCurrent, lineIdx, (int)tableIdx, (int)numPrint, (int)formulaCode, (int)gameIdx };
}
List<byte> dataCollect = new List<byte>();
foreach (int c in code)
{
byte[] byteBuf = BitConverter.GetBytes(c);//将int值转为byte数组(1 int = 4 byte)
foreach (byte b in byteBuf)
dataCollect.Add(b);
}
MD5 md5 = new MD5CryptoServiceProvider();
byte[] md5data = md5.ComputeHash(dataCollect.ToArray());//计算data字节数组的哈希值
md5.Clear();
for (int i = 0; i != 4; ++i)
md5data[i + 12] = (byte)(md5data[i] ^ md5data[i + 4] ^ md5data[i + 8] ^ md5data[i + 12]);
uint outCode = BitConverter.ToUInt32(md5data, 12);//取得最后12位
outCode %= 10000;
return outCode;
}
///<summary>
///MD5加密
///<param name="strPwd">被加密的字符串</param>
///<returns>返回被加密后的字符串</returns>
///</summary>
public string GetMD5(string strPwd)
{
MD5 md5 = new MD5CryptoServiceProvider();
byte[] data = System.Text.Encoding.Default.GetBytes(strPwd);
byte[] md5data = md5.ComputeHash(data);
md5.Clear();
string str = "";
for(int i = 0; i < md5data.Length-1; i++)
{
str += md5data[i].ToString("x").PadLeft(2, '0');
}
return str;
}
