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