using Org.BouncyCastle.Crypto.Modes.Gcm;

using System;

using System.Collections;

using System.Linq;

public class Program

{

    public static void Main()

    {

        byte[] a = Convert.FromHexString("acbef20579b4b8ebce889bac8732dad7");

        byte[] b = Convert.FromHexString("ed95f8e164bf3213febc740f0bd9c4af");

        byte[] c = gf_mul_be_fixed(a, b);

        Console.WriteLine(Convert.ToHexString(c)); // 4DB870D37CB75FCB46097C36230D1612

​

        byte[] aRev = ReverseAllBits(a);

        byte[] bRev = ReverseAllBits(b);

        byte[] cRev = ReverseAllBits(gf_mul_be(aRev, bRev));

        Console.WriteLine(Convert.ToHexString(cRev)); // 4DB870D37CB75FCB46097C36230D1612

​

        byte[] cBC = gf_mul_be_BC(a, b.ToArray());

        Console.WriteLine(Convert.ToHexString(cBC)); // 4DB870D37CB75FCB46097C36230D1612

    }

    private static byte[] gf_mul_be_fixed(byte[] a, byte[] b)

    {

        var V = new byte[16];

        b.CopyTo(V, 0);

​

        var Z = Enumerable.Repeat((byte)0, 16).ToArray();

​

        var X = new byte[16];

        a.CopyTo(X, 0);

​

        for (var i = 0; i < 128; i++)   // Change 1: reverse

        {

            var j = i / 8;

            var k = i % 8;

            var xi = (X[j] >> (8 - k - 1)) & 1;

            if (xi == 1)

            {

                Z = Z.Zip(V, (z, v) => (byte)(z ^ v)).ToArray();

            }

​

            var lsbV = V[15] & 0x01;    // Change 2: use LSB1(V)

            RightShiftByteArray(V);     // Change 3: right shift bits

            if (lsbV != 0)

            {

                V[0] ^= 0xe1;           // Change 4: use MSB8(V) for XORing with R = b11100001 00000000 ... = 0xE100...

            }

        }

        return Z;

    }

​

    private static byte[] gf_mul_be(byte[] a, byte[] b)

    {

        var V = new byte[16];

        b.CopyTo(V, 0);

​

        var Z = Enumerable.Repeat((byte)0, 16).ToArray();   // 0^128

​

        var X = new byte[16];

        a.CopyTo(X, 0);

​

        for (var i = 127; i >= 0; i--)

        {

            var j = i / 8;

            var k = i % 8;

            var xi = (X[j] >> (8 - k - 1)) & 1;

            if (xi == 1)

            {

                Z = Z.Zip(V, (z, v) => (byte)(z ^ v)).ToArray();    // Z XOR V

            }

​

            var lsbV = V[0] & 0x80; // LSBn is the rightmost n bits from LE bit representation as per spec; so for our BE representation, it's the leftmost

            LeftShiftByteArray(V);  // left-shift because we have the bitstring is reverse order (MSB first)

            if (lsbV != 0)

            {

                V[15] ^= 0x87; // bit pattern 1000 0111 in last byte

            }

        }

​

        return Z;

    }

​

    private static byte[] gf_mul_be_BC(byte[] a, byte[] b)

    {

        BasicGcmMultiplier bgm = new BasicGcmMultiplier();

        bgm.Init(a);

        bgm.MultiplyH(b);

        return b;

    }

​

    private static void LeftShiftByteArray(byte[] bytes)

    {

        var carry = 0;

        for (var l = bytes.Length - 1; l >= 0; l--)

        {

            var byteCopy = bytes[l];

            bytes[l] = (byte)(bytes[l] << 1);

            if (carry == 1)

            {

                bytes[l] = (byte)(bytes[l] | 0x01);

            }

            carry = (byteCopy & 0x80) >> 7;

        }

    }

​

    private static void RightShiftByteArray(byte[] bytes)

    {

        var carry = 0;

        for (var i = 0; i < bytes.Length; i++)

        {

            var byteCopy = bytes[i];

            bytes[i] = (byte)(bytes[i] >> 1);

            if (carry == 1)

            {

                bytes[i] = (byte)(bytes[i] | 0x80);

            }

            carry = (byteCopy & 0x01);

        }

    }

​

    private static byte[] ReverseAllBits(byte[] input)

    {

        BitArray bitArray = new BitArray(input);

        Reverse(bitArray);

        byte[] reversed = new byte[input.Length];

        bitArray.CopyTo(reversed, 0);

        return reversed;

    }

​

    public static void Reverse(BitArray array)

    {

        int length = array.Length;

        int mid = (length / 2);

​

        for (int i = 0; i < mid; i++)

        {

            bool bit = array[i];

            array[i] = array[length - i - 1];

            array[length - i - 1] = bit;

        }

    }

}