string EncriptText, Result; //переменные для примера
            TestClass TestClass; //тестовый объект для сериализации
            Cryptography CRY; //класс для криптографических операций

            //Минимальная инициализация класса шифрования с заданием ключа (пароля)
            CRY = new Cryptography("Password");

            //Шифрование/дешифрование текста
            EncriptText = CRY.EncryptText("TestText");
            Result = CRY.DecryptText(EncriptText);

            //Шифрование/дешифрование объекта с бинарной сериализацией
            //П.С. объект должен быть с тегом [Serializable]
            CRY.SerializeAndEncrypt(new TestClass(), @"C:\test.bin");
            TestClass = CRY.DeSerializeAndDecrypt<TestClass>(@"C:\test.bin");

            //Шифрование/дешифрование файла
            //все операции производятся в потоковом режиме этим достигается высокая скорость
            //и малое потребление памяти
            CRY.EncryptFile(@"C:\test.bin", @"C:\test.bin");
            CRY.DecryptFile(@"C:\test.bin", @"C:\test.bin");

            //ДОПОЛНИТЕЛЬНО
            //Данный класс поддерживает использование неограниченного количества ключей одновременно.
            //При вызове метода шифрования/дешифрования они смешиваются и образуют один ключ
            CRY = new Cryptography(new string[] { "Password_1", "Password_2", "Password_n" });

            //Все ключи в классе между его инициализацией и использованием
            //методов шифрование/дешифрования хранятся в шифрованном виде,
            //для этого используется SessionKey, который можно задать при инициализации класса
            //сразу после ключа
            CRY = new Cryptography("Password", "SessionKey");

            //Если задать SessionKey при инициализации класса, то его нужно вводить при
            //каждом вызове метода шифрования/дешифрования
            CRY = new Cryptography("Password", "SessionKey");
            Result = CRY.EncryptText("TestText", SessionKey: "SessionKey");

            //Если SessionKey при инициализации класса не был введен, то он
            //генерируется автоматически и ключи внутри класса все равно
            //хранятся в зашифрованном виде, а вот SessionKey нет, что
            //создает уязвимость, поэтому так делать не рекомендуется.
            //Но в данном случае его ввод при шифровании/дешифровании
            //не требуется

            //Также при вызове метода шифрования/дешифрования можно указать
            //секретный ключ, который добавится в стек ключей, хранящихся в классе,
            //но только на 1 раз, таким образом для каждого метода
            //можно изменять ключи на лету, не меняя ключи,
            //заданные при инициализации, например в следующем примере
            //получится 3 разных варианта
            CRY = new Cryptography("Password");
            Result = CRY.EncryptText("TestText");
            Result = CRY.EncryptText("TestText", SecretKey: "SecretKey_1");
            Result = CRY.EncryptText("TestText", SecretKey: "SecretKey_2");

            //и конечно же можно использовать быстрый вызов (я КЭП)
            Result = new Cryptography("Password").EncryptText("TestText");

    [Serializable]
    public class TestClass
    {
        public Guid ID { get; set; }
        public string Name { get; set; }

        public TestClass()
        {
            ID = Guid.NewGuid();
            Name = "NewName";
        }
    }

using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace ThisProject
{
    public class Cryptography
    {
        private string _AutoSessionKey = "";
        private bool _UseAutoSessionKey = false;
        private int _KeySize = 256;
        private bool _ExistKey = false;
        private List<string> _Keys = new List<string>();

        public Cryptography(string Key, string SessionKey = "")
        {
            SetKeys(new string[] { Key }, SessionKey);
        }

        public Cryptography(string[] Keys, string SessionKey = "")
        {
            SetKeys(Keys, SessionKey);
        }

        public Cryptography(List<string> Keys, string SessionKey = "")
        {
            SetKeys(Keys.ToArray(), SessionKey);
        }

        public void SetKeys(string[] Keys, string SessionKey)
        {
            if (Keys != null || Keys.Length != 0)
            {
                _Keys.Clear();
                if (SessionKey == "")
                {
                    _UseAutoSessionKey = true;
                    _AutoSessionKey = Gen(32);
                }
                else
                {
                    _UseAutoSessionKey = false;
                    _AutoSessionKey = "";
                }
                byte[] KEY = new byte[32];
                byte[] IV = new byte[32];
                GetSessionKEYandIV((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV);
                foreach (string Line in Keys)
                {
                    _Keys.Add(EncryptKey(GetMd5Hash(Line), KEY, IV));
                }
                _ExistKey = true;
            }
        }

        public bool IsUseAutoSessionKey()
        {
            return _UseAutoSessionKey;
        }

        public int GetCountKeys()
        {
            return _Keys.Count;
        }

        public int GetKeySize()
        {
            return _KeySize;
        }

        public bool ExistKey()
        {
            return _ExistKey;
        }

        public void ClearKey()
        {
            _Keys.Clear();
            _ExistKey = false;
        }

        private void GetSessionKEYandIV(string SessionKey, ref byte[] Key, ref byte[] Iv)
        {
            SessionKey = GetMd5Hash(SessionKey);
            byte[] KEY = new byte[32];
            byte[] IV = new byte[32];
            for (int i = 0; i < 32; i++)
            {
                KEY[i] = Convert.ToByte(SessionKey[i]);
            }
            KEY.CopyTo(IV, 0);
            Array.Reverse(IV);
            Key = KEY;
            Array.Resize(ref IV, 16);
            Iv = IV;
        }

        private void GetKEYandIVforCRY(string SessionKey, ref byte[] Key, ref byte[] Iv, string SecretKey = "")
        {

            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetSessionKEYandIV((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV);
            string KeyLine = "";
            foreach (string Line in _Keys)
            {
                KeyLine += DecryptKey(Line, KEY, IV);
            }
            if (SecretKey != "")
                KeyLine += GetMd5Hash(SecretKey);
            KeyLine = GetMd5Hash(KeyLine);
            KEY = new byte[32];
            IV = new byte[32];
            for (int i = 0; i < 32; i++)
            {
                KEY[i] = Convert.ToByte(KeyLine[i]);
            }
            KEY.CopyTo(IV, 0);
            Array.Reverse(IV);
            Key = KEY;
            Array.Resize(ref IV, 16);
            Iv = IV;
        }

        private string GetMd5Hash(string Text)
        {
            MD5 MD5 = MD5.Create();
            byte[] Data = MD5.ComputeHash(Encoding.Default.GetBytes(Text));
            StringBuilder SB = new StringBuilder();
            for (int i = 0; i < Data.Length; i++)
            {
                SB.Append(Data[i].ToString("x2"));
            }
            return SB.ToString();
        }

        private string EncryptKey(string Text, byte[] Key, byte[] IV)
        {
            string NewText = null;
            foreach (byte Byte in EncryptStringToBytes_Aes(Text, _KeySize, Key, IV))
            {
                NewText += char.ConvertFromUtf32(Byte);
            }
            return NewText;
        }

        private string DecryptKey(string Text, byte[] Key, byte[] IV)
        {
            byte[] Bytes = new byte[Text.Length];
            for (int i = 0; i < Bytes.Length; i++)
            {
                Bytes[i] = (Byte)char.ConvertToUtf32(Text, i);
            }
            return DecryptStringFromBytes_Aes(Bytes, _KeySize, Key, IV);
        }

        private byte[] EncryptStringToBytes_Aes(string PlainText, int KeySize, byte[] Key, byte[] IV)
        {
            byte[] Encrypted;
            using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider())
            {
                AES.KeySize = KeySize;
                AES.Key = Key;
                AES.IV = IV;
                ICryptoTransform encryptor = AES.CreateEncryptor(AES.Key, AES.IV);
                MemoryStream msEncrypt = new MemoryStream();
                using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                {
                    using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                    {
                        swEncrypt.Write(PlainText);
                    }
                    Encrypted = msEncrypt.ToArray();
                }
            }
            return Encrypted;
        }

        private string DecryptStringFromBytes_Aes(byte[] CipherText, int KeySize, byte[] Key, byte[] IV)
        {
            string PlainText = null;
            using (AesCryptoServiceProvider AES = new AesCryptoServiceProvider())
            {
                AES.KeySize = KeySize;
                AES.Key = Key;
                AES.IV = IV;
                ICryptoTransform decryptor = AES.CreateDecryptor(AES.Key, AES.IV);
                using (MemoryStream msDecrypt = new MemoryStream(CipherText))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {
                            PlainText = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }
            return PlainText;
        }

        public string Gen(int CountSymbols, string Symbols = "1234567890ABCDEF")
        {
            string Result = "";
            Random Random = new Random(System.DateTime.Now.Millisecond);
            for (int sch = 1; sch <= CountSymbols; sch++)
            {
                Result += Symbols[Random.Next(0, Symbols.Length - 1)];
            }
            return Result;
        }

        public string EncryptText(string Text, string SessionKey = "", string SecretKey = "")
        {
            if (_ExistKey == false)
                throw new Exception("keys not installed");

            if (_UseAutoSessionKey == false && SessionKey == "")
                throw new Exception("SessionKey not entered");

            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetKEYandIVforCRY((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV, SecretKey);

            string NewText = null;
            foreach (byte Byte in EncryptStringToBytes_Aes(Text, _KeySize, KEY, IV))
            {
                NewText += char.ConvertFromUtf32(Byte);
            }
            return NewText;
        }

        public string DecryptText(string Text, string SessionKey = "", string SecretKey = "")
        {
            if (_ExistKey == false)
                throw new Exception("keys not installed");

            if (_UseAutoSessionKey == false && SessionKey == "")
                throw new Exception("SessionKey not entered");

            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetKEYandIVforCRY((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV, SecretKey);

            byte[] Bytes = new byte[Text.Length];
            for (int i = 0; i < Bytes.Length; i++)
            {
                Bytes[i] = (Byte)char.ConvertToUtf32(Text, i);
            }
            return DecryptStringFromBytes_Aes(Bytes, _KeySize, KEY, IV);
        }

        public void SerializeAndEncrypt(object Object, string Path, string SessionKey = "", string SecretKey = "")
        {
            if (_ExistKey == false)
                throw new Exception("keys not installed");

            if (_UseAutoSessionKey == false && SessionKey == "")
                throw new Exception("SessionKey not entered");

            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetKEYandIVforCRY((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV, SecretKey);
            using (RijndaelManaged RM = new RijndaelManaged())
            {
                RM.KeySize = _KeySize;
                RM.Key = KEY;
                RM.IV = IV;
                if (File.Exists(Path)) File.Delete(Path);

                using (FileStream FS = new FileStream(Path, FileMode.OpenOrCreate))
                {
                    using (CryptoStream CS = new CryptoStream(FS, RM.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter BW = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        BW.Serialize(CS, Object);
                    }
                }
            }
        }

        public Type DeSerializeAndDecrypt<Type>(string Path, string SessionKey = "", string SecretKey = "")
        {
            if (_ExistKey == false)
                throw new Exception("keys not installed");

            if (_UseAutoSessionKey == false && SessionKey == "")
                throw new Exception("SessionKey not entered");

            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetKEYandIVforCRY((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV, SecretKey);
            using (RijndaelManaged RM = new RijndaelManaged())
            {
                RM.KeySize = _KeySize;
                RM.Key = KEY;
                RM.IV = IV;
                using (FileStream FS = new FileStream(Path, FileMode.Open))
                {
                    using (CryptoStream CS = new CryptoStream(FS, RM.CreateDecryptor(), CryptoStreamMode.Read))
                    {
                        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter BW = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        return (Type)BW.Deserialize(CS);
                    }
                }
            }
        }

        public void EncryptFile(string OldPath, string NewPath, string SessionKey = "", string SecretKey = "")
        {
            if (_ExistKey == false)
                throw new Exception("keys not installed");

            if (_UseAutoSessionKey == false && SessionKey == "")
                throw new Exception("SessionKey not entered");

            if (File.Exists(OldPath) == false)
                throw new Exception("File not found");

            bool TimePath = false;
            if (OldPath != NewPath)
            {
                if (File.Exists(NewPath))
                    File.Delete(NewPath);
            }
            else
            {
                TimePath = true;
                NewPath += ".tf";
            }

            byte[] Buffer = new byte[2048];
            int CountRead = 0;
            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetKEYandIVforCRY((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV, SecretKey);
            using (RijndaelManaged RM = new RijndaelManaged())
            {
                RM.KeySize = _KeySize;
                RM.Key = KEY;
                RM.IV = IV;
                using (FileStream FS1 = new FileStream(OldPath, FileMode.Open))
                {
                    using (FileStream FS2 = new FileStream(NewPath, FileMode.OpenOrCreate))
                    {
                        using (CryptoStream CS1 = new CryptoStream(FS2, RM.CreateEncryptor(), CryptoStreamMode.Write))
                        {
                            do
                            {
                                CountRead = FS1.Read(Buffer, 0, 2048);
                                CS1.Write(Buffer, 0, CountRead);
                            } while (CountRead != 0);
                            CS1.Flush();
                        }
                    }
                }
            }
            if (TimePath == true)
            {
                File.Delete(OldPath);
                File.Move(NewPath, OldPath);
            }
        }

        public void DecryptFile(string OldPath, string NewPath, string SessionKey = "", string SecretKey = "")
        {
            if (_ExistKey == false)
                throw new Exception("keys not installed");

            if (_UseAutoSessionKey == false && SessionKey == "")
                throw new Exception("SessionKey not entered");

            if (File.Exists(OldPath) == false)
                throw new Exception("File not found");

            bool TimePath = false;
            if (OldPath != NewPath)
            {
                if (File.Exists(NewPath))
                    File.Delete(NewPath);
            }
            else
            {
                TimePath = true;
                NewPath += ".tf";
            }
            byte[] Buffer = new byte[2048];
            int CountRead = 0;
            byte[] KEY = new byte[32];
            byte[] IV = new byte[16];
            GetKEYandIVforCRY((_UseAutoSessionKey ? _AutoSessionKey : SessionKey), ref KEY, ref IV, SecretKey);
            using (RijndaelManaged RM = new RijndaelManaged())
            {
                RM.KeySize = _KeySize;
                RM.Key = KEY;
                RM.IV = IV;
                using (FileStream FS1 = new FileStream(OldPath, FileMode.Open))
                {
                    using (FileStream FS2 = new FileStream(NewPath, FileMode.OpenOrCreate))
                    {
                        using (CryptoStream CS1 = new CryptoStream(FS1, RM.CreateDecryptor(), CryptoStreamMode.Read))
                        {
                            do
                            {
                                CountRead = CS1.Read(Buffer, 0, 2048);
                                FS2.Write(Buffer, 0, CountRead);
                            } while (CountRead != 0);
                            FS2.Flush();
                        }
                    }
                }
            }
            if (TimePath == true)
            {
                File.Delete(OldPath);
                File.Move(NewPath, OldPath);
            }
        }
    }
}