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);
}
//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, 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);
}
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 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);
}
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 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 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 string Decrypt(string input)
{
byte[] results;
var utf8 = new System.Text.UTF8Encoding();
var hashProvider = new MD5CryptoServiceProvider();
var tdesKey = hashProvider.ComputeHash(utf8.GetBytes(_key));
var tdesAlgorithm = new TripleDESCryptoServiceProvider {
Key = tdesKey, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
};
var dataToDecrypt = Convert.FromBase64String(input);
try
{
ICryptoTransform decryptor = tdesAlgorithm.CreateDecryptor();
results = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length);
}
finally
{
tdesAlgorithm.Clear();
hashProvider.Clear();
}
return(utf8.GetString(results));
}
public static string Encrypt(string dataToEncrypt)
{
if (dataToEncrypt != null && dataToEncrypt.Trim() != "")
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(dataToEncrypt);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(Cryptography.SECURITYKEY));
hashmd5.Clear();
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));
}
else
{
return(dataToEncrypt);
}
}
public string cifrar(string cadena) // Función para cifrar una cadena.
{
byte[] llave; //Array donde guardaremos la llave para el cifrado 3DES.
byte[] arreglo = UTF8Encoding.UTF8.GetBytes(cadena); //Array donde guardaremos la cadena a cifrar.
// Ciframos utilizando el Algoritmo MD5.
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
llave = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(clave));
md5.Clear();
//Ciframos utilizando el Algoritmo 3DES.
TripleDESCryptoServiceProvider tripledes = new TripleDESCryptoServiceProvider();
tripledes.Key = llave;
tripledes.Mode = CipherMode.ECB;
tripledes.Padding = PaddingMode.PKCS7;
ICryptoTransform convertir = tripledes.CreateEncryptor();
// Iniciamos la conversión de la cadena
byte[] resultado = convertir.TransformFinalBlock(arreglo, 0, arreglo.Length);
//Arreglo de bytes donde guardaremos la cadena cifrada.
tripledes.Clear();
return(Convert.ToBase64String(resultado, 0, resultado.Length)); // Convertimos la cadena y la regresamos.
}
//For Decryption
public static string DecryptPassword(string DecryptText)
{
byte[] SecratekeyArray;
byte[] DecryptArray = Convert.FromBase64String(DecryptText);
SecratekeyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider objtripledes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
MD5CryptoServiceProvider objmd5crypto = new MD5CryptoServiceProvider();
SecratekeyArray = objmd5crypto.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
objmd5crypto.Clear();
objtripledes.Key = SecratekeyArray;
//Mode of Encreption.
objtripledes.Mode = CipherMode.ECB;
objtripledes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = objtripledes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(DecryptArray, 0, DecryptArray.Length);
//Release resources
objtripledes.Clear();
//For returning the the Clear decrypted TEXT
return(UTF8Encoding.UTF8.GetString(resultArray));
}
//giải mã bằng 3DES
public static string DecryptDataByTripleDES(string Message, string password)
{
byte[] Results;
var UTF8 = new UTF8Encoding();
var HashProvider = new MD5CryptoServiceProvider();
var TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = HashProvider.ComputeHash(UTF8.GetBytes(password));
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
var DataToDecrypt = Convert.FromBase64String(Message);
try
{
Results = TDESAlgorithm.CreateDecryptor().TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return(UTF8.GetString(Results));
}
public string Encriptar(string texto)
{
byte[] keyArray;
byte[] Arreglo_a_Cifrar = UTF8Encoding.UTF8.GetBytes(texto);
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));
}
/// <summary>
/// DeCrypt a string using dual encryption method
/// </summary>
/// <param name="cipherString">Must be encrypted string</param>
/// <param name="salt">Must be some random key for extra secirity</param>
/// <returns>Return a DeCrypted clear string</returns>
public static string Decrypt(string cipherString, string salt)
{
byte[] keyArray;
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(salt));
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(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(Encoding.UTF8.GetString(resultArray));
}
public static string Decrypt(string encryptedText)
{
byte[] llave;
byte[] arreglo = Convert.FromBase64String(encryptedText); // Arreglo donde guardaremos la cadena descovertida.
// Ciframos utilizando el Algoritmo MD5.
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
llave = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes(clave));
md5.Clear();
//Ciframos utilizando el Algoritmo 3DES.
TripleDESCryptoServiceProvider tripledes = new TripleDESCryptoServiceProvider();
tripledes.Key = llave;
tripledes.Mode = CipherMode.ECB;
tripledes.Padding = PaddingMode.PKCS7;
ICryptoTransform convertir = tripledes.CreateDecryptor();
byte[] resultado = convertir.TransformFinalBlock(arreglo, 0, arreglo.Length);
tripledes.Clear();
string cadena_descifrada = UTF8Encoding.UTF8.GetString(resultado); // Obtenemos la cadena
return(cadena_descifrada); // Devolvemos la cadena
}
public static string Decrypt(string cipherString)
{
const string key = "TPE";
var toEncryptArray = Convert.FromBase64String(cipherString);
var hashmd5 = new MD5CryptoServiceProvider();
var keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
var tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
var cTransform = tdes.CreateDecryptor();
var resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(Encoding.UTF8.GetString(resultArray));
}
public static string Encrypt(object data)
{
var json = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(data);
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(json);
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[] resultArray = cTransform.TransformFinalBlock
(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/// <summary>
/// Metodo para encriptar
/// </summary>
/// <param name="TextForCrypto">Cadena a encriptar</param>
/// <returns>Regresa una cadena con el texto encriptado</returns>
public String CryptoString(string TextForCrypto)
{
byte[] keyArray;
byte[] ArrayForCrypto = UTF8Encoding.UTF8.GetBytes(TextForCrypto);
MD5CryptoServiceProvider HashMD5 = new MD5CryptoServiceProvider();
keyArray = HashMD5.ComputeHash(UTF8Encoding.UTF8.GetBytes(this.KeyCrypto));
HashMD5.Clear();
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(ArrayForCrypto, 0, ArrayForCrypto.Length);
tdes.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
public string AdvancedEncrypt(string input)
{
if (!string.IsNullOrEmpty(input))
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(input);
string key = "cohort35";
MD5CryptoServiceProvider hash = new MD5CryptoServiceProvider();
keyArray = hash.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hash.Clear();
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform ctrans = tdes.CreateEncryptor();
byte[] resultArray = ctrans.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
return(null);
}
public static string Encrypt(string PlainText)
{
try
{
string key = CommonObjects.GetCongifValue(ConfigKeys.TripleDesKey);
byte[] iv1 = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
byte[] PlainTextArray = UTF8Encoding.UTF8.GetBytes(PlainText);
byte[] keyArray = MD5.CreateMd5ByteArray(key);
TripleDESCryptoServiceProvider TripleDes = new TripleDESCryptoServiceProvider();
TripleDes.Key = keyArray;
TripleDes.Mode = CipherMode.ECB;
TripleDes.Padding = PaddingMode.PKCS7;
TripleDes.IV = iv1;
ICryptoTransform cTransform = TripleDes.CreateEncryptor();
byte[] CipherString = cTransform.TransformFinalBlock(PlainTextArray, 0, PlainTextArray.Length);
TripleDes.Clear();
return(Convert.ToBase64String(CipherString, 0, CipherString.Length));
}
catch (Exception)
{
throw;
}
}
public static string Encrypt(string PlainText)
{
byte[] toEncryptedArray = UTF8Encoding.UTF8.GetBytes(PlainText);
MD5CryptoServiceProvider objMD5CryptoService = new MD5CryptoServiceProvider();
byte[] securityKeyArray = objMD5CryptoService.ComputeHash(UTF8Encoding.UTF8.GetBytes(_securityKey));
objMD5CryptoService.Clear();
var objTripleDESCryptoService = new TripleDESCryptoServiceProvider();
objTripleDESCryptoService.Key = securityKeyArray;
objTripleDESCryptoService.Mode = CipherMode.ECB;
objTripleDESCryptoService.Padding = PaddingMode.PKCS7;
var objCrytpoTransform = objTripleDESCryptoService.CreateEncryptor();
byte[] resultArray = objCrytpoTransform.TransformFinalBlock(toEncryptedArray, 0, toEncryptedArray.Length);
objTripleDESCryptoService.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/**
* TripleDESCryptoServiceProvider
* Legal min key size = 128
* Legal max key size = 192
* Legal min block size = 64
* Legal max block size = 64
* */
public string encrypt(string toEncrypt)
{
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
// Get the key from config file
//192 64 s6RDEWiv+mQ= iFGC3Nx1XvUCfDbHTKg8BEPIlJ+oLM7l
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.IV = Convert.FromBase64String("s6RDEWiv+mQ=");
tdes.Key = Convert.FromBase64String("iFGC3Nx1XvUCfDbHTKg8BEPIlJ+oLM7l");
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 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 Decrypt(string input)
{
try
{
byte[] key = new byte[16] {
3, 3, 3, 5, 222, 13, 155, 55, 122, 123, 165, 187, 188, 1, 11, 133
};
byte[] inputArray = Convert.FromBase64String(input);
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Key = key;// UTF8Encoding.UTF8.GetBytes(key);
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tripleDES.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
tripleDES.Clear();
return(UTF8Encoding.UTF8.GetString(resultArray));
}
catch (Exception ex)
{
// don't throw from here.
return("");
}
}
public string Decrypt(string cypherString, string key, bool useHasing)
{
byte[] toDecryptArray = Convert.FromBase64String(cypherString);
var keyArray = GetKeyArray(key, useHasing);
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 DecryptString(string Message)
{
byte[] Results;
System.Text.UTF8Encoding UTF8 = new System.Text.UTF8Encoding();
MD5CryptoServiceProvider HashProvider = new MD5CryptoServiceProvider();
byte[] TDESKey = HashProvider.ComputeHash(UTF8.GetBytes("india123"));
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = TDESKey;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
byte[] DataToDecrypt = Convert.FromBase64String(Message);
try
{
ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
HashProvider.Clear();
}
return UTF8.GetString(Results);
}
/// <summary>Encrypts the specified data with a key</summary>
/// <param name="data">The data.</param>
/// <param name="key">The key.</param>
/// <returns>Return data encrypted</returns>
public static string Encrypt(string data, string key)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
byte[] dataArray = Encoding.UTF8.GetBytes(data);
byte[] keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(key));
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform desEncrypt = tdes.CreateEncryptor();
byte[] stringEncrypt = desEncrypt.TransformFinalBlock(dataArray, 0, dataArray.Length);
tdes.Clear();
hashmd5.Clear();
return(Convert.ToBase64String(stringEncrypt));
}
public static string Decrypt(string input, string key)
{
byte[] properkey = GetKey(key);
byte[] inputArray = Convert.FromBase64String(input);
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Key = properkey;
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tripleDES.CreateDecryptor();
try
{
byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
tripleDES.Clear();
return(Encoding.UTF8.GetString(resultArray));
}
catch (System.Exception ex)
{
}
return("");
}
public string TDESCifrar(string clave, string cadena)
{
//Arreglo donde guardaremos la cadena descifrada.
byte[] arreglo = Encoding.UTF8.GetBytes(cadena);
// Ciframos utilizando el Algoritmo MD5.
var md5 = new MD5CryptoServiceProvider();
byte[] llave = md5.ComputeHash(Encoding.UTF8.GetBytes(clave));
md5.Clear();
//Ciframos utilizando el Algoritmo 3DES.
var tripledes = new TripleDESCryptoServiceProvider
{
Key = llave, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
};
// Iniciamos la conversión de la cadena
ICryptoTransform convertir = tripledes.CreateEncryptor();
//Arreglo de bytes donde guardaremos la cadena cifrada.
byte[] resultado = convertir.TransformFinalBlock(arreglo, 0, arreglo.Length);
tripledes.Clear();
// Convertimos la cadena y la regresamos.
return(Convert.ToBase64String(resultado, 0, resultado.Length));
}
public static string Encrypt(string password)
{
var saltSize = 16;
var keySize = 16;
var iterations = 10000;
byte[] key;
byte[] data = Encoding.UTF32.GetBytes(password);
using (var algorithm = new Rfc2898DeriveBytes(password, saltSize, iterations, HashAlgorithmName.SHA512))
{
key = algorithm.GetBytes(keySize);
}
using (TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider())
{
tdes.Key = key;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
byte[] output = tdes.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
tdes.Clear();
return(Convert.ToBase64String(output, 0, output.Length));
}
}
public string DecryptStringFromBytesAes(Message mess)
{
string str = mess.GetString();
byte[] Results;
TripleDESCryptoServiceProvider TDESAlgorithm = new TripleDESCryptoServiceProvider();
TDESAlgorithm.Key = Key;
TDESAlgorithm.IV = IV;
TDESAlgorithm.Mode = CipherMode.ECB;
TDESAlgorithm.Padding = PaddingMode.PKCS7;
byte[] DataToDecrypt = Convert.FromBase64String(str);
try
{
ICryptoTransform Decryptor = TDESAlgorithm.CreateDecryptor();
Results = Decryptor.TransformFinalBlock(DataToDecrypt, 0, DataToDecrypt.Length);
}
finally
{
TDESAlgorithm.Clear();
}
return(Encoding.Unicode.GetString(Results));
}
/// <summary>
/// This method allow the user to encrypt information based on the key provided
/// </summary>
/// <param name="dataToEncrypt"></param>
/// <returns></returns>
public string EncryptData(string dataToEncrypt, string encryDecryptionKey)
{
this.encryDecryptionKey = encryDecryptionKey;
if (this.encryDecryptionKey == string.Empty)
{
throw new Exception("The encription key can not be empty");
}
string encryptResult = string.Empty;
byte[] inputArray = UTF8Encoding.UTF8.GetBytes(dataToEncrypt);
TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
tripleDES.Key = UTF8Encoding.UTF8.GetBytes(this.encryDecryptionKey);
tripleDES.Mode = CipherMode.ECB;
tripleDES.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tripleDES.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length);
tripleDES.Clear();
encryptResult = Convert.ToBase64String(resultArray, 0, resultArray.Length);
return(encryptResult);
}
public static byte[] EncryptTDES(byte[] toEncryptArray, byte[] keyArray, bool useHasing)
{
if (useHasing)
{
using (var hashmd5 = new MD5CryptoServiceProvider())
{
keyArray = hashmd5.ComputeHash(keyArray);
hashmd5.Clear();
}
}
using (var tDes = new TripleDESCryptoServiceProvider {
Key = keyArray, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7
})
{
using (ICryptoTransform cTransform = tDes.CreateEncryptor())
{
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tDes.Clear();
return(resultArray);
}
}
}
public string Encrypt(string src, string cryptoKey)
{
var toEncryptArray = Encoding.UTF8.GetBytes(src);
var hashmd5 = new MD5CryptoServiceProvider();
var keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(cryptoKey));
hashmd5.Clear();
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(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/// <summary>Encrypts the specified to string.</summary>
/// <param name="toEncrypt">the string to encrypt.</param>
/// <returns>Encrypted string</returns>
public static string Encrypt(string toEncrypt)
{
//Get string in bytes
var toEncryptArray = Encoding.UTF8.GetBytes(toEncrypt);
//get md5 hash of processor id
var hashmd5 = new MD5CryptoServiceProvider();
var keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(getProcessorID()));
hashmd5.Clear();
//Encrypt the string with Triple Des usng the hashed processor id.
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 the encrypted string
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
public static string cifrarPass(string sPass, int iOpcion)
{
byte[] llave;
byte[] arrCifrado = UTF8Encoding.UTF8.GetBytes(sPass);
MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
llave = md5.ComputeHash(UTF8Encoding.UTF8.GetBytes("zkteco"));
md5.Clear();
TripleDESCryptoServiceProvider tripledes = new TripleDESCryptoServiceProvider();
tripledes.Key = llave;
tripledes.Mode = CipherMode.ECB;
tripledes.Padding = PaddingMode.PKCS7;
ICryptoTransform convertir = tripledes.CreateEncryptor();
byte[] resultado = convertir.TransformFinalBlock(arrCifrado, 0, arrCifrado.Length);
tripledes.Clear();
string res = "";
res = Convert.ToBase64String(resultado, 0, resultado.Length);
return(res);
}
/// <summary>
/// Encrypt a string using dual encryption method. Return a encrypted cipher Text
/// </summary>
/// <param name="toEncrypt">string to be encrypted</param>
/// <param name="key">key for encrypt</param>
/// <returns></returns>
public static string Encrypt(string toEncrypt, string key)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
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[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return(Convert.ToBase64String(resultArray, 0, resultArray.Length));
}
/// <summary>Decrypts the specified data with default key</summary>
/// <param name="data">The data.</param>
/// <returns>Return data decrypted</returns>
public static string Decrypt(string data)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
byte[] dataEncrypted = Convert.FromBase64String(data);
byte[] keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes(DefaultKey));
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider
{
Key = keyArray,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform desEncrypt = tdes.CreateDecryptor();
byte[] stringDecrypted = desEncrypt.TransformFinalBlock(dataEncrypted, 0, dataEncrypted.Length);
hashmd5.Clear();
tdes.Clear();
return(Encoding.UTF8.GetString(stringDecrypted));
}
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);
}
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 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);
}
/*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);
}
