使用相同的参数进行加密可得出不同的结果

Question

Im sure there is a big mistake I am making here....

I am trying to encrypt a string using AES but passing the same parameters (plainText, password and salt) each time produces a different result.

I am calling as follows with the result of each being different:

var cipherTextCode  = EncryptAes(plainTextCode, "K29V2NVsFhCVRYeJ88PJSdBd8Gd1PEXnWsX3lCKcy0y4M43oRq", "LQzJUNdsVgio20KnOPTdMONBO50FCCgOLXK5s7vpeX3Pr3fOu1");
var cipherTextCode1 = EncryptAes(plainTextCode, "K29V2NVsFhCVRYeJ88PJSdBd8Gd1PEXnWsX3lCKcy0y4M43oRq", "LQzJUNdsVgio20KnOPTdMONBO50FCCgOLXK5s7vpeX3Pr3fOu1");
var cipherTextCode2 = EncryptAes(plainTextCode, "K29V2NVsFhCVRYeJ88PJSdBd8Gd1PEXnWsX3lCKcy0y4M43oRq", "LQzJUNdsVgio20KnOPTdMONBO50FCCgOLXK5s7vpeX3Pr3fOu1");
var cipherTextCode3 = EncryptAes(plainTextCode, "K29V2NVsFhCVRYeJ88PJSdBd8Gd1PEXnWsX3lCKcy0y4M43oRq", "LQzJUNdsVgio20KnOPTdMONBO50FCCgOLXK5s7vpeX3Pr3fOu1");

The method I use to encrypt is as follows:

     private const int CB = 32;

   /// <summary>
        /// The initialization vector
        /// </summary>
        private readonly byte[] InitialisationVectorBytes = Encoding.ASCII.GetBytes("EAzjVfNrCzOoE7AI");

/// <summary>
        /// Encrypts a string using AES encryption
        /// </summary>
        /// <param name="plainText">The string to encrypt</param>
        /// <param name="passPhrase">The encryption key</param>
        /// <param name="salt">The encryption salt</param>
        /// <returns>an encrypted string</returns>
        private string EncryptAes(string plainText, string passPhrase, string salt)
        {
            try
            {
                //get the plain text bytes and the salt bytes
                var plainTextBytes = Encoding.UTF8.GetBytes(plainText);
                var saltBytes = Encoding.UTF8.GetBytes(salt);

                //Derives the key from the phrase and the salt
                using(var password = new Rfc2898DeriveBytes(passPhrase, saltBytes))
                {
                    //use the AES Rijndael algorithm
                    using(var symmetricKey = new RijndaelManaged())
                    {
                        //set the mode
                        symmetricKey.Mode = CipherMode.CBC;

                        //create an encryption object
                        using(var encryptor = symmetricKey.CreateEncryptor(password.GetBytes(CB), InitialisationVectorBytes))
                        {
                            //create a memory stream
                            using(var memoryStream = new MemoryStream())
                            {
                                //create a cryptography stream
                                using(var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write))
                                {
                                    //encrypt the plain text
                                    cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length);
                                    cryptoStream.FlushFinalBlock();
                                    var cipherTextBytes = memoryStream.ToArray();
                                    return Convert.ToBase64String(cipherTextBytes);
                                }
                            }
                        }
                    }
                }
            }
            catch(SecurityException)
            {
                return string.Empty;
            }
        }

What am I doing wrong?

Answer 1

A blockcipher like AES is a keyed permutation. In the case of AES it takes a key and then turns a 16 byte block into another 16 byte block deterministically.

To encrypt something with a block-cipher you need to use a mode of operation. Typically those modes take an IV (similar to a salt) which should be different for each message you encrypt. This difference in the IV leads to a totally different encrypted message. Encrypting the same message with the same IV and key returns always the same ciphertext. Encrypting several messages with the same IV and key weakens security, but by how much depends on the mode.

The required properties for an IV depend on the chosen mode, sometimes it needs to be unique(eg for CTR mode), sometimes it needs to be unpredictably random (eg for CBC mode). But it generally doesn't have to be secret, so you send it to the recipient alongside the ciphertext, typically as a prefix.

There are some modes designed for deterministic encryption. Using those modes you still leak if two messages are the same, but nothing more. You should only use those modes when you require determinism.

In Short : You are using " symmetricKey.Mode = CipherMode.CBC;" : unpredictably random.

if you want the same you can use : CipherMode.CTR

credits : my source