After AES decryption file got corrupted C#

Question

After decrypting the file with the AES algorithm, I'm getting this message:

But when I click OK, the file is opening propely without any loss of data.

It makes the user think there is something wrong with the file.

My code for encryption and decryption :

    /// <summary>
    /// AES strong encryption logic used
    /// </summary>
    /// <param name="encfilepath">file path which need to encrypt</param>
    /// <param name="enckey">key used to decrypt</param>
    public static void AESEncryptFile(string encfilepath, byte[] enckey)
    {
        byte[] bytesToBeEncrypted = System.IO.File.ReadAllBytes(System.Security.SecurityElement.Escape(encfilepath));

        // Hash the password with SHA256
        byte[] passwordBytes = SHA256.Create().ComputeHash(enckey);

        //create the new folder to for decryption
        var decryptedFilePath = Path.GetDirectoryName(encfilepath) + @"\" + Guid.NewGuid() + @"\" + Path.GetFileName(encfilepath);
        if (!Directory.Exists(Path.GetDirectoryName(decryptedFilePath)))
            Directory.CreateDirectory(Path.GetDirectoryName(decryptedFilePath));

        //decrypt the plain file and store in decryption folder
        AES_Encrypt(encfilepath, decryptedFilePath, passwordBytes);

        //move the file from decryption folder to actual folder
        if (File.Exists(encfilepath))
            File.Delete(encfilepath);
        File.Move(decryptedFilePath, encfilepath);
        Directory.Delete(Path.GetDirectoryName(decryptedFilePath));
    }

    /// <summary>
    /// AES strong encryption logic used
    /// </summary>
    /// <param name="inputFile">this is plain file path which want to encrypt</param>
    /// <param name="outputFile">this is output file where encrypt file need to save</param>
    /// <param name="passwordBytes">password byte</param>
    private static void AES_Encrypt(string inputFile, string outputFile, byte[] passwordBytes)
    {
        byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
        string cryptFile = outputFile;
        FileStream fsCrypt = new FileStream(cryptFile, FileMode.Create);

        RijndaelManaged AES = new RijndaelManaged();

        AES.KeySize = 256;
        AES.BlockSize = 128;


        var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
        AES.Key = key.GetBytes(AES.KeySize / 8);
        AES.IV = key.GetBytes(AES.BlockSize / 8);
        AES.Padding = PaddingMode.Zeros;

        AES.Mode = CipherMode.CBC;

        CryptoStream cs = new CryptoStream(fsCrypt,
             AES.CreateEncryptor(),
            CryptoStreamMode.Write);

        FileStream fsIn = new FileStream(inputFile, FileMode.Open);

        int data;
        while ((data = fsIn.ReadByte()) != -1)
            cs.WriteByte((byte)data);


        fsIn.Close();
        cs.Close();
        fsCrypt.Close();

    }


    /// <summary>
    /// AES strong encryption logic used
    /// </summary>
    /// <param name="encfilepath">file path which need to encrypt</param>
    /// <param name="enckey">key used to decrypt</param>

    /// <summary>
    /// Decrypt the encrypted file file using AES algorithm
    /// </summary>
    /// <param name="encryptedFilePath">Selected encrypted file</param>
    /// <param name="decryptFilePath">Decrypt file path</param>
    /// <param name="userFileName">Selected encrypted file user file name</param>
    /// <returns>Value of bool - File decrypted status</returns>
    //public bool DecryptFile(string encryptedFilePath, string decryptFilePath, string userFileName)
    public static bool AESDecryptFile(string encryptedFilePath, out string decryptFilePath, byte[] encryptionKey)
    {
        var isDecrypted = false;
        try
        {
            decryptFilePath = Path.GetDirectoryName(encryptedFilePath) + @"\" + Guid.NewGuid() + @"\" + Path.GetFileName(encryptedFilePath);
            if (!Directory.Exists(Path.GetDirectoryName(decryptFilePath)))
                Directory.CreateDirectory(Path.GetDirectoryName(decryptFilePath));
            var passwordBytes = SHA256.Create().ComputeHash(encryptionKey);
            AES_Decrypt(encryptedFilePath, decryptFilePath, passwordBytes);
            isDecrypted = true;
        }
        catch (Exception ex)
        {
            throw ex;
        }
        return isDecrypted;
    }

    /// <summary>
    /// AES strong encryption logic used
    /// </summary>
    /// <param name="inputFile">this is cypertext file path which want to decrypt</param>
    /// <param name="outputFile">this is output file where decrypted file need to save</param>
    /// <param name="passwordBytes">password byte</param>
    public static void AES_Decrypt(string inputFile, string outputFile, byte[] passwordBytes)
    {

        byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
        FileStream fsCrypt = new FileStream(inputFile, FileMode.Open);

        RijndaelManaged AES = new RijndaelManaged();

        AES.KeySize = 256;
        AES.BlockSize = 128;


        var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000);
        AES.Key = key.GetBytes(AES.KeySize / 8);
        AES.IV = key.GetBytes(AES.BlockSize / 8);
        AES.Padding = PaddingMode.Zeros;

        AES.Mode = CipherMode.CBC;

        CryptoStream cs = new CryptoStream(fsCrypt,
            AES.CreateDecryptor(),
            CryptoStreamMode.Read);

        FileStream fsOut = new FileStream(outputFile, FileMode.Create);

        int data;
        while ((data = cs.ReadByte()) != -1)
            fsOut.WriteByte((byte)data);

        fsOut.Close();
        cs.Close();
        fsCrypt.Close();

    }

I have reused this code : (AES encryption on large files)

Answer 1

Edit : This will not work for file of 500MB or more.

I used AES encryption last week in C#. I used this example :

https://learn.microsoft.com/en-us/dotnet/api/system.security.cryptography.aes?view=netframework-4.7.2

Here is my code :

Using the method to encrypt :

string password = "password";
using (Aes aes = Aes.Create())
        {
           //Encrypt the string
           byte[] encrypted = EncryptStringToBytes_Aes(password, aes.Key, aes.IV);
           //Decrypt the string
           string roundtrip = DecryptStringFromBytes_Aes(encrypted, aes.Key, aes.IV);
           //Convert the key, iv and encrypted message to base 64 string to get them in text
           Convert.ToBase64String(encrypted)
        }

Two methods for encrypting/decrypting :

static byte[] EncryptStringToBytes_Aes(string plainText, byte[] Key, byte[] IV)
    {
        // Check arguments.
        if (plainText == null || plainText.Length <= 0)
            throw new ArgumentNullException("plainText");
        if (Key == null || Key.Length <= 0)
            throw new ArgumentNullException("Key");
        if (IV == null || IV.Length <= 0)
            throw new ArgumentNullException("IV");
        byte[] encrypted;

        // Create an Aes object
        // with the specified key and IV.
        using (Aes aesAlg = Aes.Create())
        {
            aesAlg.Key = Key;
            aesAlg.IV = IV;

            // Create an encryptor to perform the stream transform.
            ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

            // Create the streams used for encryption.
            using (MemoryStream msEncrypt = new MemoryStream())
            {
                using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                    {
                        //Write all data to the stream.
                        swEncrypt.Write(plainText);
                    }
                    encrypted = msEncrypt.ToArray();
                }
            }
        }


        // Return the encrypted bytes from the memory stream.
        return encrypted;

    }

    static string DecryptStringFromBytes_Aes(byte[] cipherText, byte[] Key, byte[] IV)
    {
        // Check arguments.
        if (cipherText == null || cipherText.Length <= 0)
            throw new ArgumentNullException("cipherText");
        if (Key == null || Key.Length <= 0)
            throw new ArgumentNullException("Key");
        if (IV == null || IV.Length <= 0)
            throw new ArgumentNullException("IV");

        // Declare the string used to hold
        // the decrypted text.
        string plaintext = null;

        // Create an Aes object
        // with the specified key and IV.
        using (Aes aesAlg = Aes.Create())
        {
            aesAlg.Key = Key;
            aesAlg.IV = IV;

            // Create a decryptor to perform the stream transform.
            ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

            // Create the streams used for decryption.
            using (MemoryStream msDecrypt = new MemoryStream(cipherText))
            {
                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {

                        // Read the decrypted bytes from the decrypting stream
                        // and place them in a string.
                        plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }

        }

        return plaintext;

    }

Answer 2

i agreed the comment for my post.

And finally i have used the following encryption logic. And its working fine for me.

AES encryption on large files

Please comment if there is any issue on this logic.