Interop C# IntPtr to C void* to C++ PCCERT_CONTEXT and back again

Question

I'm needing to use C++ to get a certificate from the local machine store because Unity & Mono don't support the local machine store correctly.

To that end I've implemented the following, but my knowledge of pointers, references, address of and C++ function lifetime is stopping me from getting a valid pointer back. I know there's likely multiple sins in the below, but first, please help me get 'out' a pointer to the found certificate that isn't nuked by memory management.

X509CertificateLookup.h

#define DLLExport __declspec(dllexport)

extern "C"
{
    DLLExport bool GetMachineCertByThumb(void**& pCertContext, const char* thumbprint, const char* storeName);
    DLLExport void FreeCertificateContext(const void* certPtr);
}

#endif

X509CertificateLookup.cpp

bool GetMachineCertByThumb(void**& pCertContext, const char* thumbprint, const char* storeName) {
    HCERTSTORE hCertStore = NULL;

    if ((hCertStore = CertOpenStore(
        CERT_STORE_PROV_SYSTEM_W,        // The store provider type
        0,                               // The encoding type is not needed
        NULL,                            // Use the default HCRYPTPROV
        CERT_SYSTEM_STORE_LOCAL_MACHINE | CERT_STORE_READONLY_FLAG, // Set the store location in a registry location
        storeName                        // The store name as a Unicode string (L"MY") 
    )) != nullptr) {
        PCCERT_CONTEXT pSearchCertContext = NULL;

        if ((pSearchCertContext = CertFindCertificateInStore(
            hCertStore,
            X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
            0,
            CERT_FIND_HASH_STR,
            thumbprint,
            pSearchCertContext)) != nullptr) {

            CertCloseStore(hCertStore, CERT_CLOSE_STORE_CHECK_FLAG);

            //A pointer to a buffer that contains the encoded certificate
            pCertContext = &pSearchCertContext; //<- This is where my issues are!
            return true;
        }
    }

    if (hCertStore) {
        CertCloseStore(hCertStore, CERT_CLOSE_STORE_CHECK_FLAG);
    }

    pCertContext = nullptr;
    return false;
}

void FreeCertificateContext(const void* certPtr) {
    if (certPtr == nullptr) {
        CertFreeCertificateContext(static_cast<PCCERT_CONTEXT>(certPtr));
    }
}

X509CertLookupWorkaround.cs

class X509CertificateLookup {
    [DllImport(nameof(X509CertificateLookup), CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.I1)]
        public static extern bool GetMachineCertByThumb(
            ref IntPtr pCertContext,
            [MarshalAs(UnmanagedType.LPUTF8Str)]
            string thumbprint,
            [MarshalAs(UnmanagedType.LPUTF8Str)]
            string storeName);

    [DllImport(nameof(X509CertificateLookup), CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
    public static extern void FreeCertificateContext([In] IntPtr certPtr);
}

class X509CertLookupWorkaround{

    public static X509Certificate2 GetMachineCertByThumb_CPP(string thumbprint, string storeName) {

        IntPtr certPtr = IntPtr.Zero;
        
        if(!X509CertificateLookup.GetMachineCertByThumb(ref certPtr, thumbprint, storeName) || certPtr == IntPtr.Zero) {
            UnityEngine.Debug.Log("Failure, Certificate not found!");
            return null;
        }else{
            UnityEngine.Debug.Log("Success, Certificate found!");
            return new X509Certificate2(certPtr);
        }
    }
    
    public static void ReleaseCertificate(IntPtr certPtr){
        X509CertificateLookup.FreeCertificateContext(certPtr)
    }
}

Answer 1

For starters, it should be

bool GetMachineCertByThumb(
   void*& pCertContext,    // A reference to a `void*` variable to which to write.
   const char* thumbprint,
   const char* storeName
) {
   ...
   pCertContext = pSearchCertContext;

   ...
}

You want to "return" the pointer returned by CertFindCertificateInStore, not a pointer to the local variable that contains this pointer.

---

Then, there's a potential issue in the use of a reference type in an extern "C" section. C doesn't have reference types, so let's avoid it.

bool GetMachineCertByThumb(
   void** ppCertContext,    // A pointer to a `void*` variable to which to write.
   const char* thumbprint,
   const char* storeName
) {
   ...
   *ppCertContext = pSearchCertContext;
   ...
}

---

But why return the value via a parameter? It would be a lot simpler to return it as a returned value.

void *GetMachineCertByThumb( const char* thumbprint, const char* storeName ) {
   ...
   return pSearchCertContext;
}

---

I don't know if there are other issues.

Answer 2

I would try to avoid the void** parameter as much as possible.

Since the C++ code gets a pointer to the buffer (and from the looks of it, the buffer is not local), this may be a better interface (or at least this is how I would look to implement it):

PCCERT_CONTEXT GetMachineCertByThumb(LPCSTR thumbprint, LPCSTR storeName) 
{
    HCERTSTORE hCertStore = NULL;

    if ((hCertStore = CertOpenStore(
        CERT_STORE_PROV_SYSTEM_W,        // The store provider type
        0,                               // The encoding type is not needed
        NULL,                            // Use the default HCRYPTPROV
        CERT_SYSTEM_STORE_LOCAL_MACHINE | CERT_STORE_READONLY_FLAG, // Set the store location in a registry location
        storeName                        // The store name as a Unicode string (L"MY") 
    )) != nullptr) {
        PCCERT_CONTEXT pSearchCertContext = NULL;

        if ((pSearchCertContext = CertFindCertificateInStore(
            hCertStore,
            X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
            0,
            CERT_FIND_HASH_STR,
            thumbprint,
            pSearchCertContext)) != nullptr) {

            CertCloseStore(hCertStore, CERT_CLOSE_STORE_CHECK_FLAG);

            //A pointer to a buffer that contains the encoded certificate
            return pSearchCertContext; 
        }
        return NULL;
    }

    if (hCertStore) {
        CertCloseStore(hCertStore, CERT_CLOSE_STORE_CHECK_FLAG);
    }

    return NULL;
}

The above interface avoids the void** parameter, as the function returns the pointer to the actual buffer (if found), or NULL (if not found).

On the C# side of the fence for the pinvoke:

[DllImport(nameof(X509CertificateLookup), CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi, ExactSpelling = true)]
public static extern IntPtr GetMachineCertByThumb([MarshalAs(UnmanagedType.LPUTF8Str)] string thumbprint, [MarshalAs(UnmanagedType.LPUTF8Str)] string storeName);

Then in the C# calling code itself, you will be testing for the IntZero, and not a return value of true or false:

class X509CertLookupWorkaround
{
    public static X509Certificate2 GetMachineCertByThumb_CPP(string thumbprint, string storeName) 
    {
        IntPtr certPtr = X509CertificateLookup.GetMachineCertByThumb(thumbprint, storeName);
        if (certPtr == IntPtr.Zero) 
        {
            UnityEngine.Debug.Log("Failure, Certificate not found!");
            return null;
        }
        else
        {
            UnityEngine.Debug.Log("Success, Certificate found!");
            return new X509Certificate2(certPtr);
        }
    }
 //...
}

Answer 3

You are probably better off just doing the whole thing in C# and PInvoke, rather than messing around trying to marshal to/from C++ as well.

Create SafeHandle classes for the store and context handles, and put them in using to dispose them properly.

class X509CertificateLookup
{
    const int CERT_CLOSE_STORE_CHECK_FLAG = 0x2;
    const int CERT_SYSTEM_STORE_LOCAL_MACHINE = 0x20000;
    const int CERT_STORE_READONLY_FLAG = 0x8000;
    const int X509_ASN_ENCODING = 0x1;
    const int PKCS_7_ASN_ENCODING = 0x10000;
    const int CERT_FIND_HASH_STR = 0x140000;
    const int CRYPT_E_NOT_FOUND = unchecked((int)0x80092004);

    [DllImport("Crypt32.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
    static extern SafeCertStoreHandle CertOpenStore(
      [MarshalAs(UnmanagedType.LPStr)] string lpszStoreProvider,
      int dwEncodingType,
      IntPtr hCryptProv,
      int dwFlags,
      [MarshalAs(UnmanagedType.LPWStr)] string pvPara
    );

    [DllImport("Crypt32.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
    static extern SafeCertContextHandle CertFindCertificateInStore(
      SafeCertStoreHandle hCertStore,
      int dwCertEncodingType,
      int dwFindFlags,
      int dwFindType,
      [MarshalAs(UnmanagedType.LPWStr)] string pvFindPara,
      SafeCertContextHandle pPrevCertContext
    );

    class SafeCertContextHandle : SafeHandleZeroOrMinusOneIsInvalid
    {
        public SafeCertContextHandle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }

        [DllImport("Crypt32.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
        private static extern bool CertFreeCertificateContext(IntPtr pCertContext);

        override protected bool ReleaseHandle()
        {
            if (!IsInvalid)
                CertFreeCertificateContext(handle);
            return true;
        }
    }

    class SafeCertStoreHandle : SafeHandleZeroOrMinusOneIsInvalid
    {
        public SafeCertStoreHandle(IntPtr handle) : base(true)
        {
            SetHandle(handle);
        }

        [DllImport("Crypt32.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
        static extern bool CertCloseStore(IntPtr hCertStore, int dwFlags);

        override protected bool ReleaseHandle()
        {
            if (!IsInvalid)
                CertCloseStore(handle, CERT_CLOSE_STORE_CHECK_FLAG);
            return true;
        }
    }

    public static X509Certificate2 GetMachineCertByThumb(string thumbprint, string storeName)
    {
        using var hCertStore = CertOpenStore(
            "CERT_STORE_PROV_SYSTEM_W",      // The store provider type
            0,                               // The encoding type is not needed
            IntPtr.Zero,                     // Use the default HCRYPTPROV
            CERT_SYSTEM_STORE_LOCAL_MACHINE | CERT_STORE_READONLY_FLAG, // Set the store location in a registry location
            storeName
        );

        if (hCertStore.IsInvalid)
            throw new Win32Exception(Marshal.GetLastWin32Error());

        using var pSearchCertContext = CertFindCertificateInStore(
            hCertStore,
            X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
            0,
            CERT_FIND_HASH_STR,
            thumbprint,
            null);

        if (pSearchCertContext.IsInvalid)
        {
            var errorCode = Marshal.GetLastWin32Error();
            if (errorCode == CRYPT_E_NOT_FOUND)
                return null;
            throw new Win32Exception(errorCode);
        }
        return new X509Certificate2(pSearchCertContext.DangerousGetHandle());
    }
}