CPKIFCryptoMediator2.h

Go to the documentation of this file.

#ifndef __PKIFCRYPTOMEDIATOR2_H__
#define __PKIFCRYPTOMEDIATOR2_H__

//include toolkit header files
#include "PKIFdll.h"
#include "components.h"

//include necessary standard library pieces
#include <vector>
#include <bitset>

// forward declarations
class CPKIFException;
FD_SMART_PTR(CPKIFCredential);
FD_SMART_PTR(CPKIFKeyUsage);

#include "PKIFMediators.h"
#include "IPKIFCryptoRawOperations.h"
#include "IPKIFCryptoKeyIDOperations.h"
#include "IPKIFCryptoMisc.h"
#include "IPKIFDefaultKeyManagement.h"
#include "IPKIFCryptoKeyAgree.h"

class CAC_API CPKIFCryptoMediator2 :    public IPKIFMediator,public IPKIFCryptoRawOperations, public IPKIFCryptoKeyIDOperations, public IPKIFCryptoMisc, public IPKIFDefaultKeyManagement, public IPKIFCryptoKeyAgree
{
    friend struct CPKIFCryptoMediator2Impl;
public:
    CPKIFCryptoMediator2(bool addDefaultColleagues = false);
    virtual ~CPKIFCryptoMediator2(void);

    //IPKIFMediator functions
    void InitializeMediator(std::vector<CPKIFException*>* errorInfo);
    void Terminate();

    //IPKIFColleague functions
    void Initialize();

    void GetColleagues(std::vector<IPKIFColleaguePtr>& v) const;

    //Miscellaneous functions
    void AddColleague(IPKIFColleaguePtr& module);
    const CPKIFCredentialPtr SetDefaultKey(const std::string& asciiHexKeyID, PKIFCRYPTO::DefaultKeyType op);
    CPKIFCredentialPtr GetDefaultKey(PKIFCRYPTO::DefaultKeyType op);

    //IPKIFCryptoMisc functions
    void GenRandom(unsigned char* buf, int len);
    IPKIFHashContext* HashInit(PKIFCRYPTO::HASH_ALG alg);
    void HashUpdate(IPKIFHashContext* hash, unsigned char* pData, int nDataLen);
    void HashFinal(IPKIFHashContext* hash, unsigned char* pResult, int* pnResultLen);

    //IPKIFCryptoKeyID functions
    void Sign(const CPKIFCredential& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int* nSignatureLen, PKIFCRYPTO::HASH_ALG hashAlg);
    void Decrypt(const CPKIFCredential& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen);
    void Encrypt(const CPKIFCredential& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen);
    bool Verify(const CPKIFCredential& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int nSignatureLen, PKIFCRYPTO::HASH_ALG hashAlg);
    void GetKeyList(CPKIFCredentialList& v, std::bitset<9>* ku=NULL);
    void GetKeyList(CPKIFCredentialList& v,CPKIFKeyUsagePtr& ku);

    IPKIFCryptContext* CryptInit(CPKIFCredentialPtr& key, bool pad = true);
    void Decrypt(IPKIFCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final);
    void Encrypt(IPKIFCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final);

    void Sign(const CPKIFCredentialPtr& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int* nSignatureLen, PKIFCRYPTO::HASH_ALG hashAlg);
    void Decrypt(const CPKIFCredentialPtr& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen);
    void Encrypt(const CPKIFCredentialPtr& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen);
    bool Verify(const CPKIFCredentialPtr& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int nSignatureLen, PKIFCRYPTO::HASH_ALG hashAlg);

    //IPKIFCryptoRaw functions
    void Sign(const CPKIFKeyMaterial& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int* nSignatureLen, PKIFCRYPTO::HASH_ALG hashAlg);
    void Encrypt(const CPKIFKeyMaterial& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool pad = true);
    void Decrypt(const CPKIFKeyMaterial& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool pad = true);
    bool Verify(const CPKIFKeyMaterial& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int nSignatureLen, PKIFCRYPTO::HASH_ALG hashAlg);
    bool VerifyCertificate(const CPKIFCertificate& issCert, const CPKIFCertificate& subCert);

    IPKIFRawCryptContext* CryptInit(const CPKIFKeyMaterial& key, bool pad = true);
    void Decrypt(IPKIFRawCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final);
    void Encrypt(IPKIFRawCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final);

    IPKIFRawCryptContext* HMACInit(const CPKIFKeyMaterial &key, PKIFCRYPTO::HASH_ALG ha);
    void HMACUpdate(IPKIFRawCryptContext* ctx, unsigned char* pData, int nDataLen);
    void HMACFinal(IPKIFRawCryptContext* ctx, unsigned char* pResult, int* pnResultLen);

    // ephemeral-static or static-static key agreement
    virtual IPKIFKeyAgreeContextPtr SecretAgree(CPKIFCredentialPtr& myPrivateKey, const CPKIFCertificatePtr& theirCert, 
        const CPKIFAlgorithm * alg);
    virtual IPKIFKeyAgreeContextPtr SecretAgree(CPKIFCredentialPtr& myPrivateKey, const CPKIFBufferPtr& theirPublicKey, 
        const CPKIFAlgorithm * alg);

    // (single-pass only) authenticated key agreement
    // originator interfaces
    virtual IPKIFKeyAgreeContextPtr SecretAgree(const CPKIFCredentialPtr& myPrivateKey, CPKIFCredentialPtr & ephemeralKeyPair,
        const CPKIFCertificatePtr& theirCert, const CPKIFAlgorithm * alg);
    virtual IPKIFKeyAgreeContextPtr SecretAgree(const CPKIFCredentialPtr& myPrivateKey, CPKIFCredentialPtr & ephemeralKeyPair,
        const CPKIFBufferPtr& theirPublicKey, const CPKIFAlgorithm * alg);
    // recipient interfaces
    virtual IPKIFKeyAgreeContextPtr SecretAgree(const CPKIFCredentialPtr& myPrivateKey, const CPKIFBufferPtr& ephemeralPublicKey, 
        const CPKIFCertificatePtr& theirCert, const CPKIFAlgorithm * alg);
    virtual IPKIFKeyAgreeContextPtr SecretAgree(const CPKIFCredentialPtr& myPrivateKey, const CPKIFBufferPtr& ephemeralPublicKey, 
        const CPKIFBufferPtr& theirPublicKey, const CPKIFAlgorithm * alg);
    
    virtual CPKIFKeyMaterialPtr DeriveKey(const IPKIFKeyAgreeContextPtr & context, unsigned long keyLen);

    // IPKIFCryptoAlgSupport
    virtual bool SupportsAlgorithm(const CPKIFKeyMaterial& key);
    
private:
    CPKIFCryptoMediator2(const CPKIFCryptoMediator2& copy);
    CPKIFCryptoMediator2& operator=(const CPKIFCryptoMediator2& rhs); //added 4/6/2004

    enum {thisComponent = TOOLKIT_CRYPTO_MEDIATOR};

    struct CPKIFCryptoMediator2Impl *m_impl;

};
DECLARE_SMART_POINTERS(CPKIFCryptoMediator2);


#endif