Win32Certificate.hpp

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2023, Delta V Software. All rights reserved.
// https://www.deltavsoft.com
//
// RCF is distributed under dual licenses - closed source or GPL.
// Consult your particular license for conditions of use.
//
// If you have not purchased a commercial license, you are using RCF under GPL terms.
//
// Version: 3.4
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************

#ifndef INCLUDE_RCF_WIN32CERTIFICATE_HPP
#define INCLUDE_RCF_WIN32CERTIFICATE_HPP

#include <RCF/Certificate.hpp>

#include <RCF/Tchar.hpp>

#include <windows.h>
#include <schnlsp.h>
#include <wincrypt.h>

namespace RCF {

    class ByteBuffer;

    enum Win32CertificateLocation;
    enum Win32CertificateStore;

    class RCF_EXPORT Win32Certificate : public Certificate
    {
    public:
        Win32Certificate();
        Win32Certificate(PCCERT_CONTEXT pContext);
        ~Win32Certificate();

        // *** SWIG BEGIN ***

        virtual CertificateImplementationType _getType();

        tstring getCertificateName();

        tstring getIssuerName();

        void exportToPfx(const std::string & pfxFilePath);

        Win32CertificatePtr findRootCertificate(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore);

        // *** SWIG END ***

        PCCERT_CONTEXT getWin32Context();

        

        void setHasBeenDeleted()
        {
            mHasBeenDeleted = true;
        }

        tstring getSubjectName();
        tstring getOrganizationName();
        tstring getCertAttribute(const char * whichAttr);

        RCF::ByteBuffer exportToPfx();

    protected:

        PCCERT_CONTEXT mpCert;
        bool mHasBeenDeleted;
    };

    
    class RCF_EXPORT PfxCertificate : public Win32Certificate
    {
    public:

        // *** SWIG BEGIN ***

        PfxCertificate(
            const std::string & pathToCert, 
            const tstring & password,
            const tstring & certName);

        void addToStore(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore);

        // *** SWIG END ***

        PfxCertificate(
            ByteBuffer certPfxBlob, 
            const tstring & password,
            const tstring & certName);

        ~PfxCertificate();

    private:

        void init(
            ByteBuffer pfxBlob,
            const tstring & password,
            const tstring & certName);

        void initFromFile(
            const std::string & pathToCert, 
            const RCF::tstring & password,
            const RCF::tstring & certName);

        HCERTSTORE mPfxStore;
    };

    class RCF_EXPORT StoreCertificate  : public Win32Certificate
    {
    public:

        // *** SWIG BEGIN ***

        StoreCertificate(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore,
            const tstring & certName);

        void removeFromStore();

        // *** SWIG END ***

        ~StoreCertificate();

    private:
        HCERTSTORE mStore;
    };

    class RCF_EXPORT StoreCertificateIterator
    {
    public:

        // *** SWIG BEGIN ***

        StoreCertificateIterator(
            Win32CertificateLocation certStoreLocation, 
            Win32CertificateStore certStore);

        bool moveNext();

        void reset();

        Win32CertificatePtr current();

        // *** SWIG END ***

        ~StoreCertificateIterator();

    private:

        HCERTSTORE              mhCertStore;
        PCCERT_CONTEXT          mpCertIterator;
        Win32CertificatePtr     mCurrentCertPtr;
    };

} // namespace RCF

#endif // ! INCLUDE_RCF_WIN32CERTIFICATE_HPP