/// <summary> /// 用输入的密钥和初始化向量,对输入的文本进行加密,返回加密后的结果 /// 密钥与初始话向量不可为汉语 /// </summary> /// <param name="input">要加密的内容</param> /// <param name="key">加密用的密钥</param> /// <param name="iv">加密用的初始化变量</param> /// <param name="bitLength">密钥的字节长度</param> /// <param name="encryptSymmetryType">要采用的对称加密算法</param> /// <returns>加密后的结果</returns> private static byte[] EncryptStringByKeyIV(this string input, byte[] key, byte[] iv, int bitLength, EncryptSymmetryType encryptSymmetryType) { if (input == null || input.Length <= 0) { throw new ArgumentNullException("input"); } if (key == null || key.Length <= 0) { throw new ArgumentNullException("key"); } if (iv == null || iv.Length <= 0) { throw new ArgumentNullException("iv"); } SymmetricAlgorithm symmetricAlgorithm = null; byte[] plainBytes = null; MemoryStream memoryStream = new MemoryStream(); switch (encryptSymmetryType) { case EncryptSymmetryType.DES: case EncryptSymmetryType.Rijandel: case EncryptSymmetryType.TripleDES: case EncryptSymmetryType.RC2: { symmetricAlgorithm = GetSymmetricAlgorithmBySmartEncryptSymmetryType(encryptSymmetryType); if (bitLength != int.MinValue && !symmetricAlgorithm.ValidKeySize(bitLength)) { throw new Exception("密钥大小对当前算法无效"); } if (bitLength != int.MinValue && symmetricAlgorithm.ValidKeySize(bitLength)) { symmetricAlgorithm.KeySize = bitLength; } symmetricAlgorithm.Key = key; symmetricAlgorithm.IV = iv; ICryptoTransform decryptor = symmetricAlgorithm.CreateEncryptor(symmetricAlgorithm.Key, symmetricAlgorithm.IV); using (CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Write)) { using (StreamWriter streamWriter = new StreamWriter(cryptoStream)) { streamWriter.Write(input); } if (symmetricAlgorithm != null) { symmetricAlgorithm.Clear(); } } } break; } plainBytes = memoryStream.ToArray(); return(plainBytes); }
public static void InitCryptAlgorithm(string keyHexString) { if (keyHexString == null || keyHexString.Length == 0) { _cryptAlgorithm = null; return; // encryption off } byte[] cryptKey = StringUtil.HexStringToByteArray(keyHexString); _cryptAlgorithm = SymmetricAlgorithm.Create(CRYPT_ALGORITHM); if (!_cryptAlgorithm.ValidKeySize(cryptKey.Length * 8)) { string msg = "Invalid Configuration value \"QueryStringEncryptionKey\". " + "The specified key size of " + cryptKey.Length + " bytes is incorrect for the \"" + CRYPT_ALGORITHM + "\" algorithm. " + "Try " + _cryptAlgorithm.Key.Length + " bytes."; throw new ApplicationException(msg); } // Set key and clear IV _cryptAlgorithm.Key = cryptKey; _cryptAlgorithm.IV = new byte[_cryptAlgorithm.IV.Length]; _cryptAlgorithm.Padding = PaddingMode.ISO10126; // using ISO padding introduces randomness to the padding bytes, preventing padding oracle probes from guessing at what correct padding is decrypting to. }
private static void ValidateBlockSize( SymmetricAlgorithm algorithm, IReadOnlyCollection <byte> initializationVector) { // Array length is bytes, IV size measured in bits. int initializationVectorSize = initializationVector.Count * BitsPerByte; // (BitsPerByte == 8) if (algorithm.ValidKeySize(initializationVectorSize)) { return; } string message = string.Format( "The size of the given initialization vector ({0}) does not match a valid block size ({2}) for the \"{1}\" algorithm.", initializationVector.Count, algorithm.GetType().Name, algorithm.LegalBlockSizes.Select( legalBlockSize => string.Format( "Max{0}Min{1}Skip{2}", legalBlockSize.MaxSize, legalBlockSize.MinSize, legalBlockSize.SkipSize)) .ToDelimitedString(", ")); //// Contract.Requires<ArgumentOutOfRangeException>( //// algorithm.ValidBlockSize(initializationVectorSize), message); throw new TypeInitializationException( "MiscCorLib.Security.Cryptography.SymmetricTransformer", new ArgumentOutOfRangeException("initializationVector", message)); }
/// <summary> /// Determines if the specified key is a valid size for the specified algorithm. /// </summary> /// <param name="key">The key string to be evaluated.</param> /// <param name="algorithm">The EncryptionAlgorithm to valid the key.</param> /// <param name="message">An output value of the valid sizes for the specified algorithm.</param> /// <returns>True if the key is a valid size; otherwise false.</returns> public static bool IsValidKeySize(string key, EncryptionAlgorithm algorithm, out string message) { SymmetricAlgorithm crypto = GetCryptoServiceProvider(algorithm); if (crypto != null) { byte[] keyBytes = Encoding.ASCII.GetBytes(key); int bitLength = keyBytes.Length * 8; StringBuilder sb = new StringBuilder(); sb.AppendFormat("The size of your key is {0} byte(s).\n", keyBytes.Length); foreach (KeySizes sizes in crypto.LegalKeySizes) { int min = (sizes.MinSize / 8); int max = (sizes.MaxSize / 8); int skip = (sizes.SkipSize / 8); sb.AppendFormat("The minimum key size acceptable is {0} byte(s), the maximum key size " + "acceptable is {1} byte(s) and the key must be created in increments of {2} byte(s).\n", min, max, skip); } message = sb.ToString(); return(crypto.ValidKeySize(bitLength)); } message = String.Empty; return(false); }
/// <summary> /// 对字符串进行对称加密 /// </summary> public static string SymmetricEncrypt(string inputString, SymmetricFormat symmetricFormat, string key, string iv) { SymmetricAlgorithm algorithm = GetSymmetricAlgorithm(symmetricFormat); byte[] desString = Encoding.UTF8.GetBytes(inputString); byte[] desKey = Encoding.ASCII.GetBytes(key); byte[] desIV = Encoding.ASCII.GetBytes(iv); if (!algorithm.ValidKeySize(desKey.Length * 8)) { throw new ArgumentOutOfRangeException("key"); } if (algorithm.IV.Length != desIV.Length) { throw new ArgumentOutOfRangeException("iv"); } MemoryStream mStream = new MemoryStream(); CryptoStream cStream = new CryptoStream(mStream, algorithm.CreateEncryptor(desKey, desIV), CryptoStreamMode.Write); cStream.Write(desString, 0, desString.Length); cStream.FlushFinalBlock(); cStream.Close(); return(Convert.ToBase64String(mStream.ToArray())); }
/// <summary> /// Initializes a new instance of the <see cref="V2CryptoBase" /> class. /// </summary> /// <param name="key">The key.</param> /// <param name="iv">The iv, or null for none.</param> /// <param name="keyStreamOffset">The key stream offset.</param> /// <exception cref="System.ArgumentNullException">factory /// or /// key /// or /// iv</exception> /// <exception cref="System.ArgumentException">Key length is invalid. /// or /// The IV length must be the same as the algorithm block length.</exception> protected void Initialize(SymmetricKey key, SymmetricIV iv, long keyStreamOffset, SymmetricAlgorithm algorithm) { if (key == null) { throw new ArgumentNullException("key"); } if (algorithm == null) { throw new ArgumentNullException("algorithm"); } if (!algorithm.ValidKeySize(key.Size)) { throw new ArgumentException("Key length is invalid."); } iv = iv ?? new SymmetricIV(new byte[algorithm.BlockSize / 8]); if (iv.Length != algorithm.BlockSize / 8) { throw new ArgumentException("The IV length must be the same as the algorithm block length."); } Key = key; _iv = iv; _blockCounter = keyStreamOffset / iv.Length; _blockOffset = (int)(keyStreamOffset % iv.Length); }
/// <summary> /// Controlla correttezza formale chiave /// </summary> /// <param name="algorithm"></param> /// <param name="key"></param> private static void checkAlgoKey(SymmetricAlgorithm algorithm, byte[] key) { if (!algorithm.ValidKeySize(key.Length * 8)) { throw new ArgumentException(string.Format("La lunghezza della chiave fornita ({0} Bytes / {1} bits) non risulta compatibile con l'algoritmo selezionato {2}. Lunghezze supportate: Min-> {3} bits, Max-> {4} bits", key.Length, key.Length * 8, algorithm.GetType().Name, algorithm.LegalKeySizes[0].MinSize, algorithm.LegalKeySizes[0].MaxSize)); } }
/// <summary> /// Create class and create a new key for the passed algorithm with a fixed keysize. /// </summary> /// <param name="Algorithm">new algorithm</param> /// <param name="KeySize">Keysize in bits(8 bits = 1 byte)</param> /// <param name="Password">Password, used to generate key</param> /// <param name="Salt">Salt, used to make generated key more random(min 8 characters)</param> /// <param name="Iterations">Rounds PBKDF2 will make to genarete a key</param> public Encryption(SymmetricAlgorithm Algorithm, int KeySize, string Password, string Salt, int Iterations = 10000) { _Algorithm = Algorithm ?? throw new ArgumentException("Invalid algorithm, algorithm is null."); if (!_Algorithm.ValidKeySize(KeySize)) { throw new ArgumentException("Invalid key, key has an invalid size."); } Algorithm.Key = CreateKey(KeySize, Password, Salt, Iterations); }
public static string GenerateKey(SymmetricAlgorithm algorithm, int keySize) { if (!algorithm.ValidKeySize(keySize)) { throw new ArgumentException("Invalid key size"); } algorithm.KeySize = keySize; algorithm.GenerateKey(); return(Convert.ToBase64String(algorithm.Key)); }
public void KeySize_WrongSize() { SymmetricAlgorithm algo = SymmetricAlgorithm.Create(); int n = 0; while (algo.ValidKeySize(++n)) { ; } algo.KeySize = n; }
// Find a valid key size for this algorithm. private static int FindKeySize(SymmetricAlgorithm algorithm) { for (int i = 1024; i > 1; i--) { if (algorithm.ValidKeySize(i)) { return(i); } } throw new InvalidOperationException( $"Cannot find a valid key size for {algorithm.GetType().Name}."); }
public SymmetricEncryptionResult Encrypt(string messageToEncrypt, int symmetricKeyLengthBits, SymmetricAlgorithm algorithm) { SymmetricEncryptionResult encryptionResult = new SymmetricEncryptionResult(); try { //first test if bit length is valid if (algorithm.ValidKeySize(symmetricKeyLengthBits)) { algorithm.KeySize = symmetricKeyLengthBits; using (MemoryStream mem = new MemoryStream()) { CryptoStream crypto = new CryptoStream(mem, algorithm.CreateEncryptor(), CryptoStreamMode.Write); byte[] bytesToEncrypt = Encoding.UTF8.GetBytes(messageToEncrypt); crypto.Write(bytesToEncrypt, 0, bytesToEncrypt.Length); crypto.FlushFinalBlock(); byte[] encryptedBytes = mem.ToArray(); string encryptedBytesBase64 = Convert.ToBase64String(encryptedBytes); encryptionResult.Success = true; encryptionResult.Cipher = encryptedBytes; encryptionResult.CipherBase64 = encryptedBytesBase64; encryptionResult.IV = algorithm.IV; encryptionResult.SymmetricKey = algorithm.Key; } } else { string NL = Environment.NewLine; StringBuilder exceptionMessageBuilder = new StringBuilder(); exceptionMessageBuilder.Append("The provided key size - ") .Append(symmetricKeyLengthBits).Append(" bits - is not valid for this algorithm."); exceptionMessageBuilder.Append(NL) .Append("Valid key sizes: ").Append(NL); KeySizes[] validKeySizes = algorithm.LegalKeySizes; foreach (KeySizes keySizes in validKeySizes) { exceptionMessageBuilder.Append("Min: ") .Append(keySizes.MinSize).Append(NL) .Append("Max: ").Append(keySizes.MaxSize).Append(NL) .Append("Step: ").Append(keySizes.SkipSize); } throw new CryptographicException(exceptionMessageBuilder.ToString()); } } catch (Exception ex) { encryptionResult.Success = false; encryptionResult.ExceptionMessage = ex.Message; } return(encryptionResult); }
/// <summary> /// Create class with an algorithm and overide the key for the selected algorithm. /// </summary> /// <param name="Algorithm">New algorithm</param> /// <param name="Key">Generated key</param> public Encryption(SymmetricAlgorithm Algorithm, byte[] Key) { _Algorithm = Algorithm ?? throw new ArgumentException("Invalid algorithm, algorithm is null."); if (Key == null) { throw new ArgumentException("Invalid key, key is null."); } if (!_Algorithm.ValidKeySize(Key.Length * 8)) { throw new ArgumentException("Invalid key, key has an invalid size."); } _Algorithm.Key = Key; }
private Tuple <byte[], byte[]> GetStartingKeyAndIVForEncryption(SymmetricAlgorithm algorithm) { int bits = algorithm.ValidKeySize(EncryptionSettings.PreferedEncryptionKeyBitsSize) ? EncryptionSettings.PreferedEncryptionKeyBitsSize : algorithm.LegalKeySizes[0].MaxSize; encryptionKeySize = bits / 8; encryptionIVSize = algorithm.IV.Length; var deriveBytes = new Rfc2898DeriveBytes(EncryptionSettings.EncryptionKey, GetSaltFromEncryptionKey(EncryptionSettings.EncryptionKey), Constants.Rfc2898Iterations); return(Tuple.Create(deriveBytes.GetBytes(encryptionKeySize.Value), deriveBytes.GetBytes(encryptionIVSize.Value))); }
/// <summary> /// permite generar llaves de seguridad /// </summary> /// <param name="algorithm">define el algoritmo</param> /// <param name="keySize">tamaño del algoritmo</param> /// <returns></returns> public static string GenerateKey(SymmetricAlgorithm algorithm, int keySize) { if (algorithm.ValidKeySize(keySize)) { algorithm.KeySize = keySize; algorithm.GenerateKey(); return(Convert.ToBase64String(algorithm.Key)); } else { throw new ArgumentException("Tamaño de Llave Invalido"); } }
/// <summary> /// Generate symmetric key for encryption and decryption. /// </summary> /// <param name="keySize">Key size.</param> /// <returns>Key byte array.</returns> public virtual byte[] GenerateKey(int keySize) { if (!_symmetricAlgorithm.ValidKeySize(keySize)) { throw new CryptographicException("Invalid key size for this algorithm."); } _symmetricAlgorithm.Clear(); _symmetricAlgorithm.KeySize = keySize; _symmetricAlgorithm.GenerateKey(); return(_symmetricAlgorithm.Key); }
/// <summary> /// </summary> /// <param name="algorithm">algorithm used for encryption, Aes if null</param> /// <param name="key">key used for encryption, secure random if null</param> /// <exception cref="ArgumentException">can't create EasyEncrypt: key is invalid</exception> public EasyEncrypt(SymmetricAlgorithm algorithm = null, byte[] key = null) { Algorithm = algorithm ?? Aes.Create(); if (key == null) { Algorithm.GenerateKey(); } else if (Algorithm.ValidKeySize(key.Length * 8)) { Algorithm.Key = key; } else { throw new ArgumentException("Can't create EasyEncrypt: key is invalid"); } }
public static string GenerarKey(string tipoAlgoritmo, int keySize) { SymmetricAlgorithm mCSP = elegirAlgoritmo(tipoAlgoritmo); if (mCSP.ValidKeySize(keySize)) { mCSP.KeySize = keySize; mCSP.GenerateKey(); return(Convert.ToBase64String(mCSP.Key)); } else { throw new ArgumentException("Tamaño inválido de la clave"); } }
private static SymmetricAlgorithm InitSymmetric(SymmetricAlgorithm algorithm, string password, int keyBitLength) { var salt = new byte[] { 1, 2, 23, 234, 37, 48, 134, 63, 248, 4 }; const int iterations = 234; using (var rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, salt, iterations)) { if (!algorithm.ValidKeySize(keyBitLength)) { throw new InvalidOperationException("Invalid size key"); } algorithm.Key = rfc2898DeriveBytes.GetBytes(keyBitLength / 8); algorithm.IV = rfc2898DeriveBytes.GetBytes(algorithm.BlockSize / 8); return(algorithm); } }
private bool IsKeySizeValid(int size) { return(myCSP.ValidKeySize(size)); }
public bool ValidKeySize(int bitLength) { return(_algo.ValidKeySize(bitLength)); }