public ICrypt Initialize(string key) { _algo?.Dispose(); using (var hashProvider = new MD5CryptoServiceProvider()) _algo = new TripleDESCryptoServiceProvider() { Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7, Key = hashProvider.ComputeHash(Encoding.UTF8.GetBytes(key)) }; return(this); }
public void Dispose() { if (_algo != null) { _algo.Dispose(); } }
/// <summary> /// DES3 CBC模式解密 /// </summary> /// <param name="key">密钥</param> /// <param name="iv">IV</param> /// <param name="data">密文的byte数组</param> /// <returns>明文的byte数组</returns> public static byte[] Des3DecodeCBC(byte[] key, byte[] iv, byte[] data) { try { // Create a new MemoryStream using the passed // array of encrypted data. MemoryStream msDecrypt = new MemoryStream(data); TripleDESCryptoServiceProvider tdsp = new TripleDESCryptoServiceProvider(); tdsp.Mode = CipherMode.CBC; tdsp.Padding = PaddingMode.PKCS7; // Create a CryptoStream using the MemoryStream // and the passed key and initialization vector (IV). CryptoStream csDecrypt = new CryptoStream(msDecrypt, tdsp.CreateDecryptor(key, iv), CryptoStreamMode.Read); // Create buffer to hold the decrypted data. byte[] fromEncrypt = new byte[data.Length]; // Read the decrypted data out of the crypto stream // and place it into the temporary buffer. csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length); //Convert the buffer into a string and return it. msDecrypt.Dispose(); tdsp.Dispose(); csDecrypt.Dispose(); return(fromEncrypt); } catch (CryptographicException ex) { Logging.Log4NetHelper.Error(typeof(EncryptionLib), ex); throw; } }
//使用TripleDES加密 public static byte[] Crypt(byte[] source, byte[] key) { if ((source.Length == 0) || (source == null) || (key == null) || (key.Length == 0)) { throw new ArgumentException("Invalid Argument"); } TripleDESCryptoServiceProvider dsp = null; try { dsp = new TripleDESCryptoServiceProvider(); dsp.Mode = CipherMode.ECB; ICryptoTransform des = dsp.CreateEncryptor(key, null); return(des.TransformFinalBlock(source, 0, source.Length)); } finally { if (dsp != null) { dsp.Dispose(); } } }
/// <summary> /// Loads serialized object from the file /// </summary> public static T LoadDecryptedDes <T>(string key, string iv, string fileName = null) where T : class { // build file path fileName = SerializationHelper.GetFilePath <T>(fileName); // check if file exists if (!System.IO.File.Exists(fileName)) { return(null); } T res; using (var decryptor = new TripleDESCryptoServiceProvider()) { decryptor.Key = Encoding.Default.GetBytes(key); decryptor.IV = Encoding.Default.GetBytes(iv); res = SerializationHelper.DecryptAndDeserialize(fileName, typeof(T), new Type[] { }, decryptor) as T; decryptor.Dispose(); } return(res); }
/// <summary> /// EncryptBase64 /// </summary> /// <param name="StringToEncrypt"></param> /// <param name="Key"></param> /// <param name="IV"></param> /// <returns></returns> private static string EncryptBase64(string StringToEncrypt, byte[] Key, byte[] IV) { TripleDESCryptoServiceProvider tripledes; MemoryStream ms; CryptoStream cs; try { tripledes = new TripleDESCryptoServiceProvider(); byte[] inputByteArray = Encoding.UTF8.GetBytes(StringToEncrypt); ms = new MemoryStream(); cs = new CryptoStream(ms, tripledes.CreateEncryptor(Key, IV), CryptoStreamMode.Write); cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); String str = Convert.ToBase64String(ms.ToArray()); cs.Clear(); tripledes.Dispose(); return(str); } catch (Exception) { throw; } finally { tripledes = null; ms = null; cs = null; } }
/// <summary> /// Encrypt a string using a static key and TripleDES /// </summary> /// <param name="data">The string that needs to be encrypted</param> /// <returns>Encrypted string</returns> public static string BBSEncrypt(string data) { if (Testing) { return(data); } else { MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider(); byte[] keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes("bbspabx")); TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider { Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7, Key = keyArray }; try { ICryptoTransform cTransform = tdes.CreateEncryptor(); byte[] resultArray = cTransform.TransformFinalBlock(Encoding.UTF8.GetBytes(data), 0, Encoding.UTF8.GetBytes(data).Length); tdes.Clear(); return(Convert.ToBase64String(resultArray, 0, resultArray.Length)); } catch (Exception ex) { MessageBox.Show(ex.Message); return(ex.Message); } finally { hashmd5.Dispose(); tdes.Dispose(); } } }
public static string Encrypt(string mString, string mKey) { if (mString == "") { return(mString); } TripleDESCryptoServiceProvider cryptdes3 = new TripleDESCryptoServiceProvider(); MD5CryptoServiceProvider hash = new MD5CryptoServiceProvider(); try { cryptdes3.Key = hash.ComputeHash(ASCIIEncoding.ASCII.GetBytes(mKey)); cryptdes3.Mode = CipherMode.ECB; ICryptoTransform enc = cryptdes3.CreateEncryptor(); byte[] buff = ASCIIEncoding.ASCII.GetBytes(mString); return(Convert.ToBase64String(enc.TransformFinalBlock(buff, 0, buff.Length))); } catch (Exception ex) { throw new Exception("Bad Data", ex); } finally { cryptdes3.Dispose(); hash.Dispose(); } }
/// <summary> /// Decrypt the given string using the specified key. /// </summary> /// <param name="textToDecrypt">The string to be encrypted</param> /// <param name="SecurePhrase">The Secure Phrase used to decryption</param> /// <returns>The Decrypted string.</returns> public static string Decrypt(string textToDecrypt, string SecurePhrase) { try { var oTripleDESCryptoServiceProvider = new TripleDESCryptoServiceProvider(); var oMD5CryptoServiceProvider = new MD5CryptoServiceProvider(); byte[] byteHash, byteBuff; byteHash = oMD5CryptoServiceProvider.ComputeHash(ASCIIEncoding.ASCII.GetBytes(SecurePhrase)); oTripleDESCryptoServiceProvider.Key = byteHash; oTripleDESCryptoServiceProvider.Mode = CipherMode.ECB; //CBC, CFB byteBuff = Convert.FromBase64String(textToDecrypt); string Aux = ASCIIEncoding.ASCII.GetString(oTripleDESCryptoServiceProvider.CreateDecryptor().TransformFinalBlock(byteBuff, 0, byteBuff.Length)); oTripleDESCryptoServiceProvider.Dispose(); oMD5CryptoServiceProvider.Dispose(); return(Aux); } catch (Exception ex) { return("Framework.Cryptography: " + ex.Message); } }
/// <summary> /// 解密 /// </summary> /// <param name="data"></param> /// <param name="key"></param> /// <returns></returns> public static string DES3Decrypt(string data, string key) { TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider(); DES.Key = ASCIIEncoding.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 = ASCIIEncoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length)); } catch (Exception ex) { Logging.Log4NetHelper.Error(typeof(EncryptionLib), ex); throw; } DES.Dispose(); return(result); }
/// <summary> /// This method is used to convert the plain text to Encrypted/Un-Readable Text format. /// </summary> /// <param name="PlainText">Plain Text to Encrypt before transferring over the network.</param> /// <returns>Cipher Text</returns> public string EncryptPassword(string input) { string hash = string.Empty; MD5CryptoServiceProvider objMD5CryptoService = null; TripleDESCryptoServiceProvider objTripleDESCryptoService = null; try { objStringBuilder.AppendLine("Begin: Utility-Common-EncryptPassword using MD5"); //Getting the bytes of Input String. byte[] toEncryptedArray = UTF8Encoding.UTF8.GetBytes(input); objMD5CryptoService = new MD5CryptoServiceProvider(); //Gettting the bytes from the Security Key and Passing it to compute the Corresponding Hash Value. byte[] securityKeyArray = objMD5CryptoService.ComputeHash(UTF8Encoding.UTF8.GetBytes(_securityKey)); //De-allocatinng the memory after doing the Job. objMD5CryptoService.Clear(); objTripleDESCryptoService = new TripleDESCryptoServiceProvider(); //Assigning the Security key to the TripleDES Service Provider. objTripleDESCryptoService.Key = securityKeyArray; //Mode of the Crypto service is Electronic Code Book. objTripleDESCryptoService.Mode = CipherMode.ECB; //Padding Mode is PKCS7 if there is any extra byte is added. objTripleDESCryptoService.Padding = PaddingMode.PKCS7; var objCrytpoTransform = objTripleDESCryptoService.CreateEncryptor(); //Transform the bytes array to resultArray byte[] resultArray = objCrytpoTransform.TransformFinalBlock(toEncryptedArray, 0, toEncryptedArray.Length); //Releasing the Memory Occupied by TripleDES Service Provider for Encryption. objTripleDESCryptoService.Clear(); //Convert and return the encrypted data/byte into string format. hash = Convert.ToBase64String(resultArray, 0, resultArray.Length); } catch (Exception error) { LogManager.LogManagerInstance.WriteErrorLog(error); } finally { objMD5CryptoService.Dispose(); objTripleDESCryptoService.Dispose(); objStringBuilder.AppendLine("End: Utility-Common-EncryptDecrypt-EncryptString"); LogManager.LogManagerInstance.WriteTraceLog(objStringBuilder); } return(hash); }
// IDisposable protected virtual void Dispose(bool disposing) { if (!disposedValue) { if (disposing) { TripleDes.Dispose(); } } disposedValue = true; }
private static string SubDecrypt(string cipherString, bool useHashing, string customKey) { MD5CryptoServiceProvider hashmd5 = null; TripleDESCryptoServiceProvider tdes = null; ICryptoTransform cTransform = null; try { byte[] keyArray; byte[] toEncryptArray = toEncryptArray = Convert.FromBase64String(cipherString); if (useHashing) { hashmd5 = new MD5CryptoServiceProvider(); keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(customKey)); hashmd5.Clear(); } else { keyArray = UTF8Encoding.UTF8.GetBytes(Key); } tdes = new TripleDESCryptoServiceProvider(); tdes.Key = keyArray; tdes.Mode = CipherMode.ECB; tdes.Padding = PaddingMode.PKCS7; cTransform = tdes.CreateDecryptor(); byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); tdes.Clear(); return(UTF8Encoding.UTF8.GetString(resultArray)); } catch (Exception) { throw; } finally { if (hashmd5 != null) { hashmd5.Dispose(); } if (tdes != null) { tdes.Dispose(); } if (cTransform != null) { cTransform.Dispose(); } } }
public byte[] CreateEncryptionKey() { var keyProvider = new TripleDESCryptoServiceProvider(); keyProvider.KeySize = 192; keyProvider.GenerateKey(); var key = keyProvider.Key; keyProvider.Dispose(); EncryptionKey = key; return(key); }
protected virtual void Dispose(bool _disposing) { if (_disposing) { if (tdes == null) { return; } tdes.Clear(); tdes.Dispose(); tdes = null; } }
/// <summary> /// Saves object to the file /// </summary> public static void SaveEncryptedDes <T>(T obj, string key, string iv, string fileName = null) where T : class { fileName = SerializationHelper.GetFilePath <T>(fileName); using (var encryptor = new TripleDESCryptoServiceProvider()) { encryptor.Key = Encoding.Default.GetBytes(key); encryptor.IV = Encoding.Default.GetBytes(iv); SerializationHelper.EncryptAndSerialize(fileName, obj, new Type[] { }, encryptor); encryptor.Dispose(); } }
/// <summary> /// 加密 /// </summary> /// <param name="data"></param> /// <param name="key"></param> /// <returns></returns> public static string DES3Encrypt(string data, string key) { TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider(); DES.Key = ASCIIEncoding.ASCII.GetBytes(key); DES.Mode = CipherMode.CBC; DES.Padding = PaddingMode.PKCS7; ICryptoTransform DESEncrypt = DES.CreateEncryptor(); byte[] Buffer = ASCIIEncoding.ASCII.GetBytes(data); DES.Dispose(); return(Convert.ToBase64String(DESEncrypt.TransformFinalBlock(Buffer, 0, Buffer.Length))); }
public static string Encrypt(string toEncrypt, bool useHashing, string customKey) { MD5CryptoServiceProvider hashmd5 = null; TripleDESCryptoServiceProvider tdes = null; ICryptoTransform cTransform = null; byte[] keyArray; byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt); if (useHashing) { hashmd5 = new MD5CryptoServiceProvider(); keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(customKey)); hashmd5.Clear(); } else { keyArray = UTF8Encoding.UTF8.GetBytes(Key); } tdes = new TripleDESCryptoServiceProvider(); tdes.Key = keyArray; tdes.Mode = CipherMode.ECB; tdes.Padding = PaddingMode.PKCS7; cTransform = tdes.CreateEncryptor(); byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); tdes.Clear(); if (hashmd5 != null) { hashmd5.Dispose(); } if (tdes != null) { tdes.Dispose(); } if (cTransform != null) { cTransform.Dispose(); } return(Convert.ToBase64String(resultArray, 0, resultArray.Length) + delimited); }
// Dispose(bool disposing) executes in two distinct scenarios. // If disposing equals true, the method has been called directly // or indirectly by a user's code. Managed and unmanaged resources // can be disposed. // If disposing equals false, the method has been called by the // runtime from inside the finalizer and you should not reference // other objects. Only unmanaged resources can be disposed. protected virtual void Dispose(bool disposing) { // Check to see if Dispose has already been called. if (!this.disposed) { // If disposing equals true, dispose all managed // and unmanaged resources. if (disposing) { // Dispose managed resources. tripleDes.Dispose(); } // Note disposing has been done. disposed = true; } }
/// <summary> /// Generic DES Decryption Function /// </summary> /// <param name="data"></param> /// <param name="key"></param> /// <param name="iv"></param> /// <param name="padding"></param> /// <param name="mode"></param> /// <returns></returns> internal static byte[] TripleDESDecrypt(byte[] data, byte[] key, byte[] iv, PaddingMode padding, CipherMode mode) { try { var algorithm = new TripleDESCryptoServiceProvider { Padding = padding, Mode = mode }; ICryptoTransform decryptor = algorithm.CreateDecryptor(key, iv); var retVal = Crypter(data, key, iv, decryptor); decryptor.Dispose(); algorithm.Dispose(); return(retVal); } catch (CryptographicException ex) { throw new ApplicationException("Error during Triple DES decryption of license code.", ex); } }
/// <summary> /// Encripta el texto que se le pasa como parámetro /// </summary> /// <param name="text">Texto a encriptar</param> /// <returns>Resultado de la encriptación</returns> public string EncryptKey(string text) { byte[] keyArray; byte[] arrayToEncript = UTF8Encoding.UTF8.GetBytes(text); TripleDESCryptoServiceProvider tdes = null; byte[] result; MD5CryptoServiceProvider hashmd5 = null; try { //MD5 hashmd5 = new MD5CryptoServiceProvider(); keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); hashmd5.Clear(); //3DAS tdes = new TripleDESCryptoServiceProvider { Key = keyArray, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 }; ICryptoTransform cTransform = tdes.CreateEncryptor(); result = cTransform.TransformFinalBlock(arrayToEncript, 0, arrayToEncript.Length); tdes.Clear(); } finally { if (tdes != null) { tdes.Dispose(); } if (hashmd5 != null) { hashmd5.Dispose(); } } //Result return(Convert.ToBase64String(result, 0, result.Length)); }
/// <summary> /// Private method to DES3 decryption. /// </summary> /// <param name="encryptedValue">DES3 encrypted string</param> /// <returns>clear text string</returns> /// <remarks></remarks> private static string decryptTripleDES(string encryptedValue) { string mRetVal = string.Empty; TripleDESCryptoServiceProvider mCryptoProvider = null; MemoryStream mMemoryStream = null; if (!string.IsNullOrEmpty(encryptedValue)) { try { mCryptoProvider = new TripleDESCryptoServiceProvider(); if (isBase64String(encryptedValue)) { //convert from string to byte array byte[] buffer = Convert.FromBase64String(encryptedValue); mMemoryStream = new MemoryStream(buffer); CryptoStream mCryptoStream = new CryptoStream(mMemoryStream, mCryptoProvider.CreateDecryptor(s_KEY_192, s_IV_192), CryptoStreamMode.Read); StreamReader mStreamReader = new StreamReader(mCryptoStream); mRetVal = mStreamReader.ReadToEnd(); } else { mRetVal = encryptedValue; } } catch (Exception ex) { throw new CryptoUtilityException("error using Decrypt Triple DES", ex); } finally { if (mCryptoProvider != null) { mCryptoProvider.Dispose(); } if (mMemoryStream != null) { mMemoryStream.Dispose(); } } } return(mRetVal); }
public static string Decrypt(string encryptedData) { try { byte[] inputArray = Convert.FromBase64String(encryptedData); SecurityCodecs codec = new SecurityCodecs(); TripleDESCryptoServiceProvider provider = codec.DES3Provider(); ICryptoTransform cTransform = provider.CreateDecryptor(); byte[] resultArray = cTransform.TransformFinalBlock(inputArray, 0, inputArray.Length); provider.Clear(); provider.Dispose(); codec.Dispose(); return(UTF32Encoding.UTF32.GetString(resultArray)); } catch { return(encryptedData); } }
/// <summary> /// Private method to perform DES3 encryption /// </summary> /// <param name="valueToEncrypt">String to be DES3 encrypted</param> /// <returns>Encrypted string</returns> /// <remarks></remarks> private static string encryptTripleDES(string valueToEncrypt) { string retVal = valueToEncrypt; if (!string.IsNullOrEmpty(valueToEncrypt)) { TripleDESCryptoServiceProvider mCryptoProvider = null; MemoryStream mMemoryStream = null; try { mCryptoProvider = new TripleDESCryptoServiceProvider(); mMemoryStream = new MemoryStream(); CryptoStream mCryptoStream = new CryptoStream(mMemoryStream, mCryptoProvider.CreateEncryptor(s_KEY_192, s_IV_192), CryptoStreamMode.Write); StreamWriter mStreamWriter = new StreamWriter(mCryptoStream); mStreamWriter.Write(valueToEncrypt); mStreamWriter.Flush(); mCryptoStream.FlushFinalBlock(); mMemoryStream.Flush(); //convert back to a string retVal = Convert.ToBase64String(mMemoryStream.GetBuffer(), 0, int.Parse(mMemoryStream.Length.ToString(CultureInfo.InvariantCulture), CultureInfo.InvariantCulture)); } catch (Exception ex) { throw new CryptoUtilityException("error using encrypt Triple DES", ex); } finally { if (mCryptoProvider != null) { mCryptoProvider.Dispose(); } if (mMemoryStream != null) { mMemoryStream.Dispose(); } } } return(retVal); }
/// <summary> /// Descrypt a string using a static key and TripleDES /// </summary> /// <param name="data">The encrypted string</param> /// <returns>Decrypted string</returns> public static string BBSDecrypt(string data) { if (Testing) { return(data); } else { MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider(); byte[] keyArray = hashmd5.ComputeHash(Encoding.UTF8.GetBytes("bbspabx")); TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider { Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7, Key = keyArray }; ICryptoTransform cTransform = tdes.CreateDecryptor(); try { byte[] b = Convert.FromBase64String(data); byte[] resultArrayA = cTransform.TransformFinalBlock(Convert.FromBase64String(data), 0, Convert.FromBase64String(data).Length); tdes.Clear(); return(Encoding.UTF8.GetString(resultArrayA)); } catch (FormatException e) { MessageBox.Show(e.ToString()); File.Delete("login_details.bbs"); //If there's an illegal character then the file is probably corrupt or hasn't been encrypted properly return(e.Message); } finally { hashmd5.Dispose(); tdes.Dispose(); } } }
/// <summary> /// DES3 CBC模式加密 /// </summary> /// <param name="key">密钥</param> /// <param name="iv">IV</param> /// <param name="data">明文的byte数组</param> /// <returns>密文的byte数组</returns> public static byte[] Des3EncodeCBC(byte[] key, byte[] iv, byte[] data) { //复制于MSDN try { // Create a MemoryStream. MemoryStream mStream = new MemoryStream(); TripleDESCryptoServiceProvider tdsp = new TripleDESCryptoServiceProvider(); tdsp.Mode = CipherMode.CBC; //默认值 tdsp.Padding = PaddingMode.PKCS7; //默认值 // Create a CryptoStream using the MemoryStream // and the passed key and initialization vector (IV). CryptoStream cStream = new CryptoStream(mStream, tdsp.CreateEncryptor(key, iv), CryptoStreamMode.Write); // Write the byte array to the crypto stream and flush it. cStream.Write(data, 0, data.Length); cStream.FlushFinalBlock(); // Get an array of bytes from the // MemoryStream that holds the // encrypted data. byte[] ret = mStream.ToArray(); // Close the streams. cStream.Close(); mStream.Close(); mStream.Dispose(); tdsp.Dispose(); cStream.Dispose(); // Return the encrypted buffer. return(ret); } catch (CryptographicException ex) { Logging.Log4NetHelper.Error(typeof(EncryptionLib), ex); throw; } }
public static byte[] Decrypt(byte[] source, byte[] key) { if ((source.Length == 0) || (source == null) || (key == null) || (key.Length == 0)) { throw new ArgumentNullException("Invalid Argument"); } TripleDESCryptoServiceProvider dsp = null; try { dsp = new TripleDESCryptoServiceProvider(); dsp.Mode = CipherMode.ECB; ICryptoTransform des = dsp.CreateDecryptor(key, null); byte[] ret = new byte[source.Length + 8]; int num; num = des.TransformBlock(source, 0, source.Length, ret, 0); ret = des.TransformFinalBlock(source, 0, source.Length); ret = des.TransformFinalBlock(source, 0, source.Length); num = ret.Length; byte[] RealByte = new byte[num]; Array.Copy(ret, RealByte, num); ret = RealByte; return(ret); }finally { if (dsp != null) { dsp.Dispose(); } } }
/// <summary> /// Encrypts/decrypts a byte array /// </summary> /// <param name="buffer">Bytes to crypt</param> /// <param name="key">"Password" for encryption</param> /// <param name="iv">"Salt" for encryption. A starting point for encryption.</param> /// <param name="encrypt">Do you wish to encrypt or decrypt?</param> /// <param name="algorithm">Encryption algorithm. AES/DES/TripleDES</param> /// <returns></returns> public static byte[] Crypt(byte[] buffer, byte[] key, byte[] iv, bool encrypt = true, string algorithm = "aes") { AesCryptoServiceProvider aes = null; DESCryptoServiceProvider des = null; TripleDESCryptoServiceProvider tripsDes = null; ICryptoTransform cryptor; switch (algorithm.ToLower()) { case "aes": aes = new AesCryptoServiceProvider(); aes.Key = key; aes.IV = iv; //aes.Padding = PaddingMode.None; if (encrypt) { cryptor = aes.CreateEncryptor(); } else { cryptor = aes.CreateDecryptor(); } break; case "des": des = new DESCryptoServiceProvider(); des.Key = key; des.IV = iv; //des.Padding = PaddingMode.None; if (encrypt) { cryptor = des.CreateEncryptor(); } else { cryptor = des.CreateDecryptor(); } break; case "tripledes": tripsDes = new TripleDESCryptoServiceProvider(); tripsDes.Key = key; tripsDes.IV = iv; //tripsDes.Padding = PaddingMode.None; if (encrypt) { cryptor = tripsDes.CreateEncryptor(); } else { cryptor = tripsDes.CreateDecryptor(); } break; default: throw new ArgumentException(algorithm + " is not an implemented encryption algorithm. Use AES/DES/TripleDES."); } try { return(cryptor.TransformFinalBlock(buffer, 0, buffer.Length)); } catch (CryptographicException) { throw new ArgumentException("Ensure you have the right key/IV."); } finally { cryptor.Dispose(); if (aes != null) { aes.Dispose(); } if (des != null) { des.Dispose(); } if (tripsDes != null) { tripsDes.Dispose(); } } }
/// <summary> /// Obtiene a partir de la firma, el versionid y el nombre del elemento /// </summary> /// <param name="signature">Firma</param> /// <param name="name">Nombre del elemento</param> /// para después desencriptar la firma de la aplicación</param> /// <returns>Version id y firma de la aplicación</returns> public KeyValuePair <Guid, string> GetInfoFromSignature(string signature, string name = null) { KeyValuePair <Guid, string> pairResult = new KeyValuePair <Guid, string>(); try { string result = string.Empty; if (!string.IsNullOrEmpty(signature)) { result = DecryptKey(signature); if (!string.IsNullOrEmpty(result)) { Guid versionId = new Guid(result.Split(delimiter).FirstOrDefault()); string text = GetSubString(result); if (versionId != null && !string.IsNullOrEmpty(text)) { pairResult = new KeyValuePair <Guid, string>(versionId, text); } } } } catch (Exception ex) { //log.ErrorException("Exception getting info from signature: ", ex); } return(pairResult); /// <summary> /// Obtener cadena a partir de un elemento delimitador /// </summary> /// <param name="text">Texto original</param> /// <returns>Texto a partir del delimietador</returns> string GetSubString(string text) { int init = 0; for (int i = text.Length - 1; i >= 0; i--) { if (text[i] == delimiter) { init = i; break; } } text = text.Substring(init + 1, text.Length - init - 1); return(text); } //Desencriptado de la firma string DecryptKey(string text) { byte[] keyArray; byte[] arrayToEncript = Convert.FromBase64String(text); TripleDESCryptoServiceProvider tdes = null; byte[] resultArray; MD5CryptoServiceProvider hashmd5 = null; try { //MD5 hashmd5 = new MD5CryptoServiceProvider(); keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key)); hashmd5.Clear(); //3DAS tdes = new TripleDESCryptoServiceProvider { Key = keyArray, Mode = CipherMode.ECB, Padding = PaddingMode.PKCS7 }; ICryptoTransform cTransform = tdes.CreateDecryptor(); resultArray = cTransform.TransformFinalBlock(arrayToEncript, 0, arrayToEncript.Length); tdes.Clear(); } finally { if (tdes != null) { tdes.Dispose(); } if (hashmd5 != null) { hashmd5.Dispose(); } } return(UTF8Encoding.UTF8.GetString(resultArray)); } }
/// <summary> /// Create a new SymCipher object with a random key based on the alg and mode supplied. /// </summary> /// <param name="symDef"></param> /// <param name="keyData"></param> /// <param name="iv"></param> /// <returns></returns> public static SymCipher Create(SymDefObject symDef = null, byte[] keyData = null, byte[] iv = null) { if (symDef == null) { symDef = new SymDefObject(TpmAlgId.Aes, 128, TpmAlgId.Cfb); } #if TSS_USE_BCRYPT BCryptAlgorithm alg = null; switch (symDef.Algorithm) { case TpmAlgId.Aes: alg = new BCryptAlgorithm(Native.BCRYPT_AES_ALGORITHM); break; case TpmAlgId.Tdes: alg = new BCryptAlgorithm(Native.BCRYPT_3DES_ALGORITHM); break; default: Globs.Throw <ArgumentException>("Unsupported symmetric algorithm " + symDef.Algorithm); return(null); } if (keyData == null) { keyData = Globs.GetRandomBytes(symDef.KeyBits / 8); } var key = alg.GenerateSymKey(symDef, keyData, GetBlockSize(symDef)); //key = BCryptInterface.ExportSymKey(keyHandle); //keyHandle = alg.LoadSymKey(key, symDef, GetBlockSize(symDef)); alg.Close(); return(key == null ? null : new SymCipher(key, keyData, iv, GetBlockSize(symDef))); #else // !TSS_USE_BCRYPT if (symDef.Mode == TpmAlgId.Ofb) { return(null); } var mode = GetCipherMode(symDef.Mode); if (mode == CipherMode_None) { return(null); } SymmetricAlgorithm alg = null; // = new RijndaelManaged(); bool limitedSupport = false; int feedbackSize = 0; switch (symDef.Algorithm) { case TpmAlgId.Aes: alg = new RijndaelManaged(); alg.Mode = mode == CipherMode.CFB ? CipherMode.ECB : mode; break; case TpmAlgId.Tdes: // DES and __3DES are not supported in TPM 2.0 rev. < 1.32 alg = new TripleDESCryptoServiceProvider(); alg.Mode = mode; if (mode == CipherMode.CFB) { feedbackSize = 8; } limitedSupport = true; break; default: //Globs.Throw<ArgumentException>("Unsupported symmetric algorithm " + symDef.Algorithm); return(null); } int blockSize = GetBlockSize(symDef); alg.KeySize = symDef.KeyBits; alg.BlockSize = blockSize * 8; alg.Padding = PaddingMode.None; alg.FeedbackSize = feedbackSize == 0 ? alg.BlockSize : feedbackSize; if (keyData == null) { // Generate random key alg.IV = Globs.GetZeroBytes(blockSize); try { alg.GenerateKey(); } catch (Exception) { alg.Dispose(); throw; } } else { // Use supplied key bits alg.Key = keyData; if (iv == null) { iv = Globs.GetZeroBytes(blockSize); } else if (iv.Length != blockSize) { Array.Resize(ref iv, blockSize); } alg.IV = iv; } var symCipher = new SymCipher(alg, mode); symCipher.LimitedSupport = limitedSupport; return(symCipher); #endif // !TSS_USE_BCRYPT } // Create()