Schannel.hpp

//******************************************************************************
// RCF - Remote Call Framework
//
// Copyright (c) 2005 - 2013, Delta V Software. All rights reserved.
// http://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: 2.0
// Contact: support <at> deltavsoft.com 
//
//******************************************************************************

#ifndef INCLUDE_RCF_SCHANNEL_HPP
#define INCLUDE_RCF_SCHANNEL_HPP

#include <RCF/Filter.hpp>
#include <RCF/SspiFilter.hpp>
#include <RCF/util/Tchar.hpp>

#include <schnlsp.h>

// missing stuff in mingw headers
#ifdef __MINGW32__
#ifndef SP_PROT_NONE
#define SP_PROT_NONE                    0
#endif
#endif // __MINGW32__

namespace RCF {

    static const ULONG DefaultSchannelContextRequirements = 
        ASC_REQ_SEQUENCE_DETECT |
        ASC_REQ_REPLAY_DETECT   |
        ASC_REQ_CONFIDENTIALITY |
        ASC_REQ_EXTENDED_ERROR  |
        ASC_REQ_ALLOCATE_MEMORY |
        ASC_REQ_STREAM;

    class SchannelServerFilter : public SspiServerFilter
    {
    public:
        SchannelServerFilter(
            RcfServer & server,
            DWORD enabledProtocols,
            ULONG contextRequirements);

        int getFilterId() const;
    };

    class SchannelFilterFactory : public FilterFactory
    {
    public:

        SchannelFilterFactory(
            DWORD enabledProtocols = SP_PROT_TLS1_SERVER,
            ULONG contextRequirements = DefaultSchannelContextRequirements);

        FilterPtr                           createFilter(RcfServer & server);
        int                                 getFilterId();

    private:
        
        ULONG mContextRequirements;
        DWORD mEnabledProtocols;
    };

    class SchannelClientFilter : public SspiClientFilter
    {
    public:
        SchannelClientFilter(
            ClientStub * pClientStub,
            DWORD enabledProtocols = SP_PROT_NONE,
            ULONG contextRequirements = DefaultSchannelContextRequirements);

        int getFilterId() const;
    };

    typedef SchannelClientFilter        SchannelFilter;

    // Certificate utility classes.

    class Win32Certificate;
    typedef boost::shared_ptr<Win32Certificate> Win32CertificatePtr;
    
    class RCF_EXPORT Win32Certificate : public Certificate
    {
    public:
        Win32Certificate();
        Win32Certificate(PCCERT_CONTEXT pContext);
        ~Win32Certificate();

        // *** SWIG BEGIN ***

        virtual CertificateImplementationType _getType()
        {
            return Cit_Win32;
        }

        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_SCHANNEL_HPP