using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace crypto_galua
{
    class Program
    {
        static int mod = 0x11b;
        static byte[,] key = { { 1, 2, 3, 4 }, { 1, 2, 3, 4 }, { 1, 2, 3, 4 }, { 1, 2, 3, 4 } };
        static int BitsCount(int b)
        {
            int count = 0;
            while (b != 0)
            {
                b = b >> 1;
                count++;
            }
            return count;
        }
        static byte Sum(byte a, byte b)
        {
            return (byte)(a ^ b);
        }
        static byte Mult(byte a, byte b, int m)
        {
            int res = ((b & 0x1) == 1) ? a : 0x0;
            int k = 1;
            b >>= 1;
            while (b != 0)
            {
                if ((b & 0x1) == 1)
                {
                    res = res ^ (a << k);
                    b >>= 1;
                    k++;
                }
                else
                {
                    b >>= 1;
                    k++;
                }
            }
            while (res >= 0xff)
                res ^= m << (BitsCount(res) - BitsCount(m));
            return (byte)res;
        }
        static byte obr(byte a, int m)
        {
            for (int i = 0; i < 256; i++)
            {
                if (Mult(a, (byte)i, 0x11b) % m == 1)
                    return (byte)i;
            }
            return 0;
        }

        static byte[,] GetToMatrix(string s)
        {
            byte[,] bytes = new byte[4, 4];
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    bytes[i, j] = (byte)s[4 * i + j];
                }
            }
            return bytes;
        }

        static byte[,] Tetta(byte[,] bytes)
        {
            byte[,] newbytes = new byte[4, 4];
            byte[,] c = new byte[,] { { 2, 3, 1, 1 }, { 1, 2, 3, 1 }, { 1, 1, 2, 3 }, { 3, 1, 1, 2 } };

            for (int i = 0; i < bytes.GetLength(0); i++)
            {
                for (int j = 0; j < c.GetLength(1); j++)
                {
                    for (int k = 0; k < c.GetLength(0); k++)
                    {
                        newbytes[i, j] ^= Mult(bytes[i, k], c[k, j], mod);
                    }
                }
            }
            return newbytes;
        }

        static byte[,] Gamma(byte[,] bytes)
        {

            byte[] a = new byte[] {
                                    0xB1,0xCE,0xC3,0x95,0x5A,0xAD,0xE7,0x02,0x4D,0x44,0xFB,0x91,0x0C,0x87,0xA1,0x50,
                                    0xCB,0x67,0x54,0xDD,0x46,0x8F,0xE1,0x4E,0xF0,0xFD,0xFC,0xEB,0xF9,0xC4,0x1A,0x6E,
                                    0x5E,0xF5,0xCC,0x8D,0x1C,0x56,0x43,0xFE,0x07,0x61,0xF8,0x75,0x59,0xFF,0x03,0x22,
                                    0x8A,0xD1,0x13,0xEE,0x88,0x00,0x0E,0x34,0x15,0x80,0x94,0xE3,0xED,0xB5,0x53,0x23,
                                    0x4B,0x47,0x17,0xA7,0x90,0x35,0xAB,0xD8,0xB8,0xDF,0x4F,0x57,0x9A,0x92,0xDB,0x1B,
                                    0x3C,0xC8,0x99,0x04,0x8E,0xE0,0xD7,0x7D,0x85,0xBB,0x40,0x2C,0x3A,0x45,0xF1,0x42,
                                    0x65,0x20,0x41,0x18,0x72,0x25,0x93,0x70,0x36,0x05,0xF2,0x0B,0xA3,0x79,0xEC,0x08,
                                    0x27,0x31,0x32,0xB6,0x7C,0xB0,0x0A,0x73,0x5B,0x7B,0xB7,0x81,0xD2,0x0D,0x6A,0x26,
                                    0x9E,0x58,0x9C,0x83,0x74,0xB3,0xAC,0x30,0x7A,0x69,0x77,0x0F,0xAE,0x21,0xDE,0xD0,
                                    0x2E,0x97,0x10,0xA4,0x98,0xA8,0xD4,0x68,0x2D,0x62,0x29,0x6D,0x16,0x49,0x76,0xC7,
                                    0xE8,0xC1,0x96,0x37,0xE5,0xCA,0xF4,0xE9,0x63,0x12,0xC2,0xA6,0x14,0xBC,0xD3,0x28,
                                    0xAF,0x2F,0xE6,0x24,0x52,0xC6,0xA0,0x09,0xBD,0x8C,0xCF,0x5D,0x11,0x5F,0x01,0xC5,
                                    0x9F,0x3D,0xA2,0x9B,0xC9,0x3B,0xBE,0x51,0x19,0x1F,0x3F,0x5C,0xB2,0xEF,0x4A,0xCD,
                                    0xBF,0xBA,0x6F,0x64,0xD9,0xF3,0x3E,0xB4,0xAA,0xDC,0xD5,0x06,0xC0,0x7E,0xF6,0x66,
                                    0x6C,0x84,0x71,0x38,0xB9,0x1D,0x7F,0x9D,0x48,0x8B,0x2A,0xDA,0xA5,0x33,0x82,0x39,
                                    0xD6,0x78,0x86,0xFA,0xE4,0x2B,0xA9,0x1E,0x89,0x60,0x6B,0xEA,0x55,0x4C,0xF7,0xE2
            };
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                    bytes[i, j] = a[bytes[i, j]];
            }
            return bytes;
        }

        static byte[,] Pi(byte[,] bytes)
        {
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                    bytes[i, j] = bytes[j, i];
            }
            return bytes;
        }

        static byte[,] XorWIthKey(byte[,] bytes, byte[,] key)
        {
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                    bytes[i, j] ^= key[i, j];
            }
            return bytes;
        }

        static byte[,] ReverseGamma(byte[,] bytes)
        {
            byte[] a = new byte[] {
                                    0xB1,0xCE,0xC3,0x95,0x5A,0xAD,0xE7,0x02,0x4D,0x44,0xFB,0x91,0x0C,0x87,0xA1,0x50,
                                    0xCB,0x67,0x54,0xDD,0x46,0x8F,0xE1,0x4E,0xF0,0xFD,0xFC,0xEB,0xF9,0xC4,0x1A,0x6E,
                                    0x5E,0xF5,0xCC,0x8D,0x1C,0x56,0x43,0xFE,0x07,0x61,0xF8,0x75,0x59,0xFF,0x03,0x22,
                                    0x8A,0xD1,0x13,0xEE,0x88,0x00,0x0E,0x34,0x15,0x80,0x94,0xE3,0xED,0xB5,0x53,0x23,
                                    0x4B,0x47,0x17,0xA7,0x90,0x35,0xAB,0xD8,0xB8,0xDF,0x4F,0x57,0x9A,0x92,0xDB,0x1B,
                                    0x3C,0xC8,0x99,0x04,0x8E,0xE0,0xD7,0x7D,0x85,0xBB,0x40,0x2C,0x3A,0x45,0xF1,0x42,
                                    0x65,0x20,0x41,0x18,0x72,0x25,0x93,0x70,0x36,0x05,0xF2,0x0B,0xA3,0x79,0xEC,0x08,
                                    0x27,0x31,0x32,0xB6,0x7C,0xB0,0x0A,0x73,0x5B,0x7B,0xB7,0x81,0xD2,0x0D,0x6A,0x26,
                                    0x9E,0x58,0x9C,0x83,0x74,0xB3,0xAC,0x30,0x7A,0x69,0x77,0x0F,0xAE,0x21,0xDE,0xD0,
                                    0x2E,0x97,0x10,0xA4,0x98,0xA8,0xD4,0x68,0x2D,0x62,0x29,0x6D,0x16,0x49,0x76,0xC7,
                                    0xE8,0xC1,0x96,0x37,0xE5,0xCA,0xF4,0xE9,0x63,0x12,0xC2,0xA6,0x14,0xBC,0xD3,0x28,
                                    0xAF,0x2F,0xE6,0x24,0x52,0xC6,0xA0,0x09,0xBD,0x8C,0xCF,0x5D,0x11,0x5F,0x01,0xC5,
                                    0x9F,0x3D,0xA2,0x9B,0xC9,0x3B,0xBE,0x51,0x19,0x1F,0x3F,0x5C,0xB2,0xEF,0x4A,0xCD,
                                    0xBF,0xBA,0x6F,0x64,0xD9,0xF3,0x3E,0xB4,0xAA,0xDC,0xD5,0x06,0xC0,0x7E,0xF6,0x66,
                                    0x6C,0x84,0x71,0x38,0xB9,0x1D,0x7F,0x9D,0x48,0x8B,0x2A,0xDA,0xA5,0x33,0x82,0x39,
                                    0xD6,0x78,0x86,0xFA,0xE4,0x2B,0xA9,0x1E,0x89,0x60,0x6B,0xEA,0x55,0x4C,0xF7,0xE2
            };
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                    bytes[i, j] = a[bytes[i, j]];
            }
            return bytes;
        }


        static void Main(string[] args)
        {
            //Console.WriteLine("Умножение: " + Convert.ToString((Mult(0xbb, 0xfb, 0x11b)), 16));
            //Console.WriteLine("Обратный элемент: " + Convert.ToString(obr(0xbb, 0x11b), 16));
            //Console.WriteLine("Типо 1 должно быть: " + Mult(obr(0xbb, 0x11b), 0xbb, 0x11b) % 0x11b);
            //Console.WriteLine(Convert.ToString(obr(0xba, 0x11b), 16));


            //пример кодирования
            byte[,] m = GetToMatrix("abcdefgtabcdefgt");
            m = XorWIthKey(Pi(Gamma(Tetta(m))), key);
            for (int i = 0; i < 4; i++)
            {
                for (int j = 0; j < 4; j++)
                {
                    Console.Write(m[i, j] + " ");
                }
                Console.WriteLine("");
            }


        }
    }
}