CryptographicException: Недопустимая длина данных для шифрования

            try
            {
                RijndaelManaged aes = new RijndaelManaged();
      
                aes.Mode = CipherMode.CFB;
                aes.Padding = PaddingMode.None ;
                aes.Key =  Encoding.UTF8.GetBytes(Key);
                aes.GenerateIV();
 
                ICryptoTransform encrypto = aes.CreateEncryptor();
 
                byte[] plainTextByte = Encoding.UTF8.GetBytes(plainText);
   
                return encrypto.TransformFinalBlock(plainTextByte, 0, plainTextByte.Length);;       
                       
            }
            catch (Exception ex) 
            {
                Console.WriteLine(ex.ToString());
            }

public static byte[] crypto (long src, string Key) 
        {
            String plainText = src.ToString();
 
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Padding = PaddingMode.None;
                aesAlg.Mode = CipherMode.CFB;
                aesAlg.Key = Encoding.UTF8.GetBytes(Key);
                aesAlg.GenerateIV();
 
                byte[] asd = aesAlg.IV;
                byte[] txt = Encoding.UTF8.GetBytes(plainText);
 
                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);
                        }
 
                        return msEncrypt.ToArray();                
 
                    }
                }
            }
        }

        public static byte[] crypto(long src, string Key)
        {
            using (Aes aesAlg = Aes.Create())
            {
                aesAlg.Padding = PaddingMode.None;
                aesAlg.Mode = CipherMode.CFB;
                aesAlg.Key = Encoding.UTF8.GetBytes(Key);
                aesAlg.GenerateIV();
 
                byte[] data = BitConverter.GetBytes(src);
 
                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))
                    {
                        csEncrypt.Write(data);
                        return msEncrypt.ToArray();
                    }
                }
            }
        }

                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        csEncrypt.Write(data);
                        CryptoStream.Close();
                        return msEncrypt.ToArray();
                    }
                }

                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);
                        }
                        csEncrypt.Close();
                        return msEncrypt.ToArray();                
 
                    }
                }

            long val = 1234567890;
            byte[] data = BitConverter.GetBytes(val);
            byte[] key = Encoding.UTF8.GetBytes("testtesttesttest");
            byte[] iv = Encoding.UTF8.GetBytes("1234123412341234");
 
            byte[] encrypted = Encrypt(data, key, iv);
            byte[] decrypted = Decrypt(encrypted, key, iv);
 
            long val2 = BitConverter.ToInt64(decrypted);

        public static byte[] Encrypt(byte[] data, byte[] key, byte[] iv)
        {
            using Aes aesAlg = Aes.Create();
            aesAlg.Padding = PaddingMode.None;
            aesAlg.Mode = CipherMode.CFB;
            aesAlg.Key = key;
            aesAlg.IV = iv;
 
            using ICryptoTransform encryptor = aesAlg.CreateEncryptor();
 
            // Create the streams used for encryption.
            using MemoryStream msEncrypt = new MemoryStream();
            using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                csEncrypt.Write(data);
            return msEncrypt.ToArray();
        }
 
        public static byte[] Decrypt(byte[] data, byte[] key, byte[] iv)
        {
            using Aes aesAlg = Aes.Create();
            aesAlg.Padding = PaddingMode.None;
            aesAlg.Mode = CipherMode.CFB;
            aesAlg.Key = key;
            aesAlg.IV = iv;
 
            using ICryptoTransform decryptor = aesAlg.CreateDecryptor();
 
            // Create the streams used for decryption.
            using MemoryStream msEncrypted = new MemoryStream(data);
            using CryptoStream csEncrypt = new CryptoStream(msEncrypted, decryptor, CryptoStreamMode.Read);
            using MemoryStream msDecrypted = new MemoryStream();
            csEncrypt.CopyTo(msDecrypted);
            return msDecrypted.ToArray();
        }

            using (var msEncrypt = new MemoryStream())
            {
                using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    csEncrypt.Write(data);
                    return msEncrypt.ToArray();
                }
            }

            using (var msEncrypt = new MemoryStream())
            {
                using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    csEncrypt.Write(data);
                }
                return msEncrypt.ToArray();
            }

    class Program
    {
        static void Main(string[] args)
        {
            var key = new byte[32];
            var iv = new byte[16];
            var manager = new CryptoManager(key, iv);
 
            var val = 1234567890L;
            var data = manager.Encrypt(val);
            //File.WriteAllBytes(@"D:\Temp\1.nya", data);
            var result = manager.DecryptToLong(data);
            if (result != val) throw new Exception();
 
            var str =
@"Black Rock Shooter (яп. ブラック★ロックシューター Буракку Рокку Сю:та:, неоф. рус. «Стрелок с Чёрной Скалы») — OVA режиссёра Синобу Ёсиоки, вышедшая 25 июля 2010 года. Сюжет был основан на одноимённой песне вокалоида Мику Хацунэ[1].
30 сентября 2009 года вышел пилотный DVD аниме. В рамках рекламной кампании аниме выпущены бонусные DVD-диски и распространены вместе с номерами журналов Megami Magazine, Animedia и Hobby Japan. 50-минутная OVA-версия аниме доступна для свободного скачивания с 25 июля по 31 августа 2010 года на официальном сайте[2].
2 февраля 2012 вышло продолжение — аниме-сериал, его трансляция проходит в программном блоке noitaminA телекомпании Fuji TV[3]. ";
            data = manager.Encrypt(str);
            //File.WriteAllBytes(@"D:\Temp\2.nya", data);
            var strResult = manager.DecryptToString(data);
            if (strResult != str) throw new Exception();
            Console.WriteLine("Nya!");
            Console.ReadKey();
        }
    }
 
    public class CryptoManager : IDisposable
    {
        private readonly SymmetricAlgorithm _algorithm;
 
        public CryptoManager(byte[] key, byte[] iv)
        {
            _algorithm = new RijndaelManaged();
            //_algorithm = Aes.Create();
            _algorithm.Mode = CipherMode.CFB;
            _algorithm.Padding = PaddingMode.None;
            _algorithm.Key = key;
            _algorithm.IV = iv;
        }
 
        public void Dispose()
        {
            _algorithm?.Dispose();
        }
 
        public byte[] Encrypt(byte[] data)
        {
            using (var cryptoTransform = _algorithm.CreateEncryptor())
                return TransformData(data, cryptoTransform);
        }
 
        public byte[] Encrypt(long val)
        {
            return Encrypt(BitConverter.GetBytes(val));
        }
 
        public byte[] Encrypt(string val)
        {
            return Encrypt(Encoding.UTF8.GetBytes(val));
        }
 
        public byte[] Decrypt(byte[] data)
        {
            using (var cryptoTransform = _algorithm.CreateDecryptor())
                return TransformData(data, cryptoTransform);
        }
 
        public long DecryptToLong(byte[] data)
        {
            var decryptData = Decrypt(data);
            return BitConverter.ToInt64(decryptData, 0);
        }
 
        public string DecryptToString(byte[] data)
        {
            var decryptData = Decrypt(data);
            return Encoding.UTF8.GetString(decryptData);
        }
 
        private byte[] TransformData(byte[] data, ICryptoTransform cryptoTransform)
        {
            using (var memory = new MemoryStream())
            {
 
                var output = new byte[cryptoTransform.OutputBlockSize];
                var input = new byte[cryptoTransform.InputBlockSize];
 
                var n = data.Length - cryptoTransform.InputBlockSize;
                var i = 0;
                for (; i < n; i += input.Length)
                {
                    Array.Copy(data, i, input, 0, input.Length);
                    var count = cryptoTransform.TransformBlock(input, 0, input.Length, output, 0);
                    memory.Write(output, 0, count);
                }
                for (var x = 0; x < input.Length; x++)
                    input[x] = 0;
                n = data.Length - i;
                Array.Copy(data, i, input, 0, n);
                output = cryptoTransform.TransformFinalBlock(input, 0, input.Length);
                memory.Write(output, 0, n);
 
                return memory.ToArray();
            }
        }
    }