Регистр сдвига c линейной обратной связью

Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
 
namespace l2t1
{
    class Program
    {
        static void Main(string[] args)
        {
            String text;
            using (StreamReader sr = new StreamReader("D:\\текст.txt", System.Text.Encoding.UTF8, false))
            {
                text = sr.ReadLine();
            }
            lfsr t1 = new lfsr(text, 0, "10001110101011101110000111");
            Console.WriteLine("Текст: {0}", t1.CleanText);
            Console.WriteLine("Ключ: {0}", t1.Key);
            Console.WriteLine("Последовательность текста: {0}", t1.TextKey);
            Console.WriteLine("Псевдослучайная последовательность: {0}", t1.RandomKey);
            Console.WriteLine("Зашифрованный текст: {0}", t1.EncryptedText);
            Console.WriteLine("Расшифрованный текст: {0}", t1.DecryptedText);
            Console.Read();
            using (StreamWriter sw = new StreamWriter("D:\\output.txt"))
            {
                sw.WriteLine(t1.EncryptedText);
                sw.WriteLine(t1.DecryptedText);
            }
 
        }
    }
}

lfsr.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace l2t1
{
    class lfsr
    {
        private String encryptedText;
        private String cleanText;
        private String decryptedText;
        private String key;
        private String randomKey;
        private String textKey;
 
        public String EncryptedText
        {
            get { return encryptedText; }
            set { encryptedText = value; }
        }
        public String CleanText
        {
            get { return cleanText; }
            set { cleanText = value; }
        }
        public String DecryptedText
        {
            get { return decryptedText; }
            set { decryptedText = value; }
        }
        public String Key
        {
            get { return key; }
            set { key = value; }
        }
        public String RandomKey
        {
            get { return randomKey; }
            set { randomKey = value; }
        }
        public String TextKey
        {
            get { return textKey; }
            set { textKey = value; }
        }
 
        private String getCharTextKey(int ch)
        {
            String charkey = "";
            int a = 0, len = 15;
            while (len >= 0)
            {
                a = ch % 2;
                ch = ch / 2;
                if (a == 0) charkey = charkey.Insert(0, "0");
                else charkey = charkey.Insert(0, "1");
                len--;
            }
 
 
            return charkey;
        }
        private void MakeTextKey(String OurText)
        {
            String buff = "";
            for (int i = 0; i < OurText.Length; i++)
            {
                buff = getCharTextKey((int)OurText[i]);
                textKey = textKey.Insert(i * 16, buff);
                buff = "";
            }
        }
        private int xor(int x, int y)
        {
            if (((x == 0) && (y == 0)) || ((x == 1) && (y == 1))) return 0;
            else return 1;
        }
        private int MakeIt(int[] arr)
        {
            int forret = arr[25];
            int result = xor(arr[25], arr[15]);
            result = xor(result, arr[6]);
            result = xor(result, arr[0]);
 
            for (int i = 1; i < 26; i++) arr[i - 1] = arr[i];
 
            arr[25] = result;
            return forret;
        }
        private void CreateKey()
        {
            int[] reg = new int[26];
            for (int i = 0; i < 26; i++) reg[i] = (int)(key[i] - 48);
            for (int i = 0; i < (16 * cleanText.Length); i++)
            {
                if (MakeIt(reg) == 0) randomKey = randomKey.Insert(i, "0");
                else randomKey = randomKey.Insert(i, "1");
            }
 
        }
        private char BinToInt(int[] arr, int k)
        {
            int sum = 0, raz = 1;
            for (int i = 15; i != -1; i--)
            {
                sum += arr[i + k * 16] * raz;
                raz *= 2;
            }
            return (char)sum;
        }
        private void Encrypt()
        {
            encryptedText = "";
            int[] finalkey = new int[randomKey.Length];
            for (int i = 0; i < randomKey.Length; i++)
                finalkey[i] = xor(randomKey[i] - 48, textKey[i] - 48);
 
            for (int i = 0; i < cleanText.Length; i++)
            {
                encryptedText = encryptedText.Insert(i, BinToInt(finalkey, i).ToString());
            }
 
        }
        private void Decrypt()
        {
            decryptedText = "";
            MakeTextKey(encryptedText);
            int[] finalkey = new int[randomKey.Length];
            for (int i = 0; i < randomKey.Length; i++)
                finalkey[i] = xor(randomKey[i] - 48, textKey[i] - 48);
 
            char ch;
            for (int i = 0; i < encryptedText.Length; i++)
            {
                ch = BinToInt(finalkey, i);
                decryptedText = decryptedText.Insert(i, ch.ToString());
            }
        }
 
        public lfsr(String _text, int k, String _key)
        {
            textKey = "";
            randomKey = "";
            cleanText = "";
            encryptedText = "";
            if (k == 0) decryptedText = _text;
            else encryptedText = _text;
            cleanText = _text;
 
            key = _key;
            MakeTextKey(cleanText);
            CreateKey();
            Encrypt();
            Decrypt();
        }
 
    }
}

Console.WriteLine("Зашифрованный текст: {0}", t1.EncryptedText);

Console.OutputEncoding = Encoding.UTF8;

        static void Main(string[] args)
        {
            Console.WriteLine("При вводе для разделения разрядов можно использовать пробел.");
            Console.WriteLine("Для шестнадцатеричной системы регистр значения не имеет.");
            Console.WriteLine("Остальные символы не предусмотренные системой счисления приводят к ошибке.");
            Console.WriteLine("Разряды вводятся от младших к старшим");
            Console.WriteLine("Для шестнадцатеричной системы количество разрядов долно быть чётным");
            Console.WriteLine("Для двоичной системы количество разрядов долно быть кратно 8");
            Console.WriteLine();
 
            Cl_Register _reg;
            string ExampleKey;
 
            do
            {
                Console.Write("Введите двоичный ключ: ");
                ExampleKey = Console.ReadLine();
 
                _reg = Cl_Register.CreateFromString(ExampleKey, Cl_Register.TypeStringEnum.Bynary);
            } while (_reg == null);
            Console.WriteLine($"Вы ввели в двоичном коде - {_reg.ToStringBinary()} ; в шестнадцатеричном коде {_reg.ToStringHex()} .");
            Console.WriteLine();
            do
            {
                Console.Write("Введите шестнадцатеричный ключ: ");
                ExampleKey = Console.ReadLine();
 
                _reg = Cl_Register.CreateFromString(ExampleKey, Cl_Register.TypeStringEnum.Hex);
            } while (_reg == null);
            Console.WriteLine($"Вы ввели в двоичном коде - {_reg.ToStringBinary()} ; в шестнадцатеричном коде {_reg.ToStringHex()} .");
            Console.WriteLine();
 
            Console.WriteLine("Высисление периода регистра");
            do
            {
                Console.WriteLine($"Шаг {_reg.TotalShift}.Значени регистра  (Bin){_reg.ToStringBinary()} ; (Hex){_reg.ToStringHex()} .");
                _reg.Step();
            } while (!_reg.ReturnedToBeginning());
            Console.Write("Для выхода нажмите любую клавишу.....   "); Console.ReadKey();
 
        }
    }
 
    /// <summary>Класс для хранения данных регистра</summary>
    class Cl_Register
    {
        private byte[] _initialValue;
        private byte[] _currentValue;
 
        /// <summary>Возвращает начальное значение регистра</summary>
        public byte[] InitialValue { get => _initialValue; private set { _initialValue = value; CurrentValue = InitialValue; } }
 
        /// <summary>Возвращает суммарный сдвиг регистра</summary>
        public long TotalShift { get; private set; }
 
        /// <summary>Возвращает текущее значение регистра</summary>
        public byte[] CurrentValue { get => _currentValue; private set { _currentValue = (byte[])value.Clone(); TotalShift = 0; } }
 
        /// <summary>Сокрытие конструктора по умолчанию</summary>
        private Cl_Register() { }
 
        /// <summary>Создание нового регистра</summary>
        /// <param name="NewValue">Массив байтов для начального значения регистра</param>
        /// <returns>Новый объект Cl_Register</returns>
        static public Cl_Register Create(byte[] NewValue) => new Cl_Register() { InitialValue = NewValue };
 
        /// <summary>Перечислитель для типов строки</summary>
        public enum TypeStringEnum { Bynary = 0, Hex = 1, Decimal = 3 }
 
        /// <summary>Создание нового регистра из строковых данных для начального значения</summary>
        /// <param name="NewValue">Строка символов от младшего к старшему разряду</param>
        /// <param name="Type">Тип данных в строке</param>
        static public Cl_Register CreateFromString(string NewValue, TypeStringEnum Type)
        {
            NewValue = NewValue.Replace(" ", ""); // Удаляет из строки все пробелы
            switch (Type)
            {
                case TypeStringEnum.Bynary:
 
                    // Количество двоичных символов в исходной строке
                    int Count_char = NewValue.Count(_char => _char == '0' || _char == '1');
 
                    if (Count_char != NewValue.Length || Count_char % 8 != 0) // Определение некорректных данных
                    {
                        MessageBox.Show("Ошибка!\nПолученные данные для двоичного преобразования некорректны!");
                        return null;
                    }
 
                    // Подготовка массива для данных
                    byte[] retValue = new byte[NewValue.Length / 8];
                    for (int IndByte = 0; IndByte < retValue.Length; IndByte++) // Цикл по байтам
                    {
                        retValue[IndByte] = Convert.ToByte(new string(NewValue.Substring(IndByte * 8, 8).Reverse().ToArray()), 2);
                    }
                    return Create(retValue);
                case TypeStringEnum.Hex:
                    NewValue = NewValue.ToUpper(); // Перевод строки в верхний регистр
                    // Ссылка на перебор шестнацатиричных символов в исходной строке
                    Count_char = NewValue.Count(_char => _char >= '0' && _char <= '9' || _char >= 'A' && _char <= 'F');
 
                    if (Count_char != NewValue.Length || Count_char % 2 != 0) // Определение некорректных данных
                    {
                        MessageBox.Show("Ошибка!\nПолученные данные для шестнадцатиричного преобразования некорректны!");
                        return null;
                    }
 
                    // Подготовка массива для данных
                    retValue = new byte[NewValue.Length / 2];
                    for (int IndByte = 0; IndByte < retValue.Length; IndByte++) // Цикл по байтам
                    {
                        int begChar = IndByte * 2; // Номер первого символа для байта
                        retValue[IndByte] = Convert.ToByte(new string(NewValue.Substring(IndByte * 2, 2).Reverse().ToArray()), 16);
                    }
                    return Create(retValue);
 
                case TypeStringEnum.Decimal:
                    // Реализция требует преобразования сначала в десятичное число, потом в двоичное, потом в массив байтов
                    // Требует работы с числами большого размера > 128
                    // Из-за сложности для учебного примера нет смысла в реализации
                    return null;
                default:
                    return null;
            }
        }
 
        /// <summary>Метод возвращающий строковое двоичное представление регистра</summary>
        public string ToStringBinary()
        {
            string _str = "";
            for (int IndByte = CurrentValue.Length - 1; IndByte >= 0; IndByte--) // Цикл по байтам в обратном порядке - от старших к младшим
            {
                // Преобразуемый байт CurrentValue[IndByte];
                _str += new string(Convert.ToString(CurrentValue[IndByte], 2).PadLeft(8, '0').Reverse().ToArray()) + " ";
            }
            return _str;
        }
 
        /// <summary>Метод возвращающий строковое шестнадцатиричное представление регистра</summary>
        public string ToStringHex()
        {
            string _str = "";
            for (int IndByte = CurrentValue.Length - 1; IndByte >= 0; IndByte--) // Цикл по байтам в обратном порядке - от старших к младшим
            {
                // Преобразуемый байт CurrentValue[IndByte];
                _str += new string(CurrentValue[IndByte].ToString("X").PadLeft(2, '0').Reverse().ToArray()) + " ";
            }
            return _str;
        }
 
        /// <summary>Метод возвращающий младший бит регистра</summary>
        public byte LowBit() => (byte)(CurrentValue[0] & 0b1);
 
        /// <summary>Метод возвращающий бит обратной связи (X^n + Xn-1 +X^1+1)</summary>
        public byte FeedbackBit() => (byte)((CurrentValue[0] & 0b1) ^ (CurrentValue[0] & 0b10)>>1 ^ ((CurrentValue[CurrentValue.Length - 1] & 0b0100_0000) >> 6) ^ ((CurrentValue[CurrentValue.Length - 1] & 0b1000_0000) >> 7));
 
        /// <summary>Метод сдвигающий регистр на один бит в сторону младших разрядов</summary>
        public void Step()
        {
            // Страший бит для заполнения байта. Инициализирован битом обратной связи
            byte _bit = FeedbackBit();
 
            for (int IndByte = CurrentValue.Length - 1; IndByte >= 0; IndByte--) // Цикл по байтам в обратном порядке - от старших к младшим
            {
                byte buf_byte = CurrentValue[IndByte]; // Запоминание текущего байта
                CurrentValue[IndByte] >>= 1; // Сдвиг текущего байта к младшим битам. В старшем бите 0.
                _bit <<= 7; // Сдвиг сохранённого бита из младшего в старший. Остальные биты = 0
                CurrentValue[IndByte] |= _bit; // Запись старшего бита в байт
                _bit = buf_byte; // Сохранение бита сдвига для следующего байта
            }
            TotalShift++; // Увелечение счётчика сдвигов
        }
 
        /// <summary>Метод сбрасывающий сдвиги</summary>
        public void Init() { CurrentValue = InitialValue; }
 
        /// <summary>Метод возвращающий True, если текущее значение регистра равно начальному</summary>
        public bool ReturnedToBeginning()
        {
            for (int IndByte = 0; IndByte < _currentValue.Length; IndByte++)
            {
                if (_currentValue[IndByte] != _initialValue[IndByte])
                    return false;
            }
            return true;
        }
 
    }

        #region Реализация шифрования регистром с обратной связью Register() 
        static void Register() // Регистр
        {
            Console.WriteLine("При вводе для разделения разрядов можно использовать пробел.");
            Console.WriteLine("Для шестнадцатеричной системы регистр значения не имеет.");
            Console.WriteLine("Остальные символы не предусмотренные системой счисления приводят к ошибке.");
            Console.WriteLine("Разряды вводятся от младших к старшим");
            Console.WriteLine("Для шестнадцатеричной системы количество разрядов долно быть чётным");
            Console.WriteLine("Для двоичной системы количество разрядов долно быть кратно 8");
            Console.WriteLine();
 
            Cl_Register _reg;
            string ExampleKey;
 
            do
            {
                Console.Write("Введите двоичный ключ: ");
                ExampleKey = Console.ReadLine();
 
                _reg = Cl_Register.CreateFromString(ExampleKey, Cl_Register.TypeStringEnum.Bynary);
            } while (_reg == null);
            Console.WriteLine($"Вы ввели в двоичном коде - {_reg.ToStringBinary()} ; в шестнадцатеричном коде {_reg.ToStringHex()} .");
            Console.WriteLine();
            do
            {
                Console.Write("Введите шестнадцатеричный ключ: ");
                ExampleKey = Console.ReadLine();
 
                _reg = Cl_Register.CreateFromString(ExampleKey, Cl_Register.TypeStringEnum.Hex);
            } while (_reg == null);
            Console.WriteLine($"Вы ввели в двоичном коде - {_reg.ToStringBinary()} ; в шестнадцатеричном коде {_reg.ToStringHex()} .");
            Console.WriteLine();
 
            Console.WriteLine("Высисление периода регистра");
            do
            {
                Console.WriteLine($"Шаг {_reg.TotalShift}.Значени регистра  (Bin){_reg.ToStringBinary()} ; (Hex){_reg.ToStringHex()} .");
                _reg.Step();
            } while (!_reg.ReturnedToBeginning());
            Console.Write("Для выхода нажмите любую клавишу.....   "); Console.ReadKey();
 
        }
    }
 
    /// <summary>Класс для хранения данных регистра</summary>
    class Cl_Register
    {
        private byte[] _initialValue;
        private byte[] _currentValue;
 
        /// <summary>Возвращает начальное значение регистра</summary>
        public byte[] InitialValue { get => _initialValue; private set { _initialValue = value; CurrentValue = InitialValue; } }
 
        /// <summary>Возвращает суммарный сдвиг регистра</summary>
        public long TotalShift { get; private set; }
 
        /// <summary>Возвращает текущее значение регистра</summary>
        public byte[] CurrentValue { get => _currentValue; private set { _currentValue = (byte[])value.Clone(); TotalShift = 0; } }
 
        /// <summary>Сокрытие конструктора по умолчанию</summary>
        private Cl_Register() { }
 
        /// <summary>Создание нового регистра</summary>
        /// <param name="NewValue">Массив байтов для начального значения регистра</param>
        /// <returns>Новый объект Cl_Register</returns>
        static public Cl_Register Create(byte[] NewValue) => new Cl_Register() { InitialValue = NewValue };
 
        /// <summary>Перечислитель для типов строки</summary>
        public enum TypeStringEnum { Bynary = 0, Hex = 1, Decimal = 3 }
 
        /// <summary>Создание нового регистра из строковых данных для начального значения</summary>
        /// <param name="NewValue">Строка символов от младшего к старшему разряду</param>
        /// <param name="Type">Тип данных в строке</param>
        static public Cl_Register CreateFromString(string NewValue, TypeStringEnum Type)
        {
            NewValue = NewValue.Replace(" ", ""); // Удаляет из строки все пробелы
            switch (Type)
            {
                case TypeStringEnum.Bynary:
 
                    // Количество двоичных символов в исходной строке
                    int Count_char = NewValue.Count(_char => _char == '0' || _char == '1');
 
                    if (Count_char != NewValue.Length || Count_char % 8 != 0) // Определение некорректных данных
                    {
                        MessageBox.Show("Ошибка!\nПолученные данные для двоичного преобразования некорректны!");
                        return null;
                    }
 
                    // Подготовка массива для данных
                    byte[] retValue = new byte[NewValue.Length / 8];
                    for (int IndByte = 0; IndByte < retValue.Length; IndByte++) // Цикл по байтам
                    {
                        retValue[IndByte] = Convert.ToByte(new string(NewValue.Substring(IndByte * 8, 8).Reverse().ToArray()), 2);
                    }
                    return Create(retValue);
                case TypeStringEnum.Hex:
                    NewValue = NewValue.ToUpper(); // Перевод строки в верхний регистр
                                                   // Ссылка на перебор шестнацатиричных символов в исходной строке
                    Count_char = NewValue.Count(_char => _char >= '0' && _char <= '9' || _char >= 'A' && _char <= 'F');
 
                    if (Count_char != NewValue.Length || Count_char % 2 != 0) // Определение некорректных данных
                    {
                        MessageBox.Show("Ошибка!\nПолученные данные для шестнадцатиричного преобразования некорректны!");
                        return null;
                    }
 
                    // Подготовка массива для данных
                    retValue = new byte[NewValue.Length / 2];
                    for (int IndByte = 0; IndByte < retValue.Length; IndByte++) // Цикл по байтам
                    {
                        int begChar = IndByte * 2; // Номер первого символа для байта
                        retValue[IndByte] = Convert.ToByte(new string(NewValue.Substring(IndByte * 2, 2).Reverse().ToArray()), 16);
                    }
                    return Create(retValue);
 
                case TypeStringEnum.Decimal:
                    // Реализация требует преобразования сначала в десятичное число, потом в двоичное, потом в массив байтов
                    // Требует работы с числами большого размера > 128
                    // Из-за сложности для учебного примера нет смысла в реализации
                    return null;
                default:
                    return null;
            }
        }
 
        /// <summary>Метод возвращающий строковое двоичное представление регистра</summary>
        public string ToStringBinary()
        {
            string _str = "";
            for (int IndByte = CurrentValue.Length - 1; IndByte >= 0; IndByte--) // Цикл по байтам в обратном порядке - от старших к младшим
            {
                // Преобразуемый байт CurrentValue[IndByte];
                _str += new string(Convert.ToString(CurrentValue[IndByte], 2).PadLeft(8, '0').Reverse().ToArray()) + " ";
            }
            return _str;
        }
 
        /// <summary>Метод возвращающий строковое шестнадцатеричное представление регистра</summary>
        public string ToStringHex()
        {
            string _str = "";
            for (int IndByte = CurrentValue.Length - 1; IndByte >= 0; IndByte--) // Цикл по байтам в обратном порядке - от старших к младшим
            {
                // Преобразуемый байт CurrentValue[IndByte];
                _str += new string(CurrentValue[IndByte].ToString("X").PadLeft(2, '0').Reverse().ToArray()) + " ";
            }
            return _str;
        }
 
        /// <summary>Метод возвращающий младший бит регистра</summary>
        public byte LowBit() => (byte)(CurrentValue[0] & 0b1);
        /// <summary>Метод возвращающий старший бит регистра</summary>
        public byte MostBit() => (byte)(CurrentValue[CurrentValue.Length - 1] & 0b1000_0000 >> 7);
        /// <summary>Метод возвращающий младший байт регистра</summary>
        public byte LowByte() => CurrentValue[0];
        /// <summary>Метод возвращающий старший байт регистра</summary>
        public byte MostByte() => CurrentValue[CurrentValue.Length - 1];
 
        /// <summary>Метод возвращающий бит обратной связи (X^n + X^n-1 + X^1 + 1)</summary>
        public byte FeedbackBit()
            => (byte)((CurrentValue[0] & 0b1) ^ (CurrentValue[0] & 0b10) >> 1
            ^ ((CurrentValue[CurrentValue.Length - 1] & 0b0100_0000) >> 6) ^ ((CurrentValue[CurrentValue.Length - 1] & 0b1000_0000) >> 7)
            );
 
        /// <summary>Метод сдвигающий регистр на один бит в сторону младших разрядов</summary>
        public void Step()
        {
            // Старший бит для заполнения байта. Инициализирован битом обратной связи
            byte _bit = FeedbackBit();
 
            for (int IndByte = CurrentValue.Length - 1; IndByte >= 0; IndByte--) // Цикл по байтам в обратном порядке - от старших к младшим
            {
                byte buf_byte = CurrentValue[IndByte]; // Запоминание текущего байта
                CurrentValue[IndByte] >>= 1; // Сдвиг текущего байта к младшим битам. В старшем бите 0.
                _bit <<= 7; // Сдвиг сохранённого бита из младшего в старший. Остальные биты = 0
                CurrentValue[IndByte] |= _bit; // Запись старшего бита в байт
                _bit = buf_byte; // Сохранение бита сдвига для следующего байта
            }
            TotalShift++; // Увелечение счётчика сдвигов
        }
 
        /// <summary>Метод сдвигающий регистр на один байт в сторону младших разрядов</summary>
        public void StepByte() { for (int Ind = 0; Ind < 8; Ind++) Step(); }
 
        /// <summary>Метод возвращающий зашифрованный поток</summary>
        public MemoryStream Encrypt(MemoryStream stream)
        {
            MemoryStream stream_ret = new MemoryStream();
            stream.Seek(0, SeekOrigin.Begin);
            Init();
            for (long Ind = 0; Ind < stream.Length; Ind++)
            {
                StepByte();
                stream_ret.WriteByte((byte)(stream.ReadByte() ^ MostByte()));
            }
            return stream_ret;
        }
 
        /// <summary>Метод сбрасывающий сдвиги</summary>
        public void Init() { CurrentValue = InitialValue; }
 
 
 
        /// <summary>Метод возвращающий True, если текущее значение регистра равно начальному</summary>
        public bool ReturnedToBeginning()
        {
            for (int IndByte = 0; IndByte < _currentValue.Length; IndByte++)
            {
                if (_currentValue[IndByte] != _initialValue[IndByte])
                    return false;
            }
            return true;
        }
        #endregion