PKIFCryptoPPRaw.cpp

Go to the documentation of this file.

#include "PKIFCryptoPPRaw.h"
#include "PKIFCryptoPPRawContext.h"
#include "PKIFCryptoPPUtils.h"

#include "PKIFCryptoException.h"
#include "PKIFKeyMaterial.h"
#include "SubjectPublicKeyInfo.h"
#include "PKIFAlgorithm.h"

#include "ToolkitUtils.h"
#include "PKIFCryptoPPErrors.h"
#include "PKIFCryptoErrors.h"
#include "Certificate.h"
#include "Buffer.h"

#include "PKIFCryptUtils.h"

#include "PKIFCryptoPPKeyMaterial.h"

#include <sstream>

#include "boost/numeric/conversion/cast.hpp"

#include "cryptlib.h"
#include "pubkey.h"
#include "sha.h"
#include "queue.h"
#include "osrng.h"
#include "rsa.h"
#include "dsa.h"
#include "eccrypto.h"
#include "asn.h"
#include "dsa.h"
#include "modes.h"
#include "aes.h"
#include "hmac.h"
#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
#include "md5.h"

#include "PKIFCryptoPPExternalDigest.h"

using namespace CryptoPP;

template<bool _CryptDirection>
static void _ASymCrypt(const CPKIFKeyMaterial& key, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool pad = true);



CPKIFCryptoPPRaw::CPKIFCryptoPPRaw(void)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::CPKIFCryptoPPRaw(void)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
}
CPKIFCryptoPPRaw::~CPKIFCryptoPPRaw(void)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::~CPKIFCryptoPPRaw(void)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
}
void CPKIFCryptoPPRaw::Initialize()
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::Initialize()", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
}
bool CPKIFCryptoPPRaw::SupportsAlgorithm(
    const CPKIFKeyMaterial& key)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::SupportsAlgorithm(const CPKIFKeyMaterial& key)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
    if(key.ContainsSymmetricKeyMaterial())
    {   
        try
        {
            switch(key.GetSymmetricKeyAlgorithm()) {
                case PKIFCRYPTO::AES:
                case PKIFCRYPTO::AES128:
                case PKIFCRYPTO::AES192:
                case PKIFCRYPTO::AES256:
                //case PKIFCRYPTO::TDES: This colleague does not currently implement DES or 3DES
                    return true;
                    break;
                default:
                    return false;
                    break;
            }
        }
        catch(CPKIFCryptoException& e)
        {
            if(CRYPTO_ALG_NOT_SUPPORTED == e.GetErrorCode())
            {
                //EXCEPTION DELETION
                //The GetSymAlgorithm function throws upon failure but
                //this function should return false.
                //delete e;
                return false;
            }
            else
                throw e; //should never happen
        }
    } else {
        CPKIFSubjectPublicKeyInfoPtr spki = key.GetSubjectPublicKeyInfo();
        if(!spki) {
            CPKIFCryptoPPKeyMaterialPtr cppKM(new CPKIFCryptoPPKeyMaterial(key));
            spki = cppKM->GetSubjectPublicKeyInfo();
        }
        if(!spki) return false;
        CPKIFAlgorithm * alg = CPKIFAlgorithm::GetAlg(spki->alg()->oid());
        switch(alg->AsymkeyAlg()) {
            case PKIFCRYPTO::RSA:
            case PKIFCRYPTO::ECC:
            case PKIFCRYPTO::DSS:           
                return true;
                break;
            default:
                return false;
        }
    }
    return false;
}
void CPKIFCryptoPPRaw::Sign(
    const CPKIFKeyMaterial& key,
    unsigned char* pHashData, 
    int nHashDataLen, 
    unsigned char* pSignature, 
    int* nSignatureLen,
    PKIFCRYPTO::HASH_ALG hashAlg)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::Sign(const CPKIFKeyMaterial& key,...)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
    // Don't do raw signature generation since we don't have a way of slinging raw private keys around
    RAISE_CRYPTO_EXCEPTION("Signing operations are not implemented for raw key material.", thisComponent, COMMON_NOT_IMPLEMENTED, this);
}

void CPKIFCryptoPPRaw::Decrypt( 
    const CPKIFKeyMaterial& key,
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool pad)
{
    if(key.ContainsSymmetricKeyMaterial()) {
        CPKIFCryptoPPRawContext * ctx = static_cast<CPKIFCryptoPPRawContext *>(this->CryptInit(key,pad));
        try {
            Decrypt(ctx,pData,nDataLen,pResult,pnResultLen,true);
        } catch(...) {
            delete ctx;
            throw;
        }
        delete ctx;
    } else {
        _ASymCrypt<false>(key, pData, nDataLen, pResult, pnResultLen, pad);
    }
}
void CPKIFCryptoPPRaw::Encrypt(
    const CPKIFKeyMaterial& key,
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool pad)
{
    if(key.ContainsSymmetricKeyMaterial()) {
        CPKIFCryptoPPRawContext * ctx = static_cast<CPKIFCryptoPPRawContext *>(this->CryptInit(key,pad));
        try {
            Encrypt(ctx,pData,nDataLen,pResult,pnResultLen,true);
        } catch(...) {
            delete ctx;
            throw;
        }
        delete ctx;
    } else {
        _ASymCrypt<true>(key, pData, nDataLen, pResult, pnResultLen, pad);
    }
}

IPKIFRawCryptContext* CPKIFCryptoPPRaw::HMACInit(const CPKIFKeyMaterial &key, PKIFCRYPTO::HASH_ALG ha)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::HMACInit(const CPKIFKeyMaterial& key, HASH_ALG ha)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
    // the iterative crypt functions are a bad idea with RSA or DSA keys...
    if(!key.ContainsSymmetricKeyMaterial())
    {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, "HMACInit() only makes sense for symmetric keys.");
    }

    CPKIFCryptoPPRawContext * ctx = new CPKIFCryptoPPRawContext();
    try {
        switch(ha) {
            case PKIFCRYPTO::SHA1:
                ctx->m_hashCtx = new HMAC<CryptoPP::SHA1>(key.GetSymmetricKey(),key.GetSymmetricKeyLength());
                break;
    #if !defined(FIPS_MODE)
            case PKIFCRYPTO::MD5:
                ctx->m_hashCtx = new HMAC<CryptoPP::Weak::MD5>(key.GetSymmetricKey(),key.GetSymmetricKeyLength());
                break;
    #endif 
            case PKIFCRYPTO::SHA224:
                ctx->m_hashCtx = new HMAC<CryptoPP::SHA224>(key.GetSymmetricKey(),key.GetSymmetricKeyLength());
                break;
            case PKIFCRYPTO::SHA256:
                ctx->m_hashCtx = new HMAC<CryptoPP::SHA256>(key.GetSymmetricKey(),key.GetSymmetricKeyLength());
                break;
            case PKIFCRYPTO::SHA384:
                ctx->m_hashCtx = new HMAC<CryptoPP::SHA384>(key.GetSymmetricKey(),key.GetSymmetricKeyLength());
                break;
            case PKIFCRYPTO::SHA512:
                ctx->m_hashCtx = new HMAC<CryptoPP::SHA512>(key.GetSymmetricKey(),key.GetSymmetricKeyLength());
                break;
            default:
                std::ostringstream os;
                os << "Unsupported hash algorithm encountered: " << ha;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), thisComponent, CRYPTO_ALG_NOT_SUPPORTED, NULL);
                break;
        }
    }catch(CryptoPP::Exception &) {
        RAISE_CRYPTO_EXCEPTION("Invalid key material for HMAC algorithm", thisComponent, COMMON_INVALID_INPUT, NULL);
    }
    
    return ctx;
}

void CPKIFCryptoPPRaw::HMACUpdate(IPKIFRawCryptContext* ctx, unsigned char* pData, int nDataLen)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::HMACUpdate(IPKIFRawCryptContext* ctx, unsigned char* pData, int nDataLen)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
    //sanity check the inputs: 
    //  hash must not be NULL, must be of a type this class supports and must not be empty
    //  pData MAY be NULL (if not it is assumed to be at least nDataLen bytes)
    //  nDataLen must not be less than zero
    if(NULL == ctx || 0 > nDataLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL input passed to HMACUpdate.");

    //cast the context to the type this class handles.  if the cast fails
    //then the context is not the correct type.
    CPKIFCryptoPPRawContext* ictx = dynamic_cast<CPKIFCryptoPPRawContext*>(ctx);
    if(NULL == ictx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Incorrect context passed to HMACUpdate.");

    if(NULL == ictx->m_hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_EMPTY_HASH_CONTEXT, "Empty context passed to HMACUpdate.");
    if(nDataLen) ictx->m_hashCtx->Update(pData,nDataLen);
}

void CPKIFCryptoPPRaw::HMACFinal(IPKIFRawCryptContext* ctx, unsigned char* pResult, int* pnResultLen)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::HMACFinal(IPKIFRawContext* ctx, unsigned char* pResult, int* pnResultLen)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);

    //sanity check the inputs: 
    //  ctx must not be NULL, must be of a type this class supports and must not be empty
    //  result must not be NULL (it is assumed to be at least *pnResultLen bytes)
    //  pnResultLen must not be NULL and *pnResultLen must not be less than or equal to zero
    if(NULL == ctx || NULL == pResult || NULL == pnResultLen || 0 >= *pnResultLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL input passed to HMACFinal.");

    CPKIFCryptoPPRawContext* hmacCtx = dynamic_cast<CPKIFCryptoPPRawContext*>(ctx);
    if(NULL == hmacCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Incorrect context passed to HMACFinal().");

    if(NULL == hmacCtx->m_hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_EMPTY_HASH_CONTEXT, "Empty context passed to HMACFinal().");
    try {
        if(hmacCtx->m_hashCtx->DigestSize() > boost::numeric_cast<unsigned int, int>(*pnResultLen))
            throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Mismatch between buffer size and hash context passed to HashFinal.");
    }catch( boost::numeric::bad_numeric_cast & ) {
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Comparison error between buffer size and hash context passed to HashFinal.");
    }

    hmacCtx->m_hashCtx->Final(pResult);
    *pnResultLen = hmacCtx->m_hashCtx->DigestSize();
    
}


static bool _Verify(
    const CPKIFKeyMaterial& key,
    unsigned char* pHashData, 
    int nHashDataLen, 
    unsigned char* pSignature, 
    int nSignatureLen,
    PKIFCRYPTO::HASH_ALG hashAlg
    )
{
    LOG_STRING_DEBUG("_Verify(const CPKIFKeyMaterial& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int nSignatureLen)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, NULL);
    CPKIFCryptoPPKeyMaterial * km = 0;
    km = dynamic_cast<CPKIFCryptoPPKeyMaterial *>(const_cast<CPKIFKeyMaterial *>(&key));

    // if the CPKIFKeyMaterial wasn't a CPKIFCryptoPPKeyMaterial, use it to make one.
    // Use a smart pointer to clean it up *only* in the event that it's created here
    CPKIFCryptoPPKeyMaterialPtr kmp;
    if(!km) {
        try {
            kmp = CPKIFCryptoPPKeyMaterialPtr(new CPKIFCryptoPPKeyMaterial(key));
        }catch(CPKIFException &){
            // we'll throw properly in the next block
            kmp = CPKIFCryptoPPKeyMaterialPtr((CPKIFCryptoPPKeyMaterial *)0);
        }
        km = kmp.get();     
    }

    if(!km)
    {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
    }

    CPKIFBufferPtr spkiBuf = km->GetRawSPKI();
    ByteQueue keyReader;
    keyReader.Put(spkiBuf->GetBuffer(), spkiBuf->GetLength());

    PK_Verifier * verifier = 0;
    const CPKIFAlgorithm * alg = km->GetKeyAlg();
    bool isDSA = false;
    switch(alg->AsymkeyAlg()) {
        case PKIFCRYPTO::RSA:
            switch(hashAlg) {
                case PKIFCRYPTO::SHA1:
                    verifier = new RSASS<PKCS1v15,CryptoPP::SHA1>::Verifier(keyReader);
                    break;
                case PKIFCRYPTO::SHA256:
                    verifier = new RSASS<PKCS1v15,CryptoPP::SHA256>::Verifier(keyReader);
                    break;
                case PKIFCRYPTO::SHA384:
                    verifier = new RSASS<PKCS1v15,CryptoPP::SHA384>::Verifier(keyReader);
                    break;
                case PKIFCRYPTO::SHA512:
                    verifier = new RSASS<PKCS1v15,CryptoPP::SHA512>::Verifier(keyReader);
                    break;
                default:
                    throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
                    break;
            }
            break;
        case PKIFCRYPTO::ECC:
            isDSA = true;
            switch(hashAlg) {
                case PKIFCRYPTO::SHA1:
                    verifier = new ECDSA<ECP,CryptoPP::SHA1>::Verifier(keyReader);
                    break;
                case PKIFCRYPTO::SHA256:
                    verifier = new ECDSA<ECP,CryptoPP::SHA256>::Verifier(keyReader);
                    break;
                case PKIFCRYPTO::SHA384:
                    verifier = new ECDSA<ECP,CryptoPP::SHA384>::Verifier(keyReader);
                    break;
                case PKIFCRYPTO::SHA512:
                    verifier = new ECDSA<ECP,CryptoPP::SHA512>::Verifier(keyReader);
                    break;
                default:
                    throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
                    break;
            }
            break;
        case PKIFCRYPTO::DSS:
            // in the case of DSA keys, PKIF needs to keep track of whether (either inherited or explicit)
            // paramters are present, as crypto++ communicates their absence by dereferencing a NULL
            // pointer.
            if(!km->HasParams())
                throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_RAW_IMPORT_FAILED);
            isDSA = true;
            switch(hashAlg) {
                case PKIFCRYPTO::SHA1:
                    verifier = new DSA::Verifier(keyReader);
                    break;
                default:
                    throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
                    break;
            }
            break;
        default:
            throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
            break;
    }
    
    PKIFCryptoPPExternalDigestAccumulator * ed = NewEDAccumulator(pHashData,nHashDataLen);
    if(!isDSA) {
        verifier->InputSignature(*ed,pSignature,nSignatureLen);
    }else{
        // PKIF deals in DER, so assume any incoming signatures are in DER format.
        // Crypto++ wants IEEE P1363.
        size_t targetLen = verifier->SignatureLength();
        unsigned char * converted = new unsigned char[targetLen];
        try {
            targetLen = DSAConvertSignatureFormat(converted,targetLen,DSA_P1363,pSignature,nSignatureLen,DSA_DER);
        }catch(BERDecodeErr &){
            // if this throws, let crypto++ assume it's IEEE P1363 and try the verification anyway
            delete[] converted;
            converted = 0;
        }
        if(converted) {
            verifier->InputSignature(*ed,converted,targetLen);
            delete[] converted;
            converted = 0;
        } else {
            verifier->InputSignature(*ed,pSignature,nSignatureLen);
        }
    }
    bool verified = verifier->Verify(ed);
    delete verifier;
    return verified;
}
bool CPKIFCryptoPPRaw::VerifyCertificate(
    const CPKIFCertificate& issCert, 
    const CPKIFCertificate& subCert)
{
    CPKIFCryptoPPKeyMaterial issKey(issCert);

    // crypto++ doesn't really know anything about certificates, so the tbsCertificate must
    // be manually extracted. it may be worth adding a function to the certificate class to retrieve that
    CPKIFBufferPtr tbsCertificate = GetTBSCertSequence(subCert);
    CPKIFAlgorithm * sigAlg = CPKIFAlgorithm::GetAlg(subCert.SignatureAlgorithm()->oid());
    if(!sigAlg) {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
    }
    IPKIFHashContext * dig = HashInit(sigAlg->HashAlg());
    boost::shared_ptr<IPKIFHashContext> digPtr(dig);
    HashUpdate(digPtr.get(),const_cast<unsigned char *>(tbsCertificate->GetBuffer()),tbsCertificate->GetLength());
    int hashLen = CPKIFAlgorithm::GetAlg(sigAlg->HashAlg())->DigestSize();
    unsigned char * hashVal = new unsigned char[hashLen];
    // stuffing this into a smart pointer in case something below throws
    CPKIFBufferPtr hashBuf(new CPKIFBuffer(true,hashVal,hashLen));
    HashFinal(digPtr.get(),hashVal,&hashLen);
    CPKIFBufferPtr sigBuf = subCert.Signature();
    return _Verify(issKey,hashVal,hashLen,const_cast<unsigned char *>(sigBuf->GetBuffer()),sigBuf->GetLength(),
        sigAlg->HashAlg());
}

bool VerifyCertificateWithCryptoPP(CPKIFSubjectPublicKeyInfoPtr& spki, const CPKIFCertificate& subCert)
{
    CPKIFCryptoPPKeyMaterial issKey(spki);

    // crypto++ doesn't really know anything about certificates, so the tbsCertificate must
    // be manually extracted. it may be worth adding a function to the certificate class to retrieve that
    CPKIFBufferPtr tbsCertificate = GetTBSCertSequence(subCert);
    CPKIFAlgorithm * sigAlg = CPKIFAlgorithm::GetAlg(subCert.SignatureAlgorithm()->oid());
    if(!sigAlg) {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);
    }

    IPKIFCryptoMisc* cm = GetPlatformCryptoMisc();

    IPKIFHashContext * dig = cm->HashInit(sigAlg->HashAlg());
    boost::shared_ptr<IPKIFHashContext> digPtr(dig);
    cm->HashUpdate(digPtr.get(),const_cast<unsigned char *>(tbsCertificate->GetBuffer()),tbsCertificate->GetLength());
    int hashLen = CPKIFAlgorithm::GetAlg(sigAlg->HashAlg())->DigestSize();
    unsigned char * hashVal = new unsigned char[hashLen];
    // stuffing this into a smart pointer in case something below throws
    CPKIFBufferPtr hashBuf(new CPKIFBuffer(true,hashVal,hashLen));
    cm->HashFinal(digPtr.get(),hashVal,&hashLen);
    CPKIFBufferPtr sigBuf = subCert.Signature();
    return _Verify(issKey,hashVal,hashLen,const_cast<unsigned char *>(sigBuf->GetBuffer()),sigBuf->GetLength(),
        sigAlg->HashAlg());
}

bool CPKIFCryptoPPRaw::Verify(
    const CPKIFKeyMaterial& key,
    unsigned char* pHashData, 
    int nHashDataLen, 
    unsigned char* pSignature, 
    int nSignatureLen,
    PKIFCRYPTO::HASH_ALG hashAlg)
{
    //no state 
    return _Verify(key, pHashData, nHashDataLen, pSignature, nSignatureLen, hashAlg);
}
void CPKIFCryptoPPRaw::GenRandom(
    unsigned char* buf,
    int len)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::GenRandom(unsigned char* buf, int len)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);

    if(NULL == buf || 0 == len)
        return; //no need to raise an exception.  the caller asks for nothing and received nothing.

    if(len && !buf)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL output buffer passed to GenRandom.");
        
    // XXX Should this be autoconf'd to allow usage with a manually seeded RNG?
    AutoSeededRandomPool rng;
    rng.GenerateBlock(buf,len);
    
}
IPKIFHashContext* CPKIFCryptoPPRaw::HashInit(
    PKIFCRYPTO::HASH_ALG alg)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::HashInit(HASH_ALG alg)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
    
    //create a hash context object and populate it with context and hash objects
    //throw bad_alloc; nothing to clean up in this function
    CPKIFCryptoPPRawContext* hashCtx = new CPKIFCryptoPPRawContext();
    switch(alg)
    {
    case PKIFCRYPTO::SHA1:
        hashCtx->m_hashCtx = new CryptoPP::SHA1();
        break;
#ifndef FIPS_MODE
    case PKIFCRYPTO::MD5:
        hashCtx->m_hashCtx = new CryptoPP::Weak::MD5();
        break;
#endif
    case PKIFCRYPTO::SHA224:
        hashCtx->m_hashCtx = new CryptoPP::SHA224();
        break;
    case PKIFCRYPTO::SHA256:
        hashCtx->m_hashCtx = new CryptoPP::SHA256();
        break;
    case PKIFCRYPTO::SHA384:
        hashCtx->m_hashCtx = new CryptoPP::SHA384();
        break;
    case PKIFCRYPTO::SHA512:
        hashCtx->m_hashCtx = new CryptoPP::SHA512();
        break;
    default:
        std::ostringstream os;
        os << "Unsupported hash algorithm encountered: " << alg;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), thisComponent, CRYPTO_ALG_NOT_SUPPORTED, NULL);
    }
    return hashCtx;
}
void CPKIFCryptoPPRaw::HashUpdate(
    IPKIFHashContext* hash, 
    unsigned char* pData, 
    int nDataLen)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::HashUpdate(IPKIFHashContext* hash, unsigned char* pData, int nDataLen)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);
    //sanity check the inputs: 
    //  hash must not be NULL, must be of a type this class supports and must not be empty
    //  pData MAY be NULL (if not it is assumed to be at least nDataLen bytes)
    //  nDataLen must not be less than zero
    if(0 == hash || 0 > nDataLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL input passed to HashUpdate.");

    //cast the hash context to the type this class handles.  if the cast fails
    //then the context is not the correct type.
    CPKIFCryptoPPRawContext* hashCtx = dynamic_cast<CPKIFCryptoPPRawContext*>(hash);
    if(0 == hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Incorrect hash context passed to HashUpdate.");

    if(0 == hashCtx->m_hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_EMPTY_HASH_CONTEXT, "Empty hash context passed to HashUpdate.");
    
    hashCtx->m_hashCtx->Update(pData, nDataLen);
    
}
void CPKIFCryptoPPRaw::HashFinal(
    IPKIFHashContext* hash,
    unsigned char* pResult, 
    int* pnResultLen)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::HashFinal(IPKIFHashContext* hash, unsigned char* pResult, int* pnResultLen)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);

    //sanity check the inputs: 
    //  hash must not be NULL, must be of a type this class supports and must not be empty
    //  result must not be NULL (it is assumed to be at least *pnResultLen bytes)
    //  pnResultLen must not be NULL and *pnResultLen must not be less than or equal to zero
    if(NULL == hash || NULL == pResult || NULL == pnResultLen || 0 >= *pnResultLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL input passed to HashFinal.");

    CPKIFCryptoPPRawContext* hashCtx = dynamic_cast<CPKIFCryptoPPRawContext*>(hash);
    if(NULL == hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Incorrect hash context passed to HashFinal.");

    if(NULL == hashCtx->m_hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_EMPTY_HASH_CONTEXT, "Empty hash context passed to HashUpdate.");
    try {   
        if(hashCtx->m_hashCtx->DigestSize() > boost::numeric_cast<unsigned int,int>(*pnResultLen))
            throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Mismatch between buffer size and hash context passed to HashFinal.");
    }catch( boost::numeric::bad_numeric_cast & ) {
        throw CPKIFCryptoException(thisComponent, PKIFCRYPTOPP_INCORRECT_HASH_CONTEXT, "Comparison error between buffer size and hash context passed to HashFinal.");
    }

    hashCtx->m_hashCtx->Final(pResult);
    *pnResultLen = hashCtx->m_hashCtx->DigestSize();
}

IPKIFRawCryptContext* CPKIFCryptoPPRaw::CryptInit(
    const CPKIFKeyMaterial& key,
    bool pad)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw::CryptInit(const CPKIFKeyMaterial& key)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, this);

    // the iterative crypt functions are a bad idea with RSA or DSA keys...
    if(!key.ContainsSymmetricKeyMaterial()) {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, "CryptInit() only makes sense for symmetric keys.");   
    }
    // don't even allocate a context if the parameters are wrong
    if(key.GetMode() == PKIFCRYPTO::CBC && NULL == key.GetIV()) {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, CRYPTO_MISSING_IV);
    }

    switch(key.GetSymmetricKeyAlgorithm()) {
        case PKIFCRYPTO::AES:
        case PKIFCRYPTO::AES128:
        case PKIFCRYPTO::AES192:
        case PKIFCRYPTO::AES256:
            break;
        default:
            throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_UNSUPPORTED_ALG);  
    }

    // throw bad_alloc... nothing to cleanup
    CPKIFCryptoPPRawContext * ctx = new CPKIFCryptoPPRawContext();
    //ctx->m_symKey = const_cast<CPKIFKeyMaterial *>(key);
    ctx->m_keyLen = key.GetSymmetricKeyLength();
    ctx->m_rawKey = new unsigned char[ctx->m_keyLen];
    memcpy(ctx->m_rawKey, key.GetSymmetricKey(), ctx->m_keyLen);
    if(NULL != key.GetIV())
    {
        ctx->m_ivLen = CPKIFAlgorithm::GetAlg(key.GetSymmetricKeyAlgorithm())->BlockSize();
        ctx->m_iv = new unsigned char[ctx->m_ivLen];
        memcpy(ctx->m_iv, key.GetIV(), ctx->m_ivLen);
    }
    ctx->m_keyMode = key.GetMode();
    ctx->m_keyAlgorithm = key.GetSymmetricKeyAlgorithm();


    ctx->m_bNeedsPad = pad;
    // nothing much else can be done to prepare the context here; need to wait until it's known whether
    // we're encrypting or decrypting

    return ctx;
}
void CPKIFCryptoPPRaw::Decrypt(
    IPKIFRawCryptContext* cryptContext, 
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult,
    int* pnResultLen, 
    bool final)
{
    CryptFunc<false>(cryptContext, pData, nDataLen, pResult, pnResultLen, final);
}
void CPKIFCryptoPPRaw::Encrypt(
    IPKIFRawCryptContext* cryptContext, 
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool final)
{
    CryptFunc<true>(cryptContext, pData, nDataLen, pResult, pnResultLen, final);
}
template <bool _CryptDirection>
void CPKIFCryptoPPRaw::CryptFunc(
    IPKIFRawCryptContext* cryptContext,
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool final)
{
    LOG_STRING_DEBUG("CPKIFCryptoPPRaw CryptFunc(IPKIFRawCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final)", TOOLKIT_CRYPTO_CRYPTOPPRAW, 0, NULL);

    CPKIFCryptoPPRawContext* icc = dynamic_cast<CPKIFCryptoPPRawContext*>(cryptContext);
    if(!icc)
    { 
        RAISE_CRYPTO_EXCEPTION("CPKIFCryptoPPRaw CryptFunc called with an invalid context.", TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, NULL);
    }
    // the context couldn't be established by init without knowing the direction,
    // so the first call needs to set that up
    if(!icc->m_ctx)
    {
        SymmetricCipher * cipher = 0;
        int keyLen = icc->m_keyLen;
        const unsigned char * rawKey = icc->m_rawKey;
        int ivLen = CPKIFAlgorithm::GetAlg(icc->m_keyAlgorithm)->BlockSize();
        const unsigned char * iv = icc->m_iv;
        
        switch(icc->m_keyAlgorithm) {
            case PKIFCRYPTO::AES:
            case PKIFCRYPTO::AES128:
            case PKIFCRYPTO::AES192:
            case PKIFCRYPTO::AES256:
                try {
                    switch(icc->m_keyMode) {
                        case PKIFCRYPTO::CBC:
                            if(_CryptDirection){
                                cipher = new CBC_Mode<CryptoPP::AES>::Encryption(rawKey,keyLen,iv);
                            } else {
                                cipher = new CBC_Mode<CryptoPP::AES>::Decryption(rawKey,keyLen,iv);
                            }
                            break;
                        case PKIFCRYPTO::ECB:
                            if(_CryptDirection){
                                cipher = new ECB_Mode<CryptoPP::AES>::Encryption(rawKey,keyLen);
                            } else {
                                cipher = new ECB_Mode<CryptoPP::AES>::Decryption(rawKey,keyLen);
                            }
                            break;
                        case PKIFCRYPTO::CTR:
                            if(_CryptDirection){
                                cipher = new CTR_Mode<CryptoPP::AES>::Encryption(rawKey,keyLen,iv);
                            } else {
                                cipher = new CTR_Mode<CryptoPP::AES>::Decryption(rawKey,keyLen,iv);
                            }
                            break;
                        default:
                            RAISE_CRYPTO_EXCEPTION("CPKIFCryptoPPRaw CryptFunc called with an invalid context.", TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, NULL);
                            break;
                    }
                }catch(CryptoPP::Exception &) {
                    RAISE_CRYPTO_EXCEPTION("Crypto++ key material did not match cipher and mode",TOOLKIT_CRYPTO_CRYPTOPPRAW,COMMON_INVALID_INPUT, NULL);
                }catch(CPKIFException &) {
                    throw;
                }catch(...){
                    RAISE_CRYPTO_EXCEPTION("Unknown error setting up crypto context. Most likely improperly initialized key material.",
                        TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, NULL);
                }
                break;
            default:
                RAISE_CRYPTO_EXCEPTION("CPKIFCryptoPPRaw CryptFunc called with an invalid context.", TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, NULL);
                break;

        }
        // the StreamTransformationFilter should pad as needed but do no harm if not needed.
        icc->m_ctx = new StreamTransformationFilter(*cipher, new ByteQueue(),
            icc->m_bNeedsPad ?  CryptoPP::StreamTransformationFilter::DEFAULT_PADDING : 
                                CryptoPP::StreamTransformationFilter::NO_PADDING);
    }
    try {
        if(nDataLen > 0) {
            icc->m_ctx->Put(pData,nDataLen);
        }
        if(final) {
            icc->m_ctx->MessageEnd();
        }
    }catch(CryptoPP::Exception & e){
        // any crypto++ exception here would generally be due to a bad ciphertext.
        RAISE_CRYPTO_EXCEPTION(e.what(),TOOLKIT_CRYPTO_CRYPTOPPRAW,COMMON_INVALID_INPUT,NULL);
    }
    ByteQueue * outTrans = dynamic_cast<ByteQueue *>(icc->m_ctx->AttachedTransformation());
    // XXX This should be OK since the buffer size came in via an int. We may want to
    // use one of the boost checked casts here just the same.
    int avail = static_cast<int>(outTrans->MaxRetrievable());
    if(avail > 0) {
        outTrans->Get(pResult,*pnResultLen);
        if(*pnResultLen > avail) *pnResultLen = avail;
        if(final && outTrans->MaxRetrievable() > 0)
            RAISE_CRYPTO_EXCEPTION("CPKIFCryptoPPRaw CryptFunc (finalize) called with a buffer that's too small for the output.",
            TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_INVALID_INPUT, NULL);
    }
}

template<bool _CryptDirection>
void _ASymCrypt(
    const CPKIFKeyMaterial& key, 
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool pad)
{
    throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, COMMON_NOT_IMPLEMENTED, "The crypto++ raw colleague does not currently support asymmetric encryption operations.");
}