using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace ConsoleApp19
{
    class Program
    {
        internal static class CryptoApi
        {
            [DllImport("Crypt32.DLL")]
            internal static extern bool CryptBinaryToString(
                [In] byte[] pbBinary,
                [In] int cbBinary,
                [In] CrypBinaryFlags dwFlags,
                [In] byte[] pszString,
                [In, Out] ref int pcchString);

            [DllImport("Crypt32.DLL", CharSet = CharSet.Unicode)]
            internal static extern bool CryptStringToBinary(
                [In] string pszString,
                [In] int cchString,
                [In] CrypBinaryFlags dwFlags,
                [In] IntPtr pbBinary,
                [In, Out] ref int pcbBinary,
                [Out] out int pdwSkip,
                [Out] out int pdwFlags);

            [Flags]
            internal enum CrypBinaryFlags : uint
            {
                Base64WithHeader = 0x00000000,
                Base64 = 0x00000001,
                Binary = 0x00000002,
                Base64WithRequestHeader = 0x00000003,
                Hexadecimal = 0x00000004,
                HexadecimalWithAscii = 0x00000005,
                AnyBase64 = 0x00000006,
                AnyString = 0x00000007,
                AnyHexadecimal = 0x00000008,
                Base64WithX509CRLHeader = 0x00000009,
                HexadecimalWithAddress = 0x0000000a,
                HexadecimalWithAsciiAndAddress = 0x0000000b,
                RawHexadecimal = 0x0000000c,
                Strict = 0x20000000,
                NoCRLF = 0x40000000,
                NoCR = 0x80000000,
            }

            internal static byte[] Decode(string input, CrypBinaryFlags flags, int inputSize)
            {
                int outputSize = 0;
                int pdwSkip;
                int pdwFlags;
                if (!CryptStringToBinary(input, inputSize, flags, IntPtr.Zero,
                    ref outputSize, out pdwSkip, out pdwFlags))
                {
                    throw new Exception();
                }
                IntPtr nativeBuffer = IntPtr.Zero;
                try
                {
                    nativeBuffer = Marshal.AllocCoTaskMem(outputSize);
                    if (!CryptStringToBinary(input, inputSize, flags, nativeBuffer,
                        ref outputSize, out pdwSkip, out pdwFlags))
                    {
                        throw new Exception();
                    }
                    byte[] result = new byte[outputSize];
                    Marshal.Copy(nativeBuffer, result, 0, outputSize);
                    return result;
                }
                finally { if (IntPtr.Zero != nativeBuffer) { Marshal.FreeCoTaskMem(nativeBuffer); } }
            }

            internal static string Encode(byte[] input, CrypBinaryFlags flags,
                Encoding encoding)
            {
                int output_size = 0;
                byte[] result = null;
                _Encode(input, input.Length, ref result, ref output_size, flags, true, false);
                result = new byte[output_size];
                _Encode(input, input.Length, ref result, ref output_size, flags, false, false);
                return encoding.GetString(result);
            }

            private static void _Encode(byte[] input, int input_size, ref byte[] output,
              ref int output_size, CrypBinaryFlags flags, bool get_only_size,
              bool alloc_buffer)
            {
                if (get_only_size)
                {
                    output_size = 0;
                    output = null;
                }
                else
                {
                    if (alloc_buffer)
                    {
                        output = new byte[output_size];
                    }
                }
                if (!CryptBinaryToString(input, input_size, flags, output, ref output_size))
                {
                    throw new Exception();
                }
            }
        }
        static void Main(string[] args)
        {
            var bytes = new byte[] { 0x11, 0x22, 0x33, 0x44 };
            var encoded = CryptoApi.Encode(bytes, CryptoApi.CrypBinaryFlags.RawHexadecimal, Encoding.UTF8);
            Console.WriteLine(encoded);
            Console.ReadKey();
            var decoded = CryptoApi.Decode(encoded, CryptoApi.CrypBinaryFlags.RawHexadecimal, encoded.TrimEnd('\0', '\n', '\r').Length);
            Console.WriteLine(string.Join(" ", decoded.Select(p=>p.ToString("x2"))));
            Console.ReadKey();

        }
    }
}