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