using System;

using Org.BouncyCastle.Crypto;

using Org.BouncyCastle.Crypto.Parameters;

using Org.BouncyCastle.Security;

using System.Linq;

using CS_AES_CTR;

using SecurityDriven.Inferno.Cipher;

​

public class Program

{

    public static byte[] StringToByteArray(string hex)

    {

        return Enumerable.Range(0, hex.Length)

            .Where(x => x % 2 == 0)

            .Select(x => Convert.ToByte(hex.Substring(x, 2), 16))

            .ToArray();

    }

​

    public static void Main()

    {

        var key = StringToByteArray("f9f437b74930f46d631a024c11d03731a8597a4093b8cf798abce1a866fb1acf");

        var initialCounter = StringToByteArray("69e5457b8ab058eb12716827a95849b4");

        var test1 = StringToByteArray("fd21b731ddc0da49a10243f277f7ba68a38fe3d2d0f8a7bd55ba574e7d43ed60");

        var test2 = StringToByteArray("4bd24c805d1a1f931d5be2be1dbc446a509f3646dfd50a5db8c7f4463e87efdc");

        var test3 = StringToByteArray("5206080118052078");

        var test4 = StringToByteArray("a84edf75");

        var test5 = StringToByteArray("eb1a");

        var test6 = StringToByteArray("0f522e3c82cc");

​

        Console.WriteLine("Inferno\n");

        AesCtrCryptoTransform transformation = new AesCtrCryptoTransform(key, new ArraySegment<byte>(initialCounter));

        byte[] encryptedContentTest = new byte[test1.Length];

        transformation.TransformBlock(test1, 0, test1.Length, encryptedContentTest, 0);

        Console.WriteLine($"Test1:\t{BitConverter.ToString(encryptedContentTest).Replace("-", "")}");

​

        encryptedContentTest = new byte[test2.Length];

        transformation.TransformBlock(test2, 0, test2.Length, encryptedContentTest, 0);

        Console.WriteLine($"Test2:\t{BitConverter.ToString(encryptedContentTest).Replace("-", "")}");

​

        encryptedContentTest = new byte[test3.Length];

        transformation.TransformBlock(test3, 0, test3.Length, encryptedContentTest, 0);

        Console.WriteLine($"Test3:\t{BitConverter.ToString(encryptedContentTest).Replace("-", "")}");

​

        encryptedContentTest = new byte[test4.Length];

        transformation.TransformBlock(test4, 0, test4.Length, encryptedContentTest, 0);

        Console.WriteLine($"Test4:\t{BitConverter.ToString(encryptedContentTest).Replace("-", "")}");

​

        encryptedContentTest = new byte[test5.Length];

        transformation.TransformBlock(test5, 0, test5.Length, encryptedContentTest, 0);

        Console.WriteLine($"Test5:\t{BitConverter.ToString(encryptedContentTest).Replace("-", "")}");

​

        encryptedContentTest = new byte[test6.Length];

        transformation.TransformBlock(test6, 0, test6.Length, encryptedContentTest, 0);

        Console.WriteLine($"Test6:\t{BitConverter.ToString(encryptedContentTest).Replace("-", "")}");

​

​

        Console.WriteLine("\nLibAES-CTR\n");

​

        AES_CTR forEncrypting = new AES_CTR(key, initialCounter);

        byte[] encryptedContent = new byte[test1.Length];

​

        forEncrypting.EncryptBytes(encryptedContent, test1);

        Console.WriteLine($"Test1:\t{BitConverter.ToString(encryptedContent).Replace("-", "")}");

​

        encryptedContent = new byte[test2.Length];

        forEncrypting.EncryptBytes(encryptedContent, test2);

        Console.WriteLine($"Test2:\t{BitConverter.ToString(encryptedContent).Replace("-", "")}");

​

        encryptedContent = new byte[test3.Length];

        forEncrypting.EncryptBytes(encryptedContent, test3);

        Console.WriteLine($"Test3:\t{BitConverter.ToString(encryptedContent).Replace("-", "")}");

​

        encryptedContent = new byte[test4.Length];

        forEncrypting.EncryptBytes(encryptedContent, test4);

        Console.WriteLine($"Test4:\t{BitConverter.ToString(encryptedContent).Replace("-", "")}");

​

        encryptedContent = new byte[test5.Length];

        forEncrypting.EncryptBytes(encryptedContent, test5);

        Console.WriteLine($"Test5:\t{BitConverter.ToString(encryptedContent).Replace("-", "")}");

​

        encryptedContent = new byte[test6.Length];

        forEncrypting.EncryptBytes(encryptedContent, test6);

        Console.WriteLine($"Test6:\t{BitConverter.ToString(encryptedContent).Replace("-", "")}");

​

        Console.WriteLine("\nPortable.BouncyCastle");

        bool manualCounter = true;

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

        {

            if (manualCounter)

            {

                Console.WriteLine("\nManualy increment counter\n");

            }

            else

            {

                Console.WriteLine("\nAuto increment counter\n");

            }

​

            IBufferedCipher aesCipher = CipherUtilities.GetCipher("AES/CTR/NoPadding");

            KeyParameter keyParameter = ParameterUtilities.CreateKeyParameter("AES", key);

​

            var myCounter = initialCounter;

​

            ICipherParameters cipherParameters = new ParametersWithIV(keyParameter, myCounter, 0, 16);

​

            byte[] outputBytesTest1 = new byte[aesCipher.GetOutputSize(test1.Length)];

            aesCipher.Reset();

            aesCipher.Init(true, cipherParameters);

​

            int length = aesCipher.ProcessBytes(test1, outputBytesTest1, 0);

            if (manualCounter)

            {

                aesCipher.DoFinal(outputBytesTest1, length);

                myCounter = Increase(myCounter, 2);

                cipherParameters = new ParametersWithIV(keyParameter, myCounter, 0, 16);

                aesCipher.Init(true, cipherParameters);

            }

            Console.WriteLine("Test1:\t{0}", BitConverter.ToString(outputBytesTest1).Replace("-", ""));

​

            byte[] outputBytesTest2 = new byte[aesCipher.GetOutputSize(test2.Length)];

​

            int length2 = aesCipher.ProcessBytes(test2, outputBytesTest2, 0);

            if (manualCounter)

            {

                aesCipher.DoFinal(outputBytesTest2, length2);

                myCounter = Increase(myCounter, 2);

                cipherParameters = new ParametersWithIV(keyParameter, myCounter, 0, 16);

                aesCipher.Init(true, cipherParameters);

            }

            Console.WriteLine("Test2:\t{0}", BitConverter.ToString(outputBytesTest2).Replace("-", ""));

​

​

            byte[] outputBytesTest3 = new byte[aesCipher.GetOutputSize(test3.Length)];

            if (manualCounter)

            {

                int length3 = aesCipher.ProcessBytes(test3, outputBytesTest3, 0);

                aesCipher.DoFinal(outputBytesTest3, length3);

                myCounter = Increase(myCounter, 1);

                cipherParameters = new ParametersWithIV(keyParameter, myCounter, 0, 16);

                aesCipher.Init(true, cipherParameters);

            }

            Console.WriteLine("Test3:\t{0}", BitConverter.ToString(outputBytesTest3).Replace("-", ""));

​

            byte[] outputBytesTest4 = new byte[aesCipher.GetOutputSize(test4.Length)];

​

            int length4 = aesCipher.ProcessBytes(test4, outputBytesTest4, 0);

            if (manualCounter)

            {

                aesCipher.DoFinal(outputBytesTest4, length4);

                myCounter = Increase(myCounter, 1);

                cipherParameters = new ParametersWithIV(keyParameter, myCounter, 0, 16);

                aesCipher.Init(true, cipherParameters);

            }

            Console.WriteLine("Test4:\t{0}", BitConverter.ToString(outputBytesTest4).Replace("-", ""));

​

            byte[] outputBytesTest5 = new byte[aesCipher.GetOutputSize(test5.Length)];

​

            int length5 = aesCipher.ProcessBytes(test5, outputBytesTest5, 0);

            if (manualCounter)

            {

                aesCipher.DoFinal(outputBytesTest5, length5);

                myCounter = Increase(myCounter, 1);

                cipherParameters = new ParametersWithIV(keyParameter, myCounter, 0, 16);

                aesCipher.Init(true, cipherParameters);

            }

            Console.WriteLine("Test5:\t{0}", BitConverter.ToString(outputBytesTest5).Replace("-", ""));

​

            byte[] outputBytesTest6 = new byte[aesCipher.GetOutputSize(test6.Length)];

​

            int length6 = aesCipher.ProcessBytes(test6, outputBytesTest6, 0);

            if (manualCounter)

            {

                aesCipher.DoFinal(outputBytesTest6, length6);

            }

            Console.WriteLine("Test6:\t{0}", BitConverter.ToString(outputBytesTest6).Replace("-", ""));

​

            manualCounter = false;

        }

    }

​

    static byte[] Increase(byte[] Counter, int Count)

    {

        int carry = 0;

        byte[] buffer = new byte[Counter.Length];

        int offset = buffer.Length - 1;

        byte[] cnt = BitConverter.GetBytes(Count);

        byte osrc, odst, ndst;

​

        Buffer.BlockCopy(Counter, 0, buffer, 0, Counter.Length);

​

        for (int i = offset; i > 0; i--)

        {

            odst = buffer[i];

            osrc = offset - i < cnt.Length ? cnt[offset - i] : (byte)0;

            ndst = (byte)(odst + osrc + carry);

            carry = ndst < odst ? 1 : 0;

            buffer[i] = ndst;

        }

​

        return buffer;

    }

}

​