Aes шифрование

public class Rijndael
    {
        
        public byte[] Encode(byte[] data, string password, int bitCount, bool useIV = false)
        {
            // если исходный массив пустой, то возвращаем пустое значение без генерации исключения
            if (data == null) return null;
 
            // пароль должен быть задан, иначе мы не сможем создать ключ шифрования
            if (string.IsNullOrEmpty(password))
                throw new RijndaelException("Не задан пароль для шифрования данных.");
 
            // разрешены ключи размером только 128, 192 или 256 бит    // если ключ не подходит выводится сообщение
            if (!(bitCount == 128 || bitCount == 192 || bitCount == 256))
                throw new RijndaelException("Недопустимый размер ключа: " + bitCount + " бит. Допустимо использовать ключ размером 128, 192 или 256 бит.");
 
            try
            {
                int bytesCount = bitCount / 8;  // 16/24/32     // Разбивает на байты  
 
                // готовим ключ на основе пароля
                byte[] key = prepareKey(password, bytesCount);
 
                // создаём сеансовый одноразовый ключ
                byte[] counterBlock = (useIV) ? createCounterBlock() : RijndaelData.counterBlockDefault;
 
                // сеансовый ключ будет храниться в первых RijndaelData.IVSize байтах зашифрованного значения
                byte[] sk = null;
                if (useIV)
                {
                    sk = new byte[RijndaelData.IVSize];
                    for (int i = 0; i < RijndaelData.IVSize; i++)
                        sk[i] = counterBlock[i];
                }
 
                // шифруем данные
                byte[] enc = EncodeBytes(data, counterBlock, key);
 
                // сведение сеансового ключа и зашифрованных данных в единый массив байт
                int IVSize = (useIV) ? RijndaelData.IVSize : 0;
                byte[] result = new byte[enc.Length + IVSize];
 
                if (useIV)
                {
                    for (int i = 0; i < IVSize; i++)
                    {
                        result[i] = sk[i];
                    }
                }
 
                for (int i = 0; i < enc.Length; i++)
                {
                    result[i + IVSize] = enc[i];
                }
 
                return result;
            }
            catch (Exception e)
            {
                throw new RijndaelException("Ошибка при шифровании данных.", e);
            }
        }
 
        public byte[] Decode(byte[] encodedData, string password, int bitCount, bool useIV = false)
        {
            // если исходный массив пустой, то возвращаем пустое значение без генерации исключения
            if (encodedData == null) return null;
 
            // пароль должен быть задан, иначе мы не сможем создать ключ шифрования
            if (string.IsNullOrEmpty(password))
                throw new RijndaelException("Не задан пароль для восстановления данных.");
 
            // разрешены ключи размером только 128, 192 или 256 бит
            if (!(bitCount == 128 || bitCount == 192 || bitCount == 256))
                throw new RijndaelException("Недопустимый размер ключа: " + bitCount + " бит. Допустимо использовать ключ размером 128, 192 или 256 бит.");
 
            try
            {
                int bytesCount = bitCount / 8;  // 16/24/32
 
                // готовим ключ на основе пароля
                byte[] key = prepareKey(password, bytesCount);
 
                // извлекаем сеансовый одноразовый ключ из первых RijndaelData.IVSize байт зашифрованного значения
                byte[] counterBlock = null;
                if (useIV)
                {
                    counterBlock = new byte[RijndaelData.blockSize];
                    for (int i = 0; i < RijndaelData.IVSize; i++)
                        counterBlock[i] = encodedData[i];
                }
                else
                {
                    counterBlock = RijndaelData.counterBlockDefault;
                }
 
                // отрезаем сеансовый ключ
                byte[] encdata = null;
                if (useIV)
                {
                    encdata = Slice(encodedData, RijndaelData.IVSize, encodedData.Length);
                }
                else
                {
                    encdata = encodedData;
                }
                
                // восстанавливаем данные
                byte[] data = DecodeBytes(encdata, counterBlock, key);
 
                return data;
            }
            catch (Exception e)
            {
                throw new RijndaelException("Ошибка при восстановлении данных.", e);
            }
        }
 
        private byte[] prepareKey(string password, int bytesCount)
        {
            byte[] pwBytes = new byte[bytesCount];  // Создаем массив байтов для будущего пароля
 
            UTF8Encoding ue = new UTF8Encoding();  // Кодируем в UTF-8 
            byte[] pwd = ue.GetBytes(password); // Разбираем пароль (string password) на байты 
 
            for (int i = 0; i < bytesCount; i++) 
            {
                // используем только первые 16/24/32 байт пароля для ключа
                pwBytes[i] = (pwd.Length <= i) ? (byte)0x00 : pwd[i];   // Добавляем нулевые байты к паролю 
            }  
 
            // получаем 16-байтовый ключ
            byte[] key = Cipher(pwBytes, KeyExpansion(pwBytes));
 
            // расширяем ключ до 16/24/32 байт
            key = key.Concat(Slice(key, 0, bytesCount - 16)).ToArray<byte>();
 
            return key;
        }
 
        private byte[] createCounterBlock()
        {
            byte[] counterBlock = new byte[RijndaelData.blockSize];
 
            DateTime start = new DateTime(1970, 01, 01);
            DateTime now = DateTime.Now;
            long elapsedTicks = now.Ticks - start.Ticks;
            TimeSpan time = new TimeSpan(elapsedTicks);
 
            int nonceMs = time.Milliseconds;
            int nonceSec = (int)time.TotalSeconds;
            Random rand = new Random();
            int nonceRnd = rand.Next(0xffff);
 
            for (int i = 0; i < 2; i++)
                counterBlock[i] = (byte)((unchecked((uint)nonceMs) >> i * 8) & 0xff); // сдвиг с заполнением (nonceMs >>> i*8)
            for (int i = 0; i < 2; i++)
                counterBlock[i + 2] = (byte)((unchecked((uint)nonceRnd) >> i * 8) & 0xff);
            for (int i = 0; i < 4; i++)
                counterBlock[i + 4] = (byte)((unchecked((uint)nonceSec) >> i * 8) & 0xff);
 
            return counterBlock;
        }
 
        private byte[] EncodeBytes(byte[] data, byte[] counterBlock, byte[] key)
        {
            // расширение ключа
            byte[,] keySchedule = KeyExpansion(key);
 
            // шифрование по блокам
            int blockCount = (int)Math.Ceiling((double)(data.Length) / RijndaelData.blockSize);
            byte[][] cipherData = new byte[blockCount][];
 
            for (int b = 0; b < blockCount; b++)
            {
                for (int c = 0; c < 8; c++)
                    counterBlock[15 - c] = (byte)((unchecked((uint)b >> c * 8) & 0xff));
 
                byte[] cipherCntr = Cipher(counterBlock, keySchedule);
 
                int blockLength = b < blockCount - 1 ? RijndaelData.blockSize : (data.Length - 1) % RijndaelData.blockSize + 1;
                byte[] cipherChar = new byte[blockLength];
 
                cipherData[b] = new byte[blockLength];
                for (int i = 0; i < blockLength; i++)
                {
                    cipherData[b][i] = (byte)(cipherCntr[i] ^ data[b * RijndaelData.blockSize + i]);
                }
            }
 
            // сведение блоков в единый массив байт
            byte[] result = new byte[(blockCount - 1) * RijndaelData.blockSize + ((data.Length - 1) % RijndaelData.blockSize + 1)];
            int idx = 0;
            for (int b = 0; b < blockCount; b++)
            {
                for (int i = 0; i < cipherData[b].Length; i++)
                {
                    result[idx] = cipherData[b][i];
                    idx++;
                }
            }
 
            return result;
        }
 
        public byte[] DecodeBytes(byte[] cipherData, byte[] counterBlock, byte[] key)
        {
            // расширение ключа
            byte[,] keySchedule = KeyExpansion(key);
 
            // разделяем закодированное значение на блоки
            int blockCount = (int)Math.Ceiling((double)(cipherData.Length) / RijndaelData.blockSize);
            byte[][] ctArray = new byte[blockCount][];
            for (int b = 0; b < blockCount; b++)
                ctArray[b] = Slice(cipherData, b * RijndaelData.blockSize, (b + 1) * RijndaelData.blockSize);
 
            // расшифрование по блокам
            byte[][] data = new byte[ctArray.Length][];
 
            int length = 0;
 
            for (int b = 0; b < blockCount; b++)
            {
                for (int c = 0; c < 8; c++)
                    counterBlock[15 - c] = (byte)((unchecked((uint)b) >> c * 8) & 0xff);
 
                byte[] cipherCntr = Cipher(counterBlock, keySchedule);
 
                data[b] = new byte[ctArray[b].Length];
                for (int i = 0; i < ctArray[b].Length; i++)
                {
                    data[b][i] = (byte)(cipherCntr[i] ^ (byte)(ctArray[b][i]));
                    length++;
                }
            }
 
            // сведение блоков в единый массив байт
            byte[] result = new byte[length];
            int idx = 0;
            for (int b = 0; b < blockCount; b++)
            {
                for (int i = 0; i < data[b].Length; i++)
                {
                    result[idx] = data[b][i];
                    idx++;
                }
            }
 
            return result;
        }
 
        public string Encode(string text, string password, int bitCount, bool useIV = false)
        {
            // если исходный текст пустой, то возвращаем пустое значение без генерации исключения
            if (string.IsNullOrEmpty(text))
                return text;
 
            // преобразуем текст в массив байтов
            UTF8Encoding ue = new UTF8Encoding();
            byte[] data = ue.GetBytes(text);
 
            // шифруем массив байтов
            byte[] enc = Encode(data, password, bitCount, useIV);
 
            // преобразуем полученный массив байтов в текст и кодируем в Base64
            string result = Base64EncodeBytes(enc);
 
            return result;
        }
 
        public string Decode(string ciphertext, string password, int bitCount, bool useIV = false)
        {
            // если зашифрованное значение пустое, то возвращаем пустое значение без генерации исключения
            if (string.IsNullOrEmpty(ciphertext))
                return ciphertext;
 
            // восстанавливаем строку из Base64 и преобразуем в массив байтов
            byte[] encdata = Base64DecodeBytes(ciphertext);
 
            // дешифруем массив байт
            byte[] data = Decode(encdata, password, bitCount, useIV);
 
            // преобразуем полученный массив байтов в текст
            string text = System.Text.Encoding.UTF8.GetString(data);
 
            return text;
        }
 
        // шифрование блока данных
        public byte[] Cipher(byte[] block, byte[,] key)
        {
            int Nb = 4;                         // размер блока (в 4-байтовых словах), количество колонок в состоянии (для AES всегда 4)
            int Nr = key.GetLength(0) / Nb - 1; // количество раундов: 10/12/14 для 128/192/256-битного ключа соответственно
 
            byte[,] state = new byte[4, Nb];
 
            for (int i = 0; i < 4 * Nb; i++)
            {
                double d = i / 4;
                state[i % 4, (int)Math.Floor(d)] = block[i]; // Внесение входных байтов в матрицу состояния по столбцам
            }
 
            state = AddRoundKey(state, key, 0, Nb); // Добавление раундового ключа
 
            for (int round = 1; round < Nr; round++)   // Для 9/11/13 раундов
            {
                state = SubBytes(state, Nb);
                state = ShiftRows(state, Nb);
                state = MixColumns(state);
                state = AddRoundKey(state, key, round, Nb);
            }
 
            state = SubBytes(state, Nb);
            state = ShiftRows(state, Nb);
            state = AddRoundKey(state, key, Nr, Nb);
 
            var output = new byte[4 * Nb]; // Массив для вывода зашифрованных байтов, var необходим для его заполнения
 
            for (int i = 0; i < 4 * Nb; i++)
            {
                double d = i / 4;
                output[i] = state[i % 4, (int)Math.Floor(d)];
            }
 
            return output;
        }