Task1.1

using System;
using System.Collections.Generic;
using System.Text;

namespace Task1_1
{
    public class Program
    {
        const int BlockSize = 4;

        static void Main(string[] args)
        {
            Console.Write("Введите текст для шифрования: ");
            string input = Console.ReadLine() ?? "";

            Console.Write("Введите ключ (строка): ");
            string keyInput = Console.ReadLine() ?? "";

            byte[] key = GetKeyBytes(keyInput);
            byte[] plaintext = Encoding.UTF8.GetBytes(input);

            byte[] iv = GenerateRandomBlock();
            Console.WriteLine($"IV: {BitConverter.ToString(iv)}");

            byte[] ciphertext = Encrypt(plaintext, key, iv);
            Console.WriteLine($"Зашифрованный текст (в hex): {BitConverter.ToString(ciphertext)}");

            byte[] decrypted = Decrypt(ciphertext, key, iv);
            string decryptedText = Encoding.UTF8.GetString(decrypted).TrimEnd('\0');

            Console.WriteLine($"Расшифрованный текст: {decryptedText}");
        }

        static byte[] GetKeyBytes(string keyInput)
        {
            byte[] keyBytes = new byte[BlockSize];
            byte[] inputBytes = Encoding.UTF8.GetBytes(keyInput);

            for (int i = 0; i < BlockSize; i++)
            {
                keyBytes[i] = i < inputBytes.Length ? inputBytes[i] : (byte)0;
            }

            return keyBytes;
        }

        static byte[] GenerateRandomBlock()
        {
            Random rand = new Random();

            byte[] block = new byte[BlockSize];
            rand.NextBytes(block);

            return block;
        }

        static List<byte[]> SplitIntoBlocks(byte[] data)
        {
            List<byte[]> blocks = new List<byte[]>();

            for (int i = 0; i < data.Length; i += BlockSize)
            {
                byte[] block = new byte[BlockSize];
                int remaining = Math.Min(BlockSize, data.Length - i);

                Array.Copy(data, i, block, 0, remaining);
                blocks.Add(block);
            }

            return blocks;
        }

        static byte[] Encrypt(byte[] plaintext, byte[] key, byte[] iv)
        {
            List<byte[]> plainBlocks = SplitIntoBlocks(plaintext);
            List<byte[]> cipherBlocks = new List<byte[]>();

            byte[] prevCipherBlock = iv;

            foreach (var block in plainBlocks)
            {
                byte[] xorWithPrev = XOR(block, prevCipherBlock);
                byte[] cipherBlock = XOR(xorWithPrev, key);

                cipherBlocks.Add(cipherBlock);
                prevCipherBlock = cipherBlock;
            }

            return CombineBlocks(cipherBlocks);
        }

        static byte[] Decrypt(byte[] ciphertext, byte[] key, byte[] iv)
        {
            List<byte[]> cipherBlocks = SplitIntoBlocks(ciphertext);
            List<byte[]> decryptedBlocks = new List<byte[]>();

            byte[] prevCipherBlock = iv;

            foreach (var block in cipherBlocks)
            {
                byte[] xorWithKey = XOR(block, key);
                byte[] plainBlock = XOR(xorWithKey, prevCipherBlock);

                decryptedBlocks.Add(plainBlock);
                prevCipherBlock = block;
            }

            return CombineBlocks(decryptedBlocks);
        }

        static byte[] XOR(byte[] a, byte[] b)
        {
            byte[] result = new byte[BlockSize];

            for (int i = 0; i < BlockSize; i++)
            {
                result[i] = (byte)(a[i] ^ b[i]);
            }

            return result;
        }

        static byte[] CombineBlocks(List<byte[]> blocks)
        {
            List<byte> result = new List<byte>();

            foreach (var block in blocks)
            {
                result.AddRange(block);
            }

            return result.ToArray();
        }
    }
}