public static string SymmetricDecrypt2(this string cipherText, string key, string eVec) { try { var encoding = Encoding.UTF8; byte[] keyBuffer = Encoding.UTF8.GetBytes(key); byte[] iv = Encoding.UTF8.GetBytes(eVec); cipherText = cipherText.Replace(" ", "+"); byte[] cipherTextBuffer = new byte[cipherText.Length + 1]; cipherTextBuffer = Convert.FromBase64String(cipherText); //byte[] cipherTextBuffer = Encoding.UTF8.GetBytes(cipherText); ISymmetricKeyAlgorithmProvider symmetricAlgorithm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(PCLCrypto.SymmetricAlgorithm.AesEcb); MemoryStream ms = new MemoryStream(); var symmetricKey = symmetricAlgorithm.CreateSymmetricKey(keyBuffer); var decryptor = WinRTCrypto.CryptographicEngine.CreateDecryptor(symmetricKey, iv); //byte[] plainTextBuffer = decryptor.TransformFinalBlock(cipherTextBuffer, 0, 16); //Convert.ToBase64String(plainTextBuffer, 0, plainTextBuffer.Length); //return Convert.ToBase64String(plainTextBuffer, 0, plainTextBuffer.Length); CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write); cs.Write(cipherTextBuffer, 0, 16); cs.FlushFinalBlock(); return(encoding.GetString(ms.ToArray())); } catch (Exception ex) { throw; } }
public void BlockLength() { ISymmetricKeyAlgorithmProvider provider = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); Assert.IsNotNull(provider); Assert.AreEqual(16, provider.BlockLength); }
public static string SymmetricDecrypt(this string cipherText, string key, string eVec) { try { byte[] keyBuffer = Encoding.UTF8.GetBytes(key); byte[] iv = Encoding.UTF8.GetBytes(eVec); cipherText = cipherText.Replace(" ", "+"); byte[] cipherTextBuffer = new byte[cipherText.Length + 1]; cipherTextBuffer = Convert.FromBase64String(cipherText); //byte[] cipherTextBuffer = Encoding.UTF8.GetBytes(cipherText); ISymmetricKeyAlgorithmProvider symmetricAlgorithm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(PCLCrypto.SymmetricAlgorithm.AesEcb); var symmetricKey = symmetricAlgorithm.CreateSymmetricKey(keyBuffer); var decryptor = WinRTCrypto.CryptographicEngine.CreateDecryptor(symmetricKey, iv); byte[] plainTextBuffer = decryptor.TransformFinalBlock(cipherTextBuffer, 0, 16); Convert.ToBase64String(plainTextBuffer, 0, plainTextBuffer.Length); return(Convert.ToBase64String(plainTextBuffer, 0, plainTextBuffer.Length)); } catch (Exception ex) { throw; } }
public static string Encrypt(string originalPayload, byte[] privateKey) { string encryptedPayload = ""; ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(privateKey); var iv = WinRTCrypto.CryptographicBuffer.GenerateRandom(aes.BlockLength); var input = Encoding.UTF8.GetBytes(originalPayload); using (var encrypter = WinRTCrypto.CryptographicEngine.CreateEncryptor(symetricKey, iv)) { using (var cipherStream = new MemoryStream()) { using (var tCryptoStream = new CryptoStream(cipherStream, encrypter, CryptoStreamMode.Write)) using (var tBinaryWriter = new BinaryWriter(tCryptoStream)) { //Prepend IV to data cipherStream.Write(iv, 0, iv.Length); //Write iv to the plain stream (not tested though) tBinaryWriter.Write(input); tCryptoStream.FlushFinalBlock(); } encryptedPayload = Convert.ToBase64String(cipherStream.ToArray()); } } return(encryptedPayload); }
public static string DecryptAes(byte[] data, byte[] key, byte[] rgbKey, byte[] rgbIV) { ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbc); ICryptographicKey symetricKey = aes.CreateSymmetricKey(rgbKey); string returnValue = ""; using (var ms = new MemoryStream(data)) { // Read the first 16 bytes which is the IV. byte[] iv = new byte[16]; ms.Read(iv, 0, 16); using (var decryptor = WinRTCrypto.CryptographicEngine.CreateDecryptor(symetricKey, iv)) { using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { using (var sr = new StreamReader(cs)) { returnValue = sr.ReadToEnd(); } } } } return(returnValue); }
/// <summary> /// Computes PKCS5 for the message /// </summary> /// <param name="message">plaintext</param> /// <returns>PKCS5 of the message</returns> public static byte[] aesCbcPkcs5(byte[] message, byte[] key, byte[] iv) { ISymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); // PKCS5 ICryptographicKey ckey = objAlg.CreateSymmetricKey(key); byte [] result = CryptographicEngine.Encrypt(ckey, message, iv); return(result); }
public static async Task decryptFile(string inFile, byte[] keyArray, string outFile) { ISymmetricKeyAlgorithmProvider aesGcm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); var cryptoKey = aesGcm.CreateSymmetricKey(keyArray); var decryptor = new ICryptoTransform[] { WinRTCrypto.CryptographicEngine.CreateDecryptor(cryptoKey) }; await CryptoTransformFileAsync(inFile, outFile, decryptor, CancellationToken.None); }
public void BlockLength(SymmetricAlgorithm algorithm, int expectedBlockLength) { ISymmetricKeyAlgorithmProvider provider = WinRTCrypto.SymmetricKeyAlgorithmProvider .OpenAlgorithm(algorithm); Assert.NotNull(provider); Assert.Equal(expectedBlockLength, provider.BlockLength); }
internal static string Decrypt(byte[] encryptedText) //Seridonio,2016 { ISymmetricKeyAlgorithmProvider aesCrypto = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symmtricKey = aesCrypto.CreateSymmetricKey(_derivedKey); ICryptoTransform decryptor = WinRTCrypto.CryptographicEngine.CreateDecryptor(symmtricKey); byte[] decryptedText = decryptor.TransformFinalBlock(encryptedText, 0, encryptedText.Length); return(Encoding.UTF8.GetString(decryptedText, 0, decryptedText.Length)); }
internal static byte[] Encrypt(string text) //Seridonio,2016 { ISymmetricKeyAlgorithmProvider aesCrypto = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symmtricKey = aesCrypto.CreateSymmetricKey(_derivedKey); ICryptoTransform encryptor = WinRTCrypto.CryptographicEngine.CreateEncryptor(symmtricKey); byte[] byteText = Encoding.UTF8.GetBytes(text); byte[] encryptedText = encryptor.TransformFinalBlock(byteText, 0, byteText.Length); return(encryptedText); }
/// <summary> /// Decrypts given bytes using symmetric alogrithm AES /// </summary> /// <param name="data">data to decrypt</param> /// <param name="password">Password used for encryption</param> /// <param name="salt">Salt used for encryption</param> /// <returns></returns> public static string DecryptAes(byte[] data, string password, byte[] salt) { byte[] key = CreateDerivedKey(password, salt); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); var bytes = WinRTCrypto.CryptographicEngine.Decrypt(symetricKey, data); return(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
/// <summary> /// Encrypts given data using symmetric algorithm AES /// </summary> /// <param name="data">Data to encrypt</param> /// <param name="password">Password</param> /// <returns>Encrypted bytes</returns> public static string EncryptAes(string data, string password) { byte[] key = new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76, 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76, 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d }; ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); var bytes = WinRTCrypto.CryptographicEngine.Encrypt(symetricKey, Encoding.UTF8.GetBytes(data)); return(Convert.ToBase64String(bytes)); }
public Encrypter(string Password) { _password = Password; _salt = new byte[] { 16, 30, 45, 1, 17, 15, 240, 193 }; _key = CreateDerivedKey(); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); _symetricKey = aes.CreateSymmetricKey(_key); }
/// <summary> /// Encrypts given data using symmetric algorithm AES /// </summary> /// <param name="data">Data to encrypt</param> /// <param name="password">Password</param> /// <param name="salt">Salt</param> /// <returns>Encrypted bytes</returns> public static byte[] EncryptAes(string data, string password, byte[] salt) { byte[] key = CreateDerivedKey(password, salt); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); var bytes = WinRTCrypto.CryptographicEngine.Encrypt(symetricKey, Encoding.UTF8.GetBytes(data)); return(bytes); }
/// <summary> /// Decrypts given bytes using symmetric alogrithm AES /// </summary> /// <param name="data">data to decrypt</param> /// <param name="password">Password used for encryption</param> /// <param name="salt">Salt used for encryption</param> /// <returns></returns> public string DecryptAes(string dataEncrypted, string password) { byte[] key = new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76, 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76, 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d }; ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); var bytes = WinRTCrypto.CryptographicEngine.Decrypt(symetricKey, Encoding.UTF8.GetBytes(dataEncrypted)); return(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
public static byte[] aesCtr(byte[] message, byte[] key, uint counter) { ISymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey ckey = objAlg.CreateSymmetricKey(key); byte[] ivBytes = new byte[16]; ByteUtil.intToByteArray(ivBytes, 0, (int)counter); byte [] result = CryptographicEngine.Decrypt(ckey, message, ivBytes); return(result); }
public byte[] Enqrypt(string decrypted) { var salt = CreateSalt(lenghtInBytes); byte[] key = CreateDerivedKey(password, salt); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); var bytes = WinRTCrypto.CryptographicEngine.Encrypt(symetricKey, Encoding.UTF8.GetBytes(decrypted)); return(bytes); }
public string Encrypt(string dataString, string password, string saltString) { byte[] data = ConvertToBytesArray(dataString); byte[] key = CreateDerivedKey(password, saltString); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); byte[] bytes = WinRTCrypto.CryptographicEngine.Encrypt(symetricKey, data); return(ConvertToString(bytes)); }
public static string DecryptAes(byte[] data, string password, byte[] salt) { byte[] key = CreateDerivedKey(password, salt); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmName.Aes, SymmetricAlgorithmMode.Cbc, SymmetricAlgorithmPadding.None); var v = aes.LegalKeySizes; ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); //symetricKey.ExportParameters(true); var bytes = WinRTCrypto.CryptographicEngine.Decrypt(symetricKey, data); return(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
public static byte[] aesCbcPkcs5(byte[] message, byte[] key, byte[] iv) { ISymmetricKeyAlgorithmProvider objAlg = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey ckey = objAlg.CreateSymmetricKey(key); if (message.Length % objAlg.BlockLength != 0) { throw new Exception("Invalid ciphertext length"); } byte [] result = CryptographicEngine.Decrypt(ckey, message, iv); return(result); }
public void LegalKeySizes(SymmetricAlgorithmName name, int minSize, int maxSize, int stepSize) { var blockMode = name.IsBlockCipher() ? SymmetricAlgorithmMode.Cbc : SymmetricAlgorithmMode.Streaming; var padding = name.IsBlockCipher() ? SymmetricAlgorithmPadding.PKCS7 : SymmetricAlgorithmPadding.None; ISymmetricKeyAlgorithmProvider provider = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(name, blockMode, padding); var result = provider.LegalKeySizes; Assert.NotNull(result); Assert.NotEmpty(result); var random = new Random(); Action <int> attemptKeySize = size => { var keyMaterial = new byte[size / 8]; random.NextBytes(keyMaterial); // some algorithms check against weak keys (e.g. all zeros) provider.CreateSymmetricKey(keyMaterial).Dispose(); }; // Verify that each allegedly legal key size actually works. foreach (var item in result) { this.logger.WriteLine($"{item.MinSize}-{item.MaxSize} ({item.StepSize})"); foreach (var keySize in item) { attemptKeySize(keySize); } // Also check the cases just off the edges of the range to see that they actually fail. // This ensures the returned values aren't too conservative. #if false // WinRT actually doesn't throw when given keys of inappropriate size. Go figure. if (item.StepSize > 0) { if (item.MinSize - item.StepSize > 0) { Assert.Throws <ArgumentException>(() => attemptKeySize(item.MinSize - item.StepSize)); } if (item.MaxSize + item.StepSize > 0) { Assert.Throws <ArgumentException>(() => attemptKeySize(item.MaxSize + item.StepSize)); } } #endif } var range = result.Single(); Assert.Equal(minSize, range.MinSize); Assert.Equal(maxSize, range.MaxSize); Assert.Equal(stepSize, range.StepSize); }
public static string SymmetricEncrypt(this string plaintext, string key) { byte[] keyBuffer = Convert.FromBase64String(key); byte[] plainTextBuffer = Convert.FromBase64String(plaintext); ISymmetricKeyAlgorithmProvider symmetricAlgorithm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(PCLCrypto.SymmetricAlgorithm.AesEcbPkcs7); var symmetricKey = symmetricAlgorithm.CreateSymmetricKey(keyBuffer); var encryptor = WinRTCrypto.CryptographicEngine.CreateEncryptor(symmetricKey); byte[] cipherBuffer = encryptor.TransformFinalBlock(plainTextBuffer, 0, plainTextBuffer.Length); return(Convert.ToBase64String(cipherBuffer)); }
/// <summary> /// Decrypts given bytes using symmetric alogrithm AES /// </summary> /// <param name="data">data to decrypt</param> /// <param name="password">Password used for encryption</param> /// <param name="salt">Salt used for encryption</param> /// <returns></returns> public static string DecryptAes(string data, byte[] salt) { if (string.IsNullOrEmpty(data)) { return(null); } byte[] key = CreateDerivedKey(SYMMETRICKEY, salt); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); var encryptedBytes = Convert.FromBase64String(data); var bytes = WinRTCrypto.CryptographicEngine.Decrypt(symetricKey, encryptedBytes); return(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
public EncryptionService(ISymmetricKeyAlgorithmProvider provider, ICryptographicBuffer cryptographicBuffer, byte[] key) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } if (key == null) { throw new ArgumentNullException(nameof(key)); } _cryptographicBuffer = cryptographicBuffer; _key = provider.CreateSymmetricKey(key); }
/// <summary> /// Metodo que crea un cifrador o descifrador /// </summary> /// <param name="keyMaterial"></param> /// <param name="rutaArchivoOriginal">Ruta al archivo que se va a procesar</param> /// <param name="rutaDestino">Ruta de carpeta donde se guardará el archivo procesado</param> /// <param name="cifrar">Determina si se va a cifrar o descifrar. TRUE=Cifrar</param> /// <returns></returns> public static async Task CifradoDescifradoAsincrono(byte[] keyMaterial, string rutaArchivoOriginal, string rutaDestino, bool cifrar) { ISymmetricKeyAlgorithmProvider aesGcm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(PCLCrypto.SymmetricAlgorithm.AesCbcPkcs7); var claveDerivada = aesGcm.CreateSymmetricKey(keyMaterial); try { var mecanismoCriptografico = cifrar ? WinRTCrypto.CryptographicEngine.CreateEncryptor(claveDerivada) : WinRTCrypto.CryptographicEngine.CreateDecryptor(claveDerivada); var transformacion = new PCLCrypto.ICryptoTransform[] { mecanismoCriptografico }; await CryptoTransformFileAsync(rutaArchivoOriginal, rutaDestino, transformacion); } catch { throw; } }
public static string Decrypt(this string val, string eKey, string eVec) { try { //if (!eKey.IsNullEmpty() && !eVec.IsNullEmpty() && eKey.Length >= 8 && eVec.Length >= 8) //{ var encoding = Encoding.UTF8; MemoryStream ms = new MemoryStream(); val = val.Replace(" ", "+"); byte[] inputByteArray = new byte[val.Length + 1]; byte[] key = Encoding.UTF8.GetBytes(eKey.Substring(0, 8)); byte[] iv = Encoding.UTF8.GetBytes(eVec.Substring(0, 8)); //DESCryptoServiceProvider des = new DESCryptoServiceProvider(); inputByteArray = Convert.FromBase64String(val); ISymmetricKeyAlgorithmProvider symmetricAlgorithm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(PCLCrypto.SymmetricAlgorithm.DesCbcPkcs7); var symmetricKey = symmetricAlgorithm.CreateSymmetricKey(key); var decryptor = WinRTCrypto.CryptographicEngine.CreateDecryptor(symmetricKey, iv); CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write); cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); return(encoding.GetString(ms.ToArray())); } catch (Exception ex) { throw; } //} //else //{ // return string.Empty; //} }
private static int GetKeyLength(SymmetricAlgorithmName symmetricAlgorithm, ISymmetricKeyAlgorithmProvider algorithmProvider) { int keyLength; switch (symmetricAlgorithm) { case SymmetricAlgorithmName.TripleDes: keyLength = algorithmProvider.BlockLength * 3; break; default: keyLength = algorithmProvider.BlockLength; break; } return(keyLength); }
public static async Task EncryptThenDecryptAsync(string beforeFilePath, string cipherFilePath, string afterFilePath) { ISymmetricKeyAlgorithmProvider aesGcm = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); byte[] keyMaterial = WinRTCrypto.CryptographicBuffer.GenerateRandom(32); var cryptoKey = aesGcm.CreateSymmetricKey(keyMaterial); string key = ""; foreach (var i in keyMaterial) { key = key + i + ","; } var encryptor = new ICryptoTransform[] { WinRTCrypto.CryptographicEngine.CreateEncryptor(cryptoKey) }; var decryptor = new ICryptoTransform[] { WinRTCrypto.CryptographicEngine.CreateDecryptor(cryptoKey) }; await CryptoTransformFileAsync(beforeFilePath, cipherFilePath, encryptor, CancellationToken.None); await CryptoTransformFileAsync(cipherFilePath, afterFilePath, decryptor, CancellationToken.None); }
private static string DecryptAes(byte[] data, string password, byte[] salt) { byte[] key = CreateKey(password, salt); ISymmetricKeyAlgorithmProvider aes = WinRTCrypto.SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithm.AesCbcPkcs7); ICryptographicKey symetricKey = aes.CreateSymmetricKey(key); byte[] bytes = null; try { bytes = WinRTCrypto.CryptographicEngine.Decrypt(symetricKey, data); } catch (Exception ex) { return(""); // do stuff } return(Encoding.UTF8.GetString(bytes, 0, bytes.Length)); }
private static uint GetKeyLength(SymmetricAlgorithm symmetricAlgorithm, ISymmetricKeyAlgorithmProvider algorithmProvider) { uint keyLength; switch (symmetricAlgorithm) { case SymmetricAlgorithm.TripleDesCbc: case SymmetricAlgorithm.TripleDesCbcPkcs7: case SymmetricAlgorithm.TripleDesEcb: case SymmetricAlgorithm.TripleDesEcbPkcs7: keyLength = (uint)algorithmProvider.BlockLength * 3; break; default: keyLength = (uint)algorithmProvider.BlockLength; break; } return(keyLength); }
private static int GetKeyLength(SymmetricAlgorithmName symmetricAlgorithm, ISymmetricKeyAlgorithmProvider algorithmProvider) { int keyLength; switch (symmetricAlgorithm) { case SymmetricAlgorithmName.TripleDes: keyLength = algorithmProvider.BlockLength * 3; break; default: keyLength = algorithmProvider.BlockLength; break; } return keyLength; }
private static uint GetKeyLength(SymmetricAlgorithm symmetricAlgorithm, ISymmetricKeyAlgorithmProvider algorithmProvider) { uint keyLength; switch (symmetricAlgorithm) { case SymmetricAlgorithm.TripleDesCbc: case SymmetricAlgorithm.TripleDesCbcPkcs7: case SymmetricAlgorithm.TripleDesEcb: case SymmetricAlgorithm.TripleDesEcbPkcs7: keyLength = (uint)algorithmProvider.BlockLength * 3; break; default: keyLength = (uint)algorithmProvider.BlockLength; break; } return keyLength; }