Decrypted Using OpenSSL from DecodeBase64 String

Hello Rajesh,

Please use this link which will help you out,

https://didisoft.com/openssl-net/examples/base-64/

using System;
using System.Runtime.InteropServices;

public class OpenSSLBase64Decoder
{
    public static byte[] Decode(string base64String)
    {
        byte[] base64Bytes = Convert.FromBase64String(base64String);

        IntPtr bioPtr = Interop.Crypto.BioNew(Interop.Crypto.BioTypes.Memory);
        Interop.Crypto.BioWrite(bioPtr, base64Bytes, base64Bytes.Length);

        IntPtr ctxPtr = Interop.Crypto.EvpEncodeInit();
        Interop.Crypto.EvpDecodeInit(ctxPtr, Interop.Crypto.EvpEncodingType.Base64);

        Interop.Crypto.EvpDecodeUpdate(ctxPtr, null, out int outlen, bioPtr, base64Bytes.Length);
        IntPtr bufferPtr = Interop.Crypto.BioCtrlPending(bioPtr, out int bufferLength);
        byte[] buffer = new byte[bufferLength];
        Marshal.Copy(bufferPtr, buffer, 0, bufferLength);

        Interop.Crypto.EvpDecodeFinal(ctxPtr, null, outlen);
        Interop.Crypto.EvpEncodeFinal(ctxPtr, null, out int _);

        Interop.Crypto.EvpEncodeCleanup(ctxPtr);
        Interop.Crypto.BioFreeAll(bioPtr);

        return buffer;
    }
}
internal static class Interop
{
    internal static class Crypto
    {
        internal enum BioTypes
        {
            Memory = 0x1,
        }

        internal enum EvpEncodingType
        {
            Base64 = 3,
        }

        [DllImport("libcrypto.dll", CallingConvention = CallingConvention.Cdecl)]
        internal static extern IntPtr BioNew(BioTypes type);

        [DllImport("libcrypto.dll", CallingConvention = CallingConvention.Cdecl)]
        internal static extern int BioWrite(IntPtr bio, byte[] data, int length);

         [DllImport("libcrypto.dll", CallingConvention = CallingConvention.Cdecl)]
    internal static extern int BioFree(IntPtr bio);

    [DllImport("libcrypto.dll", CallingConvention = CallingConvention.Cdecl)]
    internal static extern IntPtr EVP_DecodeBlock(IntPtr output, byte[] input, int length);

    [DllImport("libcrypto.dll", CallingConvention = CallingConvention.Cdecl)]
    internal static extern IntPtr EVP_EncodeBlock(IntPtr output, byte[] input, int length);

    internal static byte[] Base64Decode(string encodedString)
    {
        var bio = BioNew(BioTypes.Memory);
        BioWrite(bio, Encoding.ASCII.GetBytes(encodedString), encodedString.Length);
        BioCtrl(bio, BioCtrlSetClose, BioClose);
        var buffer = new byte[encodedString.Length];
        var length = (int)EVP_DecodeBlock(bio, buffer, encodedString.Length);
        BioFree(bio);
        var result = new byte[length];
        Array.Copy(buffer, 0, result, 0, length);
        return result;
    }

    internal static string Base64Encode(byte[] inputBytes)
    {
        var bio = BioNew(BioTypes.Memory);
        var output = BioNew(BioTypes.Memory);
        var length = inputBytes.Length;
        var writtenBytes = 0;

        do
        {
            var bytesToWrite = Math.Min(length - writtenBytes, MaxBufferSize);
            var segment = new ArraySegment(inputBytes, writtenBytes, bytesToWrite);
            BioWrite(bio, segment.Array, bytesToWrite);
            writtenBytes += bytesToWrite;
        } while (writtenBytes < length);

        var buffer = new byte[MaxBufferSize];
        do
        {
            var bytesRead = EVP_EncodeBlock(output, buffer, MaxBufferSize);
            if (bytesRead > 0)
            {
                var segment = new ArraySegment(buffer, 0, bytesRead);
                BioWrite(bio, segment.Array, bytesRead);
            }
        } while (writtenBytes < length);

        BioCtrl(bio, BioCtrlSetClose, BioClose);
        BioCtrl(output, BioCtrlSetClose, BioClose);

        var resultPointer = IntPtr.Zero;
        var resultLength = (int)BioCtrl(bio, BioCtrlPending, 0, IntPtr.Zero);
        var resultBytes = new byte[resultLength];

        if (resultLength > 0)
        {
            resultPointer = Marshal.AllocHGlobal(resultLength);
            resultLength = (int)BioRead(bio, resultPointer, resultLength);
            Marshal.Copy(resultPointer, resultBytes, 0, resultLength);
            Marshal.FreeHGlobal(resultPointer);
        }

        BioFree(bio);
        BioFree(output);

        return Encoding.ASCII.GetString(resultBytes);
    }
}

See the code it may help you.

you can use the System.Security.Cryptography namespace, which provides various cryptographic services, including encryption, decryption, and digital signatures. A sample code snippet that shows how to convert the decoded Base64 string into OpenSSL using the System.Security.Cryptography namespace

1) First, convert the Base64 string into a byte array using the Convert.FromBase64String method.
2) Then create an OpenSSL BIO object to hold the byte array.
3) Create an EVP_ENCODE_CTX object to hold the decoding context.
4) Set the decoding context to use Base64 decoding.
5) Decode the data using the BIO object and decoding context.
6) Finalize the decoding process.
7) Retrieve the decoded data from the BIO object.
8) Cleanup the OpenSSL objects.