CertStore.h

Go to the documentation of this file.

/*  CertStore.h - certificate store wrappers
    Copyright (C) 2001-2004 Mark Weaver
    Written by Mark Weaver <mark@npsl.co.uk>

    Part of the Open-Win32 library.
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the
    Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA  02111-1307, USA.
*/

#ifndef OW32_CertStore_h
#define OW32_CertStore_h

#include <OW32/OW32Libs.h>
#include <OW32/XHCERTSTORE.h>
#ifndef OW32_NO_STL
#include <OW32/tstl.h>
#endif

namespace OW32
{

#ifndef MY_ENCODING_TYPE
#define MY_ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
#endif

class OW32_LIB_EXPORT CCertStore
{
private:
    CCertStore(const CCertStore& );
    CCertStore& operator=(const CCertStore& );

    XHCERTSTORE m_hCertStore;

public:
    CCertStore() {}

    CCertStore(HCERTSTORE hCertStore) :
        m_hCertStore(hCertStore)    
    {
    }

    HCERTSTORE Detach()
    {
        return m_hCertStore.Detach();
    }

    void OpenFromHandle(HCERTSTORE hCertStore)
    {
        m_hCertStore = hCertStore;
    }

    BOOL Open(LPCSTR lpszStoreProvider = CERT_STORE_PROV_SYSTEM,
         DWORD dwMsgAndCertEncodingType = PKCS_7_ASN_ENCODING | X509_ASN_ENCODING,
         HCRYPTPROV hCryptProv = NULL,
         DWORD dwFlags = CERT_SYSTEM_STORE_CURRENT_USER,
         const void* pvPara = L"MY")
    {
        m_hCertStore = CertOpenStore(lpszStoreProvider, dwMsgAndCertEncodingType,
            hCryptProv, dwFlags, pvPara);
        return (m_hCertStore != NULL);
    }

    BOOL OpenCurrentUser(LPCWSTR lpStore = L"MY")
    {
        return Open(CERT_STORE_PROV_SYSTEM, PKCS_7_ASN_ENCODING|X509_ASN_ENCODING,
                    NULL, CERT_SYSTEM_STORE_CURRENT_USER, lpStore);
    }

    BOOL OpenLocalMachine(LPCWSTR lpStore = L"MY")
    {
        return Open(CERT_STORE_PROV_SYSTEM, MY_ENCODING_TYPE,
                    NULL, CERT_SYSTEM_STORE_LOCAL_MACHINE, lpStore);
    }

    BOOL OpenMemoryStore()
    {
        return Open(CERT_STORE_PROV_MEMORY, MY_ENCODING_TYPE,
            NULL, 0, NULL);
    }

    void Close(DWORD dwFlags=0)
    {
        m_hCertStore.Close(dwFlags);
    }

    BOOL FindCertificateBySubject(LPCWSTR subject, PCCERT_CONTEXT* ppCertContext)
    {
        *ppCertContext = CertFindCertificateInStore(
            m_hCertStore, MY_ENCODING_TYPE, 0, CERT_FIND_SUBJECT_STR, subject, NULL);
        if (!*ppCertContext)
            return FALSE;
        return TRUE;
    }

    /* \brief Find a certificate in the store by CERT_ID (issuer, serial number) */
    BOOL FindCertificateByCertID(CERT_ID* pCertID, PCCERT_CONTEXT* ppCertContext)
    {
        *ppCertContext = CertFindCertificateInStore(
            m_hCertStore, MY_ENCODING_TYPE, 0, CERT_FIND_CERT_ID, pCertID, NULL); 
        if (!*ppCertContext)
            return FALSE;
        return TRUE;
    }

    BOOL FindCertificateByHash(CRYPT_HASH_BLOB* hash, PCCERT_CONTEXT* ppCertContext)
    {
        *ppCertContext = CertFindCertificateInStore(
            m_hCertStore, MY_ENCODING_TYPE, 0, CERT_FIND_HASH, hash, NULL);
        if (!*ppCertContext)
            return FALSE;
        return TRUE;
    }

    BOOL FindCertificateByHash(BYTE* hash, DWORD hashLen, PCCERT_CONTEXT* ppCertContext)
    {
        CRYPT_HASH_BLOB hashBlob;
        hashBlob.cbData = hashLen;
        hashBlob.pbData = hash;
        return FindCertificateByHash(&hashBlob, ppCertContext);
    }

    BOOL FindCertificateByCertID(LPCSTR issuer, 
        LPCSTR serial, PCCERT_CONTEXT* ppCertContext);

    // convert a certificate name to a string
    static BOOL NameToStr(LPTSTR buf, DWORD cch, CERT_NAME_BLOB* pName,
                          DWORD dwStrType = CERT_X500_NAME_STR);

#ifndef OW32_NO_STL

    static BOOL NameToStr(std::_tstring& str, CERT_NAME_BLOB* pName, 
                          DWORD dwStrType = CERT_X500_NAME_STR);
#endif

    BOOL AddCertificateContext(PCCERT_CONTEXT pCertContext,
        DWORD dwAddDisposition = CERT_STORE_ADD_NEW,
        PCCERT_CONTEXT* ppStoreContext = NULL)
    {
        return CertAddCertificateContextToStore(m_hCertStore,
            pCertContext, dwAddDisposition, ppStoreContext);
    }

    PCCERT_CONTEXT EnumCertificates(PCCERT_CONTEXT pPrevCertContext)
    {
        return CertEnumCertificatesInStore(m_hCertStore, pPrevCertContext);
    }

    operator HCERTSTORE() { return m_hCertStore; }
    HCERTSTORE* operator&() { return &m_hCertStore; }
};

} // namespace OW32

#endif // OW32_CertStore_h

---