Дешифрование файла

 public void DecryptFile(string inFile)
        {
            //создаем экземпляр Rijndael для симметричного дешифрования данных.
            RijndaelManaged rjndl = new RijndaelManaged();
            rjndl.KeySize = 256;
            rjndl.BlockSize = 256;
            rjndl.Mode = CipherMode.CBC;
 
            //создайте байт-массивы, чтобы получить длину зашифрованного ключа и IV.
            //эти значения были сохранены как 4 байта в начале зашифрованного пакета.
            byte[] LenK = new byte[4];
            byte[] LenIV = new byte[4];
 
            //создайте имя файла для зашифрованного файла.
            string outFile = DecrFolder_cl + inFile.Substring(0, inFile.LastIndexOf(".")) + ".txt";
 
            //используйте объекты FileStream для чтения зашифрованного файла (inFs) и сохранения расшифрованного файла (outFs).
            using (FileStream inFs = new FileStream(EncrFolder_cl + inFile, FileMode.Open))
            {
                inFs.Seek(0, SeekOrigin.Begin);
                inFs.Seek(0, SeekOrigin.Begin);
                inFs.Read(LenK, 0, 3);
                inFs.Seek(4, SeekOrigin.Begin);
                inFs.Read(LenIV, 0, 3);
 
                //преобразует длины в целочисленные значения.
                int lenK = BitConverter.ToInt32(LenK, 0);
                int lenIV = BitConverter.ToInt32(LenIV, 0);
 
                int startC = lenK + lenIV + 8; //начальная позиция зашифрованного текста
                int lenC = (int)inFs.Length - startC; //его длину
 
                //создание байтовых массивов для зашифрованного ключа Rijndael, IV и шифрованного текста
                byte[] KeyEncrypted = new byte[lenK];
                byte[] IV = new byte[lenIV];
 
                //извлечение ключа и IV, начиная с индекса 8, после значения длины.
                inFs.Seek(8, SeekOrigin.Begin);
                inFs.Read(KeyEncrypted, 0, lenK);
                inFs.Seek(8 + lenK, SeekOrigin.Begin);
                inFs.Read(IV, 0, lenIV);
                Directory.CreateDirectory(DecrFolder_cl);
                //использование RSACryptoServiceProvider для дешифрования ключа Rijndael
                //rsa = new RSACryptoServiceProvider(cspp);
                //RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cspp);
                byte[] KeyDecrypted = rsa.Decrypt(KeyEncrypted, false);
                //ключ расшифрования
                ICryptoTransform transform = rjndl.CreateDecryptor(KeyDecrypted, IV);
 
                //расшифровать шифрованный текст из FileSteam зашифрованного файла (inFs) в FileStream для расшифрованного файла (outFs).
                using (FileStream outFs = new FileStream(outFile, FileMode.Create))
                {
                    int count = 0;
                    int offset = 0;
 
                    //blockSizeBytes может быть любого произвольного размера
                    int blockSizeBytes = rjndl.BlockSize / 8;
                    byte[] data = new byte[blockSizeBytes];
 
                    //дешифрование с начала зашиврованного текста
                    inFs.Seek(startC, SeekOrigin.Begin);
                    using (CryptoStream outStreamDecrypted = new CryptoStream(outFs, transform, CryptoStreamMode.Write))
                    {
                        do
                        {
                            count = inFs.Read(data, 0, blockSizeBytes);
                            offset += count;
                            outStreamDecrypted.Write(data, 0, count);
                        }
                        while (count > 0);
 
                        outStreamDecrypted.FlushFinalBlock();
                        outStreamDecrypted.Close();
                    }
                    outFs.Close();
                }
                inFs.Close();
            }
        }

    class Crypto
    {
 
        public byte[] AES_Encrypt(byte[] bytesToBeEncrypted, byte[] passwordBytes, byte[] saltBytes)
        {
            byte[] encryptedBytes = null;
            if (saltBytes == null)
            {
                saltBytes = new byte[] { 101, 111, 67, 85, 13, 1, 217, 99 };
            }
            if (passwordBytes == null)
            {
                SHA256 mySHA256 = SHA256Managed.Create();
                passwordBytes = mySHA256.ComputeHash(Utils.Converting.GetBytes("Сорок тысяч обезьян с жопой что-то там того"));
            }
            using (MemoryStream ms = new MemoryStream())
            {
                using (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.Mode = CipherMode.CBC;
                    AES.Padding = PaddingMode.PKCS7;
                    using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length);
                    }
                    encryptedBytes = ms.ToArray();
                }
            }
 
            return encryptedBytes;
        }
 
        public byte[] AES_Decrypt(byte[] bytesToBeDecrypted, byte[] passwordBytes, byte[] saltBytes)
        {
            byte[] decryptedBytes = null;
 
            if (saltBytes == null)
            {
                saltBytes = new byte[] { 101, 111, 67, 85, 13, 1, 217, 99 };
            }
 
            if (passwordBytes == null)
            {
                SHA256 mySHA256 = SHA256Managed.Create();
                passwordBytes = mySHA256.ComputeHash(Utils.Converting.GetBytes("Сорок тысяч обезьян с жопой что-то там того"));
            }
            using (MemoryStream ms = new MemoryStream())
            {
                using (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.Mode = CipherMode.CBC;
                    AES.Padding = PaddingMode.PKCS7;
                    try
                    {
                        using (var cs = new CryptoStream(ms, AES.CreateDecryptor(), CryptoStreamMode.Write))
                        {
                            cs.Write(bytesToBeDecrypted, 0, bytesToBeDecrypted.Length);
                        }
                        decryptedBytes = ms.ToArray();
                        return decryptedBytes;
                    }
                    catch
                    {
                        return null;
                    }
 
                }
            }
        }
    }

using System.IO;
using System.Security.Cryptography;

        public static byte[] GetBytes(string str)
        {
            byte[] bytes = new byte[str.Length * sizeof(char)];
            System.Buffer.BlockCopy(str.ToCharArray(), 0, bytes, 0, bytes.Length);
            return bytes;
        }
 
        public static string GetString(byte[] bytes)
        {
            char[] chars = new char[bytes.Length / sizeof(char)];
            System.Buffer.BlockCopy(bytes, 0, chars, 0, bytes.Length);
            return new string(chars);
        }