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); }