Алгоритм шифрования ГОСТ 28147-89. Режим простой замены

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
 
namespace InformationSecurity1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        byte[,] Sblocks = {
                            {4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3},
                            {14, 11, 4, 12, 6,  13, 15, 10, 2,  3,  8,  1,  0,  7,  5,  9},
                            {5, 8,1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0,  9,  11},
                            {7, 13, 10, 1, 0, 8 ,9  ,15, 14, 4, 6, 12,  11, 2,  5,  3},
                            {6, 12, 7,  1,  5,  15, 13, 8,  4,  10, 9,  14, 0,  3,  11, 2},
                            {4, 11, 10, 0,  7,  2,  1,  13, 3,  6,  8,  5,  9,  12, 15, 14},
                            {13,    11, 4,  1,  3,  15, 5,  9,  0,  10, 14, 7,  6,  8,  2,  12},
                            {1, 15, 13, 0,  5,  7,  10, 4,  9,  2,  3,  14, 6,  11, 8,  12}
                          };//Блок замен
        List<byte[]> lsKey = new List<byte[]>();//Список подключей размером в 4 байта
        List<byte[]> lsData = new List<byte[]>();//Список блоков открытого текста размером 8 байт
 
        byte[] fillingArrayData(List<byte[]> list)
        {
            byte[] array = new byte[list.Count * 8];
            int index = 0;
            for (int i = 0; i < list.Count; ++i)
            {
                for (int j = 0; j < list[i].Length; ++j)
                {
                    array[index] = list[i][j];
                    index++;
                }
            }
            return array;
        }
 
        void fillingListData(string data)
        {
            byte[] temp = Encoding.Default.GetBytes(data);
            int count = 0;
            byte[] k = new byte[8];
            for (int i = 0; i < temp.Length; ++i)
            {
                if (count != 8)
                {
                    k[count] = temp[i];
                    count++;
                }
                else
                {
                    lsData.Add(k);
                    --i;
                    count = 0;
                    k = new byte[8];
                }
            }
            lsData.Add(k);
        }
 
        void fillingListKey(string key)
        {
            byte[] temp = Encoding.Default.GetBytes(key);
            int count = 0;
            byte[] k = new byte[4];
            for (int i = 0; i < temp.Length; ++i)
            {
                if (count != 4)
                {
                    k[count] = temp[i];
                    count++;
                }
                else
                {
                    lsKey.Add(k);
                    --i;
                    count = 0;
                    k = new byte[4];
                }
            }
            lsKey.Add(k);
        }
 
        int lengthKey(string key)
        {
            byte[] temp = Encoding.Default.GetBytes(key);
            return temp.Length;
        }
 
        byte[] retL(byte[] data)
        {
            byte[] temp = new byte[4];
            for (int i = 0; i < 4; ++i)
            {
                temp[i] = data[i];
            }
            return temp;
        }//Возвращает старшую часть 8 байтового блока данных
 
        byte[] retR(byte[] data)
        {
            byte[] temp = new byte[4];
            int count = 4;
            for (int i = 0; i < 4; ++i)
            {
                temp[i] = data[count];
                count++;
            }
            return temp;
        }//Возвращает младшую часть 8 байтового блока данных
 
 
        byte[] mod2_32(byte[] a, byte[] b)
        {
            byte[] res;
            UInt32 A = BitConverter.ToUInt32(a, 0);
            UInt32 B = BitConverter.ToUInt32(b, 0);
            A += B;
            res = BitConverter.GetBytes(A);
            return res;
        }// Сложение по модулю 2^32
 
        UInt32 func(byte[] R, byte[] Ki)
        {
            byte[] s8 = new byte[8];
            int count = 0;
            byte[] s = mod2_32(R, Ki);
            for (int j = 0; j < s.Length; ++j)
            {
                byte e = (byte)((s[j] >> 4));
                s8[count] = e;
                ++count;
                byte f = (byte)((s[j] & 15));
                s8[count] = f;
                ++count;
            }
            for (int i = 0; i < 8; ++i)
            {
                    s8[i] = Sblocks[i, (int)s8[i]];
            }
            UInt32 result = BitConverter.ToUInt32(s8, 0);
            result = result << 11;
            return result;
        }
 
        byte[] encode(byte[] data)
        {
            byte[] L = retL(data);
            byte[] R = retR(data);
            byte[] block = new byte[4];
            UInt32 temp = 0;
            int index = 0;
            bool flag = true;
            for (int i = 0; i < 32; ++i)
            {
                if (i == 24)
                {
                    flag = false;
                }
                if (flag)
                {
                    if (index == 8)
                    {
                        index = 0;
                    }
                    temp = func(R, lsKey[index]);
                    index++;
                }
                else
                {
                    if (index == 8)
                    {
                        --index;
                    }
                    temp = func(R, lsKey[index]); 
                    --index;
                }
                temp = BitConverter.ToUInt32(L, 0) ^ temp;
                L = R;
                R = BitConverter.GetBytes(temp);
            }
            byte[] result = new byte[8];
            index = 0;
            for (int i = 0; i < 8; ++i)
            {
                if (i < 4)
                {
                    result[i] = L[i];
                }
                else
                {
                    result[i] = R[index];
                    index++;
                }
            }
            return result;
        }
 
        byte[] decode(byte[] data)
        {
            byte[] L = retL(data);
            byte[] R = retR(data);
            byte[] block = new byte[4];
            UInt64 temp = 0;
            int index = 0;
            bool flag = false;
            for (int i = 0; i < 32; ++i)
            {
                if (i == 24)
                {
                    flag = true;
                }
                if (flag)
                {
                    if (index == 8)
                    {
                        index = 0;
                    }
                    temp = func(R, lsKey[index]);
                    index++;
                }
                else
                {
                    if (index == 0)
                    {
                        index=7;
                    }
                    temp = func(R, lsKey[index]); //index выходит за рамки равен -1
                    --index;
                }
                temp = BitConverter.ToUInt32(L, 0) ^ temp;
                L = R;
                R = BitConverter.GetBytes(temp);
                //++index;
            }
            byte[] result = new byte[8];
            index = 0;
            for (int i = 0; i < 8; ++i)
            {
                if (i < 4)
                {
                    result[i] = L[i];
                }
                else
                {
                    result[i] = R[index];
                    index++;
                }
            }
            return result;
        }
 
        private void textBox2_TextChanged(object sender, EventArgs e)
        {
            if (lengthKey(textBox2.Text) < 32)
            {
                textBox2.BackColor = Color.Red;
                button1.Enabled = false;
            }
            else
            {
                if (lengthKey(textBox2.Text) > 32)
                {
                    textBox2.BackColor = Color.Red;
                    button1.Enabled = false;
                }
                else
                {
                    textBox2.BackColor = Color.Green;
                    button1.Enabled = true;
                    textBox2.MaxLength = textBox2.TextLength;
                }
            }
 
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            fillingListKey(textBox2.Text);
            fillingListData(textBox1.Text);
           // byte[] temp = Encoding.Default.GetBytes(textBox1.Text);
 
            byte[] t = new byte[8];
            List<byte[]> result = new List<byte[]>();
            for (int i = 0; i < lsData.Count; ++i)
            {
                t = encode(lsData[i]);
                result.Add(t);
            }
            byte[] res = fillingArrayData(result);
            textBox3.Text = Encoding.Default.GetString(res);
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            fillingListKey(textBox2.Text);
            fillingListData(textBox3.Text);
            byte[] temp = Encoding.Default.GetBytes(textBox3.Text);
            byte[] t = new byte[8];
            List<byte[]> result = new List<byte[]>();
            for (int i = 0; i < lsData.Count; ++i)
            {
                t = decode(lsData[i]);
                result.Add(t);
            }
            byte[] res = fillingArrayData(result);
            textBox4.Text = Encoding.Default.GetString(res);
        }
    }
}

N1 = (uint)(dateFragment >> 32);

(uint)((X + N1) % (Convert.ToUInt64(Math.Pow(2, 32))));

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace IS
{
    public static class Encryption
    {
        #region Инициализация блока замен
        private static byte[,] Sblocks = {
                            {4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3},
                            {14, 11, 4, 12, 6,  13, 15, 10, 2,  3,  8,  1,  0,  7,  5,  9},
                            {5, 8,1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0,  9,  11},
                            {7, 13, 10, 1, 0, 8 ,9  ,15, 14, 4, 6, 12,  11, 2,  5,  3},
                            {6, 12, 7,  1,  5,  15, 13, 8,  4,  10, 9,  14, 0,  3,  11, 2},
                            {4, 11, 10, 0,  7,  2,  1,  13, 3,  6,  8,  5,  9,  12, 15, 14},
                            {13,    11, 4,  1,  3,  15, 5,  9,  0,  10, 14, 7,  6,  8,  2,  12},
                            {1, 15, 13, 0,  5,  7,  10, 4,  9,  2,  3,  14, 6,  11, 8,  12}
                          };//Блок замен
        #endregion
 
        private static bool mod64(int length)//Проверка делится ли открытый текст нацело на 64 бита
        {
            if ((length % 8) == 0)
                return true;
            else
                return false;
        }
 
        private static List<UInt64> fillingListData(string data)//Возвращает список из 64-х битных блоков данных
        {
            List<UInt64> resultList = new List<UInt64>();
            byte[] temp = Encoding.Default.GetBytes(data);
            int startIndex = 0;
            while (startIndex < temp.Length)
            {
                resultList.Add(BitConverter.ToUInt64(temp, startIndex));
                startIndex += 8;
            }
            return resultList;
        }
 
        private static List<UInt32> fillingListKey(string key)
        {
            List<UInt32> resultList = new List<UInt32>();
            byte[] temp = Encoding.Default.GetBytes(key);
            resultList.Add(BitConverter.ToUInt32(temp, 0));
            resultList.Add(BitConverter.ToUInt32(temp, 4));
            resultList.Add(BitConverter.ToUInt32(temp, 8)); 
            resultList.Add(BitConverter.ToUInt32(temp, 12));
            resultList.Add(BitConverter.ToUInt32(temp, 16));
            resultList.Add(BitConverter.ToUInt32(temp, 20));
            resultList.Add(BitConverter.ToUInt32(temp, 24));
            resultList.Add(BitConverter.ToUInt32(temp, 28));
            return resultList;
        }//Возвращает список из 32-х битных блоков ключа
 
        private static string getPartString(UInt64 partText)
        {
            byte[] temp = BitConverter.GetBytes(partText);
            string result = Encoding.Default.GetString(temp);
            return result;
        }//Возврашает часть зашифрованной/расшифрованной строки
 
        private static UInt32 mod2_32(UInt32 a, UInt32 b)
        {
            UInt32 result = a + b;
            return result;
        }// Сложение по модулю 2^32
 
        private static UInt32 shiftN(UInt32 num, int n)
        {
            UInt32 c = num;
            for (int i = 0; i < n; ++i)
            {
                //UInt32 temp = (UInt32)(num / Convert.ToUInt32(Math.Pow(2, 31)));
                UInt32 temp = num >> 31;
                num <<= 1;
                num += temp;
            }
            return num;
        }//циклический сдвиг 32-х битового числа на n разрядов 
 
        private static UInt32 retL(UInt64 data)
        {
            data >>= 32;
            UInt32 result = (UInt32)data;//temp;
            return result;
        }//Возвращает старшую часть 8 байтового блока данных
 
        private static UInt32 retR(UInt64 data)
        {
            UInt32 result = (UInt32)data;
            return result;
        }//Возвращает младшую часть 8 байтового блока данных
 
        private static UInt32 func(UInt32 R, UInt32 Ki)
        {
            UInt32 s = mod2_32(R, Ki);
            List<UInt32> partsS = new List<UInt32>();
            for (int i = 0; i < 8; ++i)
            {
 
                UInt32 temp = s >> 28;
                partsS.Add(temp);
                s <<= 4;
            }
            partsS.Reverse();
            for (int i = 0; i < 8; ++i)
            {
                partsS[i] = Sblocks[i, (int)partsS[i]];
            }
            s = 0;
            for (int i = 0; i < partsS.Count; ++i)
            {
                s += partsS[i];
                s <<= 4;
            }
                s = shiftN(s, 11);
            return s;
        }//Функция f(Ri, Ki), используемая в сети Фейстеля
 
        private static UInt64 encodePartData(UInt64 partData, List<UInt32> partsKey)
        {
            for (int i = 0; i < 24; ++i)
            {
                partData = feistel(partData, partsKey[i%8]);
            }
            for (int i = 7; i >= 0; --i)
            {
                partData = feistel(partData, partsKey[i]);
            }
            UInt64 result = (partData << 32) + (partData >> 32);
            return result;
        }//Шифрует 64-х битный блок данных
 
        private static UInt64 decodePartData(UInt64 partData, List<UInt32> partsKey)
        {
            for (int i = 0; i < 8; ++i)
            {
                partData = feistel(partData, partsKey[i]);
            }
            for (int i = 23; i >= 0; --i)
            {
                partData = feistel(partData, partsKey[i % 8]);
            }
            UInt64 result = (partData << 32) + (partData >> 32);
            return result;
        }//Расшифровывает 64-х битный блок шифрованных данных
 
        private static UInt64 feistel(UInt64 partData, UInt32 partKey)//осуществляет шаг в сети Фейстеля
        {
            UInt32 L = retL(partData);
            UInt32 R = retR(partData);
            UInt32 temp = func(R, partKey);
            UInt32 xor = L ^ temp;
            UInt64 result = (UInt64)R;
            result <<= 32;
            result += (UInt64)xor;
            return result;
        }
 
        public static string encode(string data, string key)
        {            
            if (!mod64(data.Length))
            {
                while (!mod64(data.Length))
                {
                    data += "\0";
                }
            }
            List<UInt32> partsKey = fillingListKey(key);
            List<UInt64> partsData = fillingListData(data);
            List<UInt64> encodedData = new List<UInt64>();
            string result = "";
            for (int i = 0; i < partsData.Count; ++i)
            {
                encodedData.Add(encodePartData(partsData[i], partsKey));
            }
            for (int i = 0; i < encodedData.Count; ++i)
            {
                result += getPartString(encodedData[i]);
            }
            return result;
 
        }//Метод шифрования
 
        public static string decode(string codedData, string key)
        {
            List<UInt32> partsKey = fillingListKey(key);
            List<UInt64> partsData = fillingListData(codedData);
            List<UInt64> decodedData = new List<UInt64>();
            string result = "";
            for (int i = 0; i < partsData.Count; ++i)
            {
                decodedData.Add(decodePartData(partsData[i], partsKey));
            }
            for (int i = 0; i < decodedData.Count; ++i)
            {
                result += getPartString(decodedData[i]);
            }
            return result;
        }//Метод расшифровки
    }
}

  private static UInt32 func(UInt32 R, UInt32 Ki)
        {
            UInt32 s = mod2_32(R, Ki);
            List<UInt32> partsS = new List<UInt32>();
            for (int i = 0; i < 8; ++i)
            {
 
                UInt32 temp = s >> 28;
                partsS.Add(temp);
                s <<= 4;
            }
            partsS.Reverse();
            for (int i = 0; i < 8; ++i)
            {
                partsS[i] = Sblocks[i, (int)partsS[i]];
            }
            s = 0;
            for (int i = 0; i < partsS.Count; ++i)
            {
                s += partsS[i];
                s <<= 4;
            }
                s = shiftN(s, 11);
            return s;

 for (int i = 0; i < partsS.Count; ++i)
            {
                s += partsS[i];
                s <<= 4;
            }

 for (int i = 0; i < partsS.Count; ++i)
            {
                s <<= 4;
                s += partsS[i];
            }

 byte[] bKey = {
                 0x73,  0x3d,  0x2C,  0x20,
         0x65,  0x68,  0x65,  0x73,
         0x74,  0x74,  0x67,  0x69,
         0x79,  0x67,  0x61,  0x20,
         0x62,  0x6e,  0x73,  0x73,
         0x20,  0x65,  0x73,  0x69,
         0x32,  0x6c,  0x65,  0x68,
         0x33,  0x20,  0x6d,  0x54
                          };

byte[] bKey = {
         0x33,  0x20,  0x6d,  0x54,
         0x32,  0x6c,  0x65,  0x68,
         0x20,  0x65,  0x73,  0x69,
         0x62,  0x6e,  0x73,  0x73,
         0x79,  0x67,  0x61,  0x20,
         0x74,  0x74,  0x67,  0x69,
         0x65,  0x68,  0x65,  0x73,
                 0x73,  0x3d,  0x2C,  0x20
                          };

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp5
{
    class Program
    {
        static void Main()
        {
        }
        /// <summary>
        ///     Класс кодирования по ГОСТ 28147-89.
        ///     Для выполнения кодирования надо создать экземпляр класса и добавить ключ (SetKey) и таблицу замен
        ///     (SetReplaceTable).
        ///     SimpleEncoding - кодирование простой вставкой
        ///     SimpleDecoding - декодирование простой вставкой
        ///     GammaСoding - кодирование c использованием гаммирования
        ///     GammaWithFeedBackCoding - кодирование c использованием гаммирования с обратной связью
        ///     ImitationPaste - формирование имитовставки
        ///     Разработчик - Ефремов С.В.
        /// </summary> 
        public class Coder
        {
            #region Fields
 
            private UInt32[] key;
 
            private byte[,] replaceTable;
 
            #endregion
 
            #region Public Methods and Operators
 
            /// <summary>
            ///     Преобразование из UInt64 в 8 байт
            /// </summary>
            /// <param name="s"></param>
            /// <returns></returns>
            public static byte[] Get8BytesFromUInt64(UInt64 s)
            {
                var result = new byte[8];
                for (int i = 0; i < 8; i++)
                {
                    int shift = (56 - 8 * i);
                    result[i] = (byte)(s >> shift);
                    s = s & (UInt64.MaxValue - ((UInt64)0xff << shift));
                }
                return result;
            }
 
            /// <summary>
            ///     Преобразование из 8 байт в UInt64
            /// </summary>
            /// <param name="s">массив байт</param>
            /// <param name="startIndex">начальный индекс в массиве</param>
            /// <returns></returns>
            public static UInt64 GetUint64From8Bytes(byte[] s, int startIndex)
            {
                UInt64 result = 0;
                for (int i = startIndex; i < startIndex + 8; i++)
                {
                    int shift = (56 - 8 * i);
                    result += ((UInt64)s[i] << shift);
                }
                return result;
            }
 
            /// <summary>
            ///     Шифрование гаммированием с обратной связью
            /// </summary>
            /// <param name="data">блок данных, размером кратным 8</param>
            /// <param name="s">синхропосылка, размером 8 байт</param>
            /// <returns></returns>
            public byte[] GammaWithFeedBackCoding(byte[] data, byte[] s)
            {
                #region проверка
 
                if (data.Length % 8 != 0)
                {
                    throw new ArgumentOutOfRangeException("Размер данных должен быть кратным 8!");
                }
 
                if (s.Length != 8)
                {
                    throw new ArgumentOutOfRangeException("Размер синхропосылки должен быть равным 8!");
                }
 
                if (this.key == null)
                {
                    throw new ArgumentNullException("Не задан ключ шифрования!");
                }
 
                if (this.replaceTable == null)
                {
                    throw new ArgumentNullException("Не задана таблица замен!");
                }
 
                #endregion
 
                #region преобразование массива байт в массив uint64
 
                int lenght = data.Length / 8;
 
                var ulongsData = new UInt64[lenght];
 
                for (int i = 0; i < lenght; i++)
                {
                    ulongsData[i] = GetUint64From8Bytes(data, 8 * i);
                }
 
                ulong ulongS = GetUint64From8Bytes(s, 0);
 
                #endregion
 
                #region шифрование и дешифрование
 
                ulong[] crypt = GammaWithFeedBackCoding(ulongsData, ulongS);
 
                #endregion
 
                #region преобразование массива uint64 в массив байт
 
                var result = new byte[data.Length];
 
                for (int i = 0; i < crypt.Length; i++)
                {
                    byte[] bytes = Get8BytesFromUInt64(crypt[i]);
                    for (int j = 0; j < 8; j++)
                    {
                        result[i * 8 + j] = bytes[j];
                    }
                }
 
                #endregion
 
                return result;
            }
 
            /// <summary>
            ///     Шифрование гаммированием
            /// </summary>
            /// <param name="data">блок данных, размером кратным 8</param>
            /// <param name="s">синхропосылка, размером 8 байт</param>
            /// <returns></returns>
            public byte[] GammaСoding(byte[] data, byte[] s)
            {
                #region проверка
 
                if (data.Length % 8 != 0)
                {
                    throw new ArgumentOutOfRangeException("Размер данных должен быть кратным 8!");
                }
 
                if (s.Length != 8)
                {
                    throw new ArgumentOutOfRangeException("Размер синхропосылки должен быть равным 8!");
                }
 
                if (this.key == null)
                {
                    throw new ArgumentNullException("Не задан ключ шифрования!");
                }
 
                if (this.replaceTable == null)
                {
                    throw new ArgumentNullException("Не задана таблица замен!");
                }
 
                #endregion
 
                #region преобразование массива байт в массив uint64
 
                int lenght = data.Length / 8;
 
                var ulongsData = new UInt64[lenght];
 
                for (int i = 0; i < lenght; i++)
                {
                    ulongsData[i] = GetUint64From8Bytes(data, 8 * i);
                }
 
                ulong ulongS = GetUint64From8Bytes(s, 0);
 
                #endregion
 
                #region шифрование и дешифрование
 
                ulong[] crypt = GammaСoding(ulongsData, ulongS);
 
                #endregion
 
                #region преобразование массива uint64 в массив байт
 
                var result = new byte[data.Length];
 
                for (int i = 0; i < crypt.Length; i++)
                {
                    byte[] bytes = Get8BytesFromUInt64(crypt[i]);
                    for (int j = 0; j < 8; j++)
                    {
                        result[i * 8 + j] = bytes[j];
                    }
                }
 
                #endregion
 
                return result;
            }
 
            /// <summary>
            ///     Формирование имитовставки
            /// </summary>
            /// <param name="plainData">блок открытых данных, размером кратным 8</param>
            /// <returns></returns>
            public byte[] ImitationPaste(byte[] plainData)
            {
                #region проверка
 
                if (plainData.Length % 8 != 0)
                {
                    throw new ArgumentOutOfRangeException("Размер данных должен быть кратным 8!");
                }
 
                if (this.key == null)
                {
                    throw new ArgumentNullException("Не задан ключ шифрования!");
                }
 
                if (this.replaceTable == null)
                {
                    throw new ArgumentNullException("Не задана таблица замен!");
                }
 
                #endregion
 
                #region преобразование массива байт в массив uint64
 
                int lenght = plainData.Length / 8;
 
                var data = new UInt64[lenght];
 
                for (int i = 0; i < lenght; i++)
                {
                    data[i] = GetUint64From8Bytes(plainData, 8 * i);
                }
 
                #endregion
 
                #region расшифрование
 
                ulong crypt = ImitationPaste(data);
 
                #endregion
 
                #region преобразование массива uint64 в массив байт
 
                byte[] result = Get8BytesFromUInt64(crypt);
 
                #endregion
 
                return result;
            }
 
            /// <summary>
            ///     Метод установки ключа - восьми 32-битовых элементов кода
            /// </summary>
            /// <param name="keyData">массив из 32 байт</param>
            public void SetKey(byte[] keyData)
            {
                if (keyData.Length != 32)
                {
                    throw new ArgumentOutOfRangeException("Длина массива для ключа должна быть равна 32!");
                }
 
                this.key = new UInt32[8];
                for (int i = 0; i < keyData.Length; i += 4)
                {
                    UInt32 k = keyData[i];
                    k = k << 8;
                    k = k | keyData[i + 1];
                    k = k << 8;
                    k = k | keyData[i + 2];
                    k = k << 8;
                    k = k | keyData[i + 3];
                    this.key[i / 4] = k;
                }
            }
 
            /// <summary>
            ///     Метод установки таблицы замен - матрицы размера 8 х 16, содержащей 4-битовые элементы
            /// </summary>
            /// <param name="replaceTableData">массив из 64 байт</param>
            public void SetReplaceTable(byte[] replaceTableData)
            {
                if (replaceTableData.Length != 64)
                {
                    throw new ArgumentOutOfRangeException("Длина массива для ключа должна быть равна 64!");
                }
 
                this.replaceTable = new byte[8, 16];
 
                for (int i = 0; i < 8; i++)
                {
                    for (int j = 0; j < 8; j++)
                    {
                        int index = i * 8 + j;
                        byte rtd = replaceTableData[index];
                        this.replaceTable[i, j * 2] = (byte)(rtd >> 4);
                        this.replaceTable[i, j * 2 + 1] = (byte)(rtd & 0x0F);
                    }
                }
            }
 
            /// <summary>
            ///     Расшифрование простой заменой
            /// </summary>
            /// <param name="plainData">блок открытых данных, размером кратным 8</param>
            /// <returns></returns>
            public byte[] SimpleDecoding(byte[] plainData)
            {
                #region проверка
 
                if (plainData.Length % 8 != 0)
                {
                    throw new ArgumentOutOfRangeException("Размер данных должен быть кратным 8!");
                }
 
                if (this.key == null)
                {
                    throw new ArgumentNullException("Не задан ключ шифрования!");
                }
 
                if (this.replaceTable == null)
                {
                    throw new ArgumentNullException("Не задана таблица замен!");
                }
 
                #endregion
 
                #region преобразование массива байт в массив uint64
 
                int lenght = plainData.Length / 8;
 
                var data = new UInt64[lenght];
 
                for (int i = 0; i < lenght; i++)
                {
                    data[i] = GetUint64From8Bytes(plainData, 8 * i);
                }
 
                #endregion
 
                #region расшифрование
 
                ulong[] crypt = SimpleDecoding(data);
 
                #endregion
 
                #region преобразование массива uint64 в массив байт
 
                var result = new byte[plainData.Length];
 
                for (int i = 0; i < crypt.Length; i++)
                {
                    byte[] bytes = Get8BytesFromUInt64(crypt[i]);
                    for (int j = 0; j < 8; j++)
                    {
                        result[i * 8 + j] = bytes[j];
                    }
                }
 
                #endregion
 
                return result;
            }
 
            /// <summary>
            ///     Шифрование простой заменой
            /// </summary>
            /// <param name="plainData">блок открытых данных, размером кратным 8</param>
            /// <returns></returns>
            public byte[] SimpleEncoding(byte[] plainData)
            {
                #region проверка
 
                if (plainData.Length % 8 != 0)
                {
                    throw new ArgumentOutOfRangeException("Размер данных должен быть кратным 8!");
                }
 
                if (this.key == null)
                {
                    throw new ArgumentNullException("Не задан ключ шифрования!");
                }
 
                if (this.replaceTable == null)
                {
                    throw new ArgumentNullException("Не задана таблица замен!");
                }
 
                #endregion
 
                #region преобразование массива байт в массив uint64
 
                int lenght = plainData.Length / 8;
 
                var data = new UInt64[lenght];
 
                for (int i = 0; i < lenght; i++)
                {
                    data[i] = GetUint64From8Bytes(plainData, 8 * i);
                }
 
                #endregion
 
                #region шифрование
 
                ulong[] crypt = SimpleEncoding(data);
 
                #endregion
 
                #region преобразование массива uint64 в массив байт 
 
                var result = new byte[plainData.Length];
 
                for (int i = 0; i < crypt.Length; i++)
                {
                    byte[] bytes = Get8BytesFromUInt64(crypt[i]);
                    for (int j = 0; j < 8; j++)
                    {
                        result[i * 8 + j] = bytes[j];
                    }
                }
 
                #endregion
 
                return result;
            }
 
            #endregion
 
            #region Methods
 
            private UInt64 BaseCycle32I(UInt64 data)
            {
                UInt64 result = data;
 
                for (int i = 0; i < 2; i++)
                {
                    for (int j = 0; j < 8; j++)
                    {
                        result = this.MainCryptoStep(result, this.key[j]);
                    }
                }
 
                return result;
            }
 
            private UInt64 BaseCycle32R(UInt64 data)
            {
                UInt64 result = data;
 
                for (int j = 0; j < 8; j++)
                {
                    result = this.MainCryptoStep(result, this.key[j]);
                }
 
                for (int i = 0; i < 3; i++)
                {
                    for (int j = 7; j >= 0; j--)
                    {
                        result = this.MainCryptoStep(result, this.key[j]);
                    }
                }
 
                result = ((result & UInt32.MaxValue) << 32) | (result >> 32);
 
                return result;
            }
 
            private UInt64 BaseCycle32Z(UInt64 data)
            {
                UInt64 result = data;
 
                for (int i = 0; i < 3; i++)
                {
                    for (int j = 0; j < 8; j++)
                    {
                        result = this.MainCryptoStep(result, this.key[j]);
                    }
                }
 
                for (int j = 7; j >= 0; j--)
                {
                    result = this.MainCryptoStep(result, this.key[j]);
                }
 
                result = ((result & UInt32.MaxValue) << 32) | (result >> 32);
 
                return result;
            }
 
            private uint CycleLeftShift11(uint value)
            {
                uint result = value << 11 | value >> (32 - 11);
                return result;
            }
 
            private UInt64[] GammaWithFeedBackCoding(UInt64[] data, UInt64 s)
            {
                var result = new UInt64[data.Length];
 
                for (int i = 0; i < data.Length; i++)
                {
                    s = this.BaseCycle32Z(s);
                    result[i] = data[i] ^ s;
                    s = result[i];
                }
 
                return result;
            }
 
            private UInt64[] GammaСoding(UInt64[] data, UInt64 s)
            {
                var result = new UInt64[data.Length];
 
                const uint C1 = 0x1010101;
                const uint C2 = 0x1010104;
 
                #region шаг 1
 
                ulong newS = this.BaseCycle32Z(s);
 
                #endregion
 
                var s0 = (UInt32)(newS & UInt32.MaxValue);
                var s1 = (UInt32)(newS >> 32);
 
                for (int i = 0; i < data.Length; i++)
                {
                    #region шаг 2
 
                    s0 = s0 + C1;
                    s1 = (uint)((s1 + C2 - 1) % (Math.Pow(2, 32) - 1) + 1);
                    newS = s1;
                    newS = newS << 32;
                    newS = newS | s0;
 
                    #endregion
 
                    #region шаг 3
 
                    newS = this.BaseCycle32Z(newS);
                    result[i] = data[i] ^ newS;
 
                    #endregion
                }
 
                return result;
            }
 
            private UInt64 ImitationPaste(UInt64[] data)
            {
                UInt64 s = 0;
                for (int i = 0; i < data.Length; i++)
                {
                    s = this.BaseCycle32I(s ^ data[i]);
                }
                return s;
            }
 
            private UInt64 MainCryptoStep(UInt64 data, UInt32 keyPart)
            {
                #region шаг 0 - разбивание UInt64 на два UInt32
 
                var n2 = (UInt32)(data >> 32);
                var n1 = (UInt32)(data & UInt32.MaxValue);
 
                #endregion
 
                #region шаг 1 - сложение по модулю 2^32
 
                UInt32 step1Value = n1 + keyPart;
 
                #endregion
 
                #region шаг 2 - замена
 
                uint step2Value = this.ReplaceValues(step1Value);
 
                #endregion
 
                #region шаг 3 - сдвиг влево на 11
 
                uint step3Value = this.CycleLeftShift11(step2Value);
 
                #endregion
 
                #region шаг 4 - сложение по модулю 2
 
                uint step4Value = step3Value ^ n2;
 
                #endregion
 
                #region шаг 5 - сдвиг по цепочке
 
                n2 = n1;
                n1 = step4Value;
 
                #endregion
 
                #region шаг 6 - возврат полученного значения
 
                UInt64 step6Value = (UInt64)n2 << 32 | n1;
 
                #endregion
 
                return step6Value;
            }
 
            private uint ReplaceValues(uint step1Value)
            {
                uint result = 0;
                for (int i = 0; i < 8; i++)
                {
                    result <<= 4;
                    int shift = 32 - 4 - 4 * i;
                    uint index = (step1Value >> shift) & 0xf;
                    step1Value = step1Value & (UInt32.MaxValue - ((UInt32)0xf << shift));
                    result += this.replaceTable[7 - i, index];
                }
                return result;
            }
 
            private UInt64[] SimpleDecoding(UInt64[] encryptedData)
            {
                var plainText = new UInt64[encryptedData.Length];
                for (int i = 0; i < encryptedData.Length; i++)
                {
                    plainText[i] = this.BaseCycle32R(encryptedData[i]);
                }
                return plainText;
            }
 
            private UInt64[] SimpleEncoding(UInt64[] plainData)
            {
                var result = new UInt64[plainData.Length];
                for (int i = 0; i < plainData.Length; i++)
                {
                    result[i] = this.BaseCycle32Z(plainData[i]);
                }
                return result;
            }
 
            #endregion
        }
    }
}