PKIFCNGCAPIRaw.cpp

Go to the documentation of this file.

#include "PKIFCNGCAPIRaw.h"
#include "PKIFCAPICryptContext2.h"
#include "PKIFCAPIHashContext.h"
#include "CAPIUtils.h"

#include "PKIFCryptoException.h"
#include "PKIFKeyMaterial.h"
#include "PKIFCryptoErrors.h"
#include "PKIFCAPIErrors.h"
#include "CAPIRawCryptContext.h"
#include "Buffer.h"

#include "AlgorithmIdentifier.h"
#include "Certificate.h"
#include "ToolkitUtils.h"
#include "components.h"
#include "PKIFException.h"

#include "SubjectPublicKeyInfo.h"

#include "ASN1Helper.h"
#include "PKIX1Algorithms88.h"

#include <iostream>
#include <sstream>

#include "PKIFCNGUtils.h"
#include "PKIFBCryptPublicKey.h"
// for DSA format conversion from crypto++
#include "dsa.h"

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

using boost::numeric_cast;
using boost::bad_numeric_cast;

using namespace std;

#ifndef STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED            ((NTSTATUS)0xC00000BBL)
#endif
#ifndef STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL         ((NTSTATUS)0xC0000023L)
#endif

//CAC_API char g_defCACCAPITrustStore[] = "Root";

#define NT_SUCCESS(Status)          (((NTSTATUS)(Status)) >= 0)
#define STATUS_UNSUCCESSFUL         ((NTSTATUS)0xC0000001L)

struct CPKIFCNGCAPIRawImpl
{

    CPKIFCNGCAPIRaw* m_parent;
    CPKIFCNGCAPIRawImpl ()
    {
        m_parent = NULL;
    }
    CPKIFCNGCAPIRawImpl (CPKIFCNGCAPIRaw  *p) 
    {
        m_parent = p;
    }
    HCRYPTPROV m_hProv;
    HCRYPTKEY m_hPubPrivKey;

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

    template <bool _CryptDirection>
    void CryptFunc(IPKIFRawCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final);

};

CPKIFCNGCAPIRaw::CPKIFCNGCAPIRaw(void)
    :m_impl (new CPKIFCNGCAPIRawImpl)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::CPKIFCNGCAPIRaw(void)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    m_impl->m_parent = this;
    m_impl->m_hProv = NULL;
    m_impl->m_hPubPrivKey = NULL;
}
CPKIFCNGCAPIRaw::~CPKIFCNGCAPIRaw(void)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::~CPKIFCNGCAPIRaw(void)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    if(NULL != m_impl->m_hPubPrivKey)
    {
        BOOL succ = CryptDestroyKey(m_impl->m_hPubPrivKey);
        m_impl->m_hPubPrivKey = NULL;
    }
    if(NULL != m_impl->m_hProv)
    {
        BOOL succ = CryptReleaseContext(m_impl->m_hProv, 0);
        m_impl->m_hProv = NULL;
    }
    delete m_impl;
    m_impl = NULL;
}
void CPKIFCNGCAPIRaw::Initialize()
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::Initialize()", TOOLKIT_CRYPTO_CAPIRAW, 0, this);
}

LPCWSTR GetCNGSymAlgorithm(
    const CPKIFKeyMaterial& key)
{
    switch(key.GetSymmetricKeyAlgorithm())
    {
    case PKIFCRYPTO::DES:
        return BCRYPT_DES_ALGORITHM;
    case PKIFCRYPTO::TDES:
        return BCRYPT_3DES_ALGORITHM;
    case PKIFCRYPTO::AES:
    case PKIFCRYPTO::AES128:
    case PKIFCRYPTO::AES192:
    case PKIFCRYPTO::AES256:
        return BCRYPT_AES_ALGORITHM;
    default:
        RAISE_CRYPTO_EXCEPTION("", TOOLKIT_CRYPTO, CRYPTO_ALG_NOT_SUPPORTED, NULL)
    }
}

bool CPKIFCNGCAPIRaw::SupportsAlgorithm(
    const CPKIFKeyMaterial& key)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::SupportsAlgorithm(const CPKIFKeyMaterial& key)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    if(key.ContainsSymmetricKeyMaterial())
    {   
        try
        {
            GetCNGSymAlgorithm(key);
            return true;
        }
        catch(CPKIFCryptoException& e)
        {
            if(CRYPTO_ALG_NOT_SUPPORTED == e.GetErrorCode())
            {
                
                //The GetSymAlgorithm function throws upon failure but
                //this function should return false.
                return false;
            } else {
                throw e; //should never happen
            }
        }
    }
    else if(key.ContainsCertificate())
    {
        try
        {
            CPKIFCertificatePtr pkifCert(new CPKIFCertificate());
            pkifCert->Decode(key.GetCertificate(),key.GetCertificateLength());
            CPKIFSubjectPublicKeyInfoPtr spki = pkifCert->GetSubjectPublicKeyInfo();
            // this really shouldn't happen. it'll throw elsewhere, though
            if(!spki) return false;
            switch(GetAlgClass(spki->alg()))
            {
            case RSA_CLASS:
            case DSA_CLASS:
            case ECDSA_CLASS:
                return true;
                break;
            default:
                return false;
                break;
            }
        }
        catch(CPKIFException&)
        {
            // if there's an exception here, it'll be a decoding error that
            // will throw elsewhere. just return false here.
            return false;
        }
    } else  {
        RAISE_CRYPTO_EXCEPTION("key parameter contents not recognized.", thisComponent, COMMON_INVALID_INPUT, this);
    }
}
void CPKIFCNGCAPIRaw::Sign(
    const CPKIFKeyMaterial& key,
    unsigned char* pHashData,
    int nHashDataLen,
    unsigned char* pSignature,
    int* nSignatureLen,
    PKIFCRYPTO::HASH_ALG hashAlg
    )
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::Sign(const CPKIFKeyMaterial& key,...)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);
    // only the stored key material colleague signs.
    RAISE_CRYPTO_EXCEPTION("Signing operations are not implemented for raw key material.", thisComponent, COMMON_NOT_IMPLEMENTED, this);
}

template <bool _CryptDirection>
void CPKIFCNGCAPIRawImpl::AsymCrypt(
    const CPKIFKeyMaterial& key,
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool pad)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRawImpl::AsymCrypt(const CPKIFKeyMaterial& key, ...)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);
    
    CPKIFBCryptPublicKey capiKey;
    BCRYPT_KEY_HANDLE hKey = capiKey.Initialize(key);
    DWORD paddingFlags = 0;
    if(RSA_CLASS == GetAlgClass(capiKey.GetAlgId()))
    {
        paddingFlags = BCRYPT_PAD_PKCS1;
    }// else throw? none of the other algs really support integrated encryption anyway

    int maxOut = *pnResultLen;
    *pnResultLen = nDataLen;
    int err = 0;
    memcpy(pResult, pData, nDataLen);
    
    pkif_byte_array iv(0);
    int ivLen;
    key.GetIV(NULL,&ivLen);
    // Currently supported  encryption schemes don't support IVs for asymmetric keys,
    // so this should really be a no-op
    if(ivLen) {
        iv.reset(new unsigned char[ivLen]);
        key.GetIV(iv,&ivLen);
    }

    NTSTATUS ntrv = 0L;
    if(_CryptDirection)
    {
        DWORD cbCipherText = 0;
        if(!NT_SUCCESS(ntrv = BCryptEncrypt(hKey,pData,nDataLen,NULL,iv,ivLen,
                                        NULL,0,&cbCipherText,paddingFlags)))
        {
            std::ostringstream os;
            os << "BCryptEncrypt failed: (" << GetLastError() << ")" << "NT status code " << ntrv;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
        }

        pkif_byte_array pbCipherText(new unsigned char[cbCipherText]);
        DWORD cbCTOut = 0;
        if(!NT_SUCCESS(ntrv = BCryptEncrypt(hKey,pData,nDataLen,NULL,iv,ivLen,
                                        pbCipherText,cbCipherText,&cbCTOut,paddingFlags)))
        {
            std::ostringstream os;
            os << "BCryptEncrypt failed: (" << GetLastError() << ")" << "NT status code " << ntrv;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
        }

        memcpy(pResult, pbCipherText.get(), cbCTOut);
        *pnResultLen = cbCTOut;
    }
    else
    {
        DWORD cbPlainText = 0;
        if(!NT_SUCCESS(ntrv = BCryptDecrypt(hKey,pData,nDataLen,NULL,iv,ivLen,
                                        NULL,0,&cbPlainText,paddingFlags)))
        {
            std::ostringstream os;
            os << "BCryptDecrypt failed: (" << GetLastError() << ")" << "NT status code " << ntrv;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
        }

        pkif_byte_array pbPlainText(new unsigned char[cbPlainText]);
        DWORD cbPTOut = 0;
        if(!NT_SUCCESS(ntrv = BCryptEncrypt(hKey,pData,nDataLen,NULL,iv,ivLen,
                                        pbPlainText,cbPlainText,&cbPTOut,paddingFlags)))
        {
            std::ostringstream os;
            os << "BCryptDecrypt failed: (" << GetLastError() << ")" << "NT status code " << ntrv;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
        }

        memcpy(pResult, pbPlainText.get(), cbPTOut);
        *pnResultLen = cbPTOut;
    }


}
void CPKIFCNGCAPIRaw::Decrypt(
    const CPKIFKeyMaterial& key, 
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult,
    int* pnResultLen, 
    bool pad)
{
    if(key.ContainsSymmetricKeyMaterial()) {
        // Encrypt() can throw
        std::auto_ptr<CPKIFCAPIRawCryptContext> ctx(
            static_cast<CPKIFCAPIRawCryptContext *>(this->CryptInit(key,pad))
            );
        Decrypt(ctx.get(),pData,nDataLen,pResult,pnResultLen,true);
    } else {
        m_impl->AsymCrypt<false>(key, pData, nDataLen, pResult, pnResultLen, pad);
    }
}
void CPKIFCNGCAPIRaw::Encrypt(
    const CPKIFKeyMaterial& key,
    unsigned char* pData,
    int nDataLen,
    unsigned char* pResult,
    int* pnResultLen,
    bool pad)
{
    if(key.ContainsSymmetricKeyMaterial()) {
        // Encrypt() can throw
        std::auto_ptr<CPKIFCAPIRawCryptContext> ctx(
            static_cast<CPKIFCAPIRawCryptContext *>(this->CryptInit(key,pad))
            );
        Encrypt(ctx.get(),pData,nDataLen,pResult,pnResultLen,true);
    } else {
        m_impl->AsymCrypt<true>(key, pData, nDataLen, pResult, pnResultLen, pad);
    }
}

bool _CNGVerify(
    const CPKIFKeyMaterial& key,
    unsigned char* pHashData,
    int nHashDataLen,
    unsigned char* pSignature,
    int nSignatureLen,
    PKIFCRYPTO::HASH_ALG ha
    )
{
    LOG_STRING_DEBUG("_CNGVerify(const CPKIFKeyMaterial& key, unsigned char* pHashData, int nHashDataLen, unsigned char* pSignature, int nSignatureLen)", TOOLKIT_CRYPTO_CAPIRAW, 0, NULL);

    DWORD hashLen = 0;
    SECURITY_STATUS cngStatus = ERROR_SUCCESS;
    NTSTATUS ntrv = 0L;
    BCRYPT_PKCS1_PADDING_INFO   PKCS1PaddingInfo= {0};


    CPKIFBCryptPublicKey bcKeyWrapper;
    BCRYPT_KEY_HANDLE bcKey = bcKeyWrapper.Initialize(key);


    switch(ha)
    {
    case PKIFCRYPTO::SHA1:
        PKCS1PaddingInfo.pszAlgId = BCRYPT_SHA1_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA256:
        PKCS1PaddingInfo.pszAlgId = BCRYPT_SHA256_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA384:
        PKCS1PaddingInfo.pszAlgId = BCRYPT_SHA384_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA512:
        PKCS1PaddingInfo.pszAlgId = BCRYPT_SHA512_ALGORITHM;
        break;
    default:
        std::ostringstream os;
        os << "Unsupported hash algorithm encountered: " << ha;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, CRYPTO_ALG_NOT_SUPPORTED, NULL);
    }

    BCRYPT_PKCS1_PADDING_INFO * pi = 0;
    DWORD pflags = 0;
    unsigned char * pSigToVerify = pSignature;
    DWORD nFinalSigLen = nSignatureLen;

    // if this is an RSA signature, need to set those properly.
    // if it's not an RSA signature, CNG gets angry if you do :-/
    DWORD algPropSize = 0;
    if(!NT_SUCCESS(ntrv = BCryptGetProperty(bcKey,BCRYPT_ALGORITHM_NAME,NULL,0,&algPropSize,0)))
    {
        std::ostringstream os;
        os << "Unable to obtain signature algorithm group for key material :(" 
            << GetLastError() << ")" << "(NTSTATUS code " << ntrv << ")" << endl;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(),TOOLKIT_CRYPTO, CRYPTO_ALG_NOT_SUPPORTED, NULL);
    }
    pkif_byte_array algName(new unsigned char[algPropSize]);
    memset(algName,0x00,algPropSize);
    if(!NT_SUCCESS(ntrv = BCryptGetProperty(bcKey,BCRYPT_ALGORITHM_NAME,algName,algPropSize,&algPropSize,0)))
    {
        std::ostringstream os;
        os << "Unable to obtain signature algorithm group for key material :(" 
            << GetLastError() << ")" << "(NTSTATUS code " << ntrv << ")" << endl;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(),TOOLKIT_CRYPTO, CRYPTO_ALG_NOT_SUPPORTED, NULL);
    }
    pkif_byte_array converted(0);
    if(0 == wcscmp(BCRYPT_RSA_ALGORITHM,(wchar_t *)algName.get()))
    {
        pi = &PKCS1PaddingInfo;
        pflags = BCRYPT_PAD_PKCS1;
    }
    else // ECDSA or DSA... should probably do a better check than "!RSA" here
    {
        DWORD dssSigLen,dssSigLenLen;
        if(FAILED(cngStatus = BCryptGetProperty(bcKey,
                                                BCRYPT_SIGNATURE_LENGTH,
                                                (unsigned char *)&dssSigLen,
                                                sizeof(DWORD),
                                                &dssSigLenLen,
                                                0)))
        {
            RAISE_CRYPTO_EXCEPTION("Unable to obtain signature length for key", TOOLKIT_CRYPTO, CRYPTO_ALG_NOT_SUPPORTED, NULL);
        }
        size_t targetLen = dssSigLen;
        converted.reset(new unsigned char[targetLen]);
        try {
            targetLen = CryptoPP::DSAConvertSignatureFormat(converted,targetLen,CryptoPP::DSA_P1363,pSignature,nSignatureLen,CryptoPP::DSA_DER);
        }catch(CryptoPP::BERDecodeErr &){
            // if this throws, assume the format's OK and try the verification anyway
            converted.clear();
        }
        if(converted.get() != 0) {
            pSigToVerify = converted.get();
            nFinalSigLen = (DWORD)targetLen;
        }

    }
    

    if(!NT_SUCCESS(ntrv = BCryptVerifySignature(bcKey,pi,pHashData,nHashDataLen,
                        pSigToVerify,nFinalSigLen,pflags)))
    {
        return false;
    }


    return true;
}
bool CPKIFCNGCAPIRaw::VerifyCertificate(
    const CPKIFCertificate& issCert,
    const CPKIFCertificate& subCert)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::VerifyCertificate(const CPKIFCertificate& issCert, const CPKIFCertificate& subCert)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    CPKIFBufferPtr issBuf = issCert.Encoded();
    CPKIFBufferPtr subBuf = subCert.Encoded();

    PCCERT_CONTEXT issCtx = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
        issBuf->GetBuffer(), issBuf->GetLength());
//  PCCERT_CONTEXT subCtx = CertCreateCertificateContext(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
//      subBuf->GetBuffer(), subBuf->GetLength());

    int err = 0;
    BOOL b = CryptVerifyCertificateSignature(NULL,X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
        subBuf->GetBuffer(), subBuf->GetLength(), &issCtx->pCertInfo->SubjectPublicKeyInfo);
    if(!b)
    {
        err = GetLastError();
    }

    CertFreeCertificateContext(issCtx);
//  CertFreeCertificateContext(subCtx);

    return TRUE == b;
}

//support RSA w/ SHA1 (DSS and MD5)
bool CPKIFCNGCAPIRaw::Verify(
    const CPKIFKeyMaterial& key,
    unsigned char* pHashData, 
    int nHashDataLen,
    unsigned char* pSignature,
    int nSignatureLen,
    PKIFCRYPTO::HASH_ALG hashAlg
    )
{
    //no state 
    return _CNGVerify(key, pHashData, nHashDataLen, pSignature, nSignatureLen,hashAlg);
}
void CPKIFCNGCAPIRaw::GenRandom(
    unsigned char* buf, 
    int len)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::GenRandom(unsigned char* buf, int len)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    BCRYPT_ALG_HANDLE_PKIF       hRandomAlg(NULL);
    NTSTATUS ntrv = 0L;

    if(!NT_SUCCESS(ntrv = BCryptOpenAlgorithmProvider(&hRandomAlg,BCRYPT_RNG_ALGORITHM,
                                                NULL,0)))
    {
        std::ostringstream os;
        os << "BCryptOpenAlgorithmProvider failed: (" << GetLastError() <<") NT Status: " << ntrv;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), thisComponent, PKIFCAPI_ACQUIRE_CONTEXT_FAILED, NULL);
    }

    if (!NT_SUCCESS(ntrv = BCryptGenRandom(hRandomAlg,buf,len,0)))
    {
        std::ostringstream os;
        os << "BCryptGenRandom failed: (" << GetLastError() <<") NT Status: " << ntrv;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), thisComponent, PKIFCAPI_GEN_RANDOM_FAILED, NULL);

    }
}
IPKIFHashContext* CPKIFCNGCAPIRaw::HashInit(
    PKIFCRYPTO::HASH_ALG alg)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::HashInit(HASH_ALG alg)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    //support SHA1 (MD5)
    wchar_t* hashAlg;
    switch(alg)
    {
    case PKIFCRYPTO::SHA1:
        hashAlg = BCRYPT_SHA1_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA256:
        hashAlg = BCRYPT_SHA256_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA384:
        hashAlg = BCRYPT_SHA384_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA512:
        hashAlg = BCRYPT_SHA512_ALGORITHM;
        break;
    default:
        std::ostringstream os;
        os << "Unsupported hash algorithm encountered: " << alg;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), thisComponent, CRYPTO_ALG_NOT_SUPPORTED, NULL);
    }

    //create a hash context object and populate it with context and hash objects
    //throw bad_alloc; nothing to clean up in this function
    CPKIFCAPIHashContext* hashCtx = new CPKIFCAPIHashContext();
    NTSTATUS                status          = STATUS_UNSUCCESSFUL;
    DWORD                   cbData          = 0,
                            cbHash          = 0,
                            cbHashObject    = 0;
    PBYTE                   pbHash          = NULL;

    //open an algorithm handle
    if(!NT_SUCCESS(status = BCryptOpenAlgorithmProvider(
                                            &hashCtx->m_hHashAlg,
                                            GetCNGHashAlg((PKIFCRYPTO::HASH_ALG)alg),
                                            NULL,0)))
    {

        std::ostringstream os;
        os << "CryptCreateHash failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //calculate the size of the buffer to hold the hash object
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hashCtx->m_hHashAlg, 
                                        BCRYPT_OBJECT_LENGTH, 
                                        (PBYTE)&cbHashObject, 
                                        sizeof(DWORD), 
                                        &cbData, 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptGetProperty failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //allocate the hash object on the heap
    hashCtx->m_pbHashObject = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbHashObject);
    if(NULL == hashCtx->m_pbHashObject)
    {
        std::ostringstream os;
        os << "Memory allocation failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //calculate the length of the hash
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hashCtx->m_hHashAlg, 
                                        BCRYPT_HASH_LENGTH, 
                                        (PBYTE)&cbHash, 
                                        sizeof(DWORD), 
                                        &cbData, 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptGetProperty failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //create a hash
    if(!NT_SUCCESS(status = BCryptCreateHash(
                                        hashCtx->m_hHashAlg, 
                                        &hashCtx->m_cngHashHandle, 
                                        hashCtx->m_pbHashObject, 
                                        cbHashObject, 
                                        NULL, 
                                        0, 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptCreateHash failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    return hashCtx;
}
void CPKIFCNGCAPIRaw::HashUpdate(
    IPKIFHashContext* hash, 
    unsigned char* pData, 
    int nDataLen)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::HashUpdate(IPKIFHashContext* hash, unsigned char* pData, int nDataLen)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    NTSTATUS                status          = STATUS_UNSUCCESSFUL;

    //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 == hash/* || NULL == pData || 0 >= nDataLen*/ || 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.
    CPKIFCAPIHashContext* hashCtx = dynamic_cast<CPKIFCAPIHashContext*>(hash);
    if(NULL == hashCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCAPI_INCORRECT_HASH_CONTEXT, "Incorrect hash context passed to HashUpdate.");

    if(NULL == hashCtx->m_cngHashHandle)
        throw CPKIFCryptoException(thisComponent, PKIFCAPI_EMPTY_HASH_CONTEXT, "Empty hash context passed to HashUpdate.");

    //hash some data
    if(!NT_SUCCESS(status = BCryptHashData(
                                        hashCtx->m_cngHashHandle,
                                        (PBYTE)pData,
                                        nDataLen,
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptHashData failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }
}
void CPKIFCNGCAPIRaw::HashFinal(
    IPKIFHashContext* hash,
    unsigned char* pResult, 
    int* pnResultLen)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::HashFinal(IPKIFHashContext* hash, unsigned char* pResult, int* pnResultLen)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    NTSTATUS                status          = STATUS_UNSUCCESSFUL;

    //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.");

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

    if(NULL == hashCtx->m_cngHashHandle)
        throw CPKIFCryptoException(thisComponent, PKIFCAPI_EMPTY_HASH_CONTEXT, "Empty hash context passed to HashUpdate.");

    DWORD digestLen = 0, maxOutLen = 0;
    try {
        maxOutLen = boost::numeric_cast<DWORD,int>(*pnResultLen);
    } catch(...) {
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "Invalid output buffer length passed to HashFinal.");
    }
    unsigned long digestLenLen = 0;
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hashCtx->m_cngHashHandle,
                                        BCRYPT_HASH_LENGTH,
                                        (PBYTE)&digestLen,
                                        sizeof(DWORD),
                                        &digestLenLen,
                                        0)))
    {
        // if the context can't tell us that property, things are unlikely to work.
        // try anyway with the length provided by the caller.
        digestLen = maxOutLen;
    }

    if(digestLen > maxOutLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "Invalid output buffer passed to HashFinal.");
    //terminate the hash and retrieve the hash value
    //close the hash
    if(!NT_SUCCESS(status = BCryptFinishHash(
                                        hashCtx->m_cngHashHandle, 
                                        pResult, 
                                        digestLen, 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptFinishHash failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_MISC_HASH_CALL_FAILED, NULL);
    }
    try {
        *pnResultLen = boost::numeric_cast<int,DWORD>(digestLen);
    } catch(...) {
        RAISE_CRYPTO_EXCEPTION("Internal error: Unable to cast digest length from DWORD to int.", TOOLKIT_CRYPTO, PKIFCAPI_MISC_HASH_CALL_FAILED, NULL);
    }
}
IPKIFRawCryptContext* CPKIFCNGCAPIRaw::CryptInit(
    const CPKIFKeyMaterial& key,
    bool pad)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::CryptInit(const CPKIFKeyMaterial& key)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    // the iterative crypt functions are a bad idea with RSA or DSA keys...
    if(!key.ContainsSymmetricKeyMaterial())
    {
        throw CPKIFCryptoException(TOOLKIT_CRYPTO, COMMON_INVALID_INPUT, "CryptInit() only makes sense for symmetric keys.");   
    }

    //throw bad_alloc; nothing to clean up in this function
    std::auto_ptr<CPKIFCAPIRawCryptContext> cryptContext(new CPKIFCAPIRawCryptContext());

    NTSTATUS status = STATUS_UNSUCCESSFUL;

    cryptContext->m_bNeedsPad = pad;
    
    LPCWSTR tmpAlgID = GetCNGSymAlgorithm(key);
    BCRYPT_ALG_HANDLE_PKIF hAlg(0);
    //open an algorithm handle
    if(!NT_SUCCESS(status = BCryptOpenAlgorithmProvider(&hAlg,tmpAlgID,NULL,0)))
    {
        std::ostringstream os;
        os << "BCryptOpenAlgorithmProvider failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_OPEN_ALG_PROVIDER_FAILED, NULL);
    }

    //calculate the size of the buffer to hold the KeyObject
    DWORD cbData = 0;
    DWORD cbKeyObject = 0;
    if(!NT_SUCCESS(status = BCryptGetProperty(hAlg,BCRYPT_OBJECT_LENGTH,(PBYTE)&cbKeyObject, 
        sizeof(DWORD),&cbData,0)))
    {
        std::ostringstream os;
        os << "BCryptGetProperty failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_GET_PROPERTY_FAILED, NULL);
    }

    pkif_byte_array pbKeyObject(new unsigned char[cbKeyObject]);

    LPCWSTR tmpMode = 0;
    switch(key.GetMode())
    {
    case PKIFCRYPTO::ECB:
        tmpMode = BCRYPT_CHAIN_MODE_ECB;
        break;
    case PKIFCRYPTO::CBC:
        tmpMode = BCRYPT_CHAIN_MODE_CBC;
        if(NULL == key.GetIV())
            throw CPKIFCryptoException(thisComponent, CRYPTO_MISSING_IV);
        break;
    default:
        throw CPKIFCryptoException(thisComponent, CRYPTO_MODE_NOT_SUPPORTED);
    }

    //calculate the block length
    if(!NT_SUCCESS(status = BCryptGetProperty(hAlg,BCRYPT_BLOCK_LENGTH,
        (PBYTE)&cryptContext->m_blockLen,sizeof(DWORD),&cbData,0)))
    {
        std::ostringstream os;
        os << "BCryptGetProperty: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_GET_PROPERTY_FAILED, NULL);

    }

    if(NULL != key.GetIV())
    {
        int ivLen = 0;
        key.GetIV(NULL, &ivLen);
        DWORD dwIVLen = 0;
        try {
            dwIVLen = boost::numeric_cast<DWORD,int>(ivLen);
        }catch(...){
            RAISE_CRYPTO_EXCEPTION("Invalid IV length.", TOOLKIT_CRYPTO, PKIFCAPING_GET_PROPERTY_FAILED, NULL);
        }
        // is an IV ever different from the block size legitimately for a block cipher?
        // (for any mode we support?)
        if (cryptContext->m_blockLen > dwIVLen)
        {
            std::ostringstream os;
            os << "Block length is not equal to the supplied IV length: " << GetLastError();;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_GET_PROPERTY_FAILED, NULL);

        }

        CPKIFBufferPtr tmp(new CPKIFBuffer(key.GetIV(), ivLen));
        cryptContext->m_iv = tmp;
    }

    if(pad)
        cryptContext->m_padbuf = new unsigned char[cryptContext->m_blockLen];

    // these are all short constants, never passed in by user
    ULONG modeLen = (ULONG) (wcslen(tmpMode)+1*sizeof(wchar_t));
    if(!NT_SUCCESS(status = BCryptSetProperty(hAlg,BCRYPT_CHAINING_MODE,(PBYTE)tmpMode, 
        modeLen,0)))
    {
        std::ostringstream os;
        os << "Failed to set mode: " << GetLastError();
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_SET_PROPERTY_FAILED, NULL);
    }

    PKIFCRYPTO::SYMKEY_ALG symAlg = key.GetSymmetricKeyAlgorithm();
    int keyLen = 0;
    key.GetSymmetricKey(NULL, &keyLen, &symAlg);
    // import raw key into a key object
    if(!NT_SUCCESS(status = BCryptGenerateSymmetricKey(hAlg,&cryptContext->m_hKey,
        pbKeyObject,cbKeyObject,(PBYTE)key.GetSymmetricKey(), 
        keyLen,0)))
    {
        std::ostringstream os;
        os << "BCryptGenerateSymmetricKey failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_GENERATE_SYM_KEY_FAILED, NULL);
    }
    // let the context take care of these now; they need to live longer than its
    // m_hKey member
    cryptContext->m_hBCAlg = hAlg.release();
    cryptContext->m_hKeyBuffer = pbKeyObject.release();

    // let the caller manage the raw pointer from here.
    return cryptContext.release();
}
void CPKIFCNGCAPIRaw::Decrypt(
    IPKIFRawCryptContext* cryptContext, 
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool final)
{
    m_impl->CryptFunc<false>(cryptContext, pData, nDataLen, pResult, pnResultLen, final);
}
void CPKIFCNGCAPIRaw::Encrypt(
    IPKIFRawCryptContext* cryptContext, 
    unsigned char* pData, 
    int nDataLen, 
    unsigned char* pResult, 
    int* pnResultLen, 
    bool final)
{
    m_impl->CryptFunc<true>(cryptContext, pData, nDataLen, pResult, pnResultLen, final);
}

template <bool _CryptDirection>
void CPKIFCNGCAPIRawImpl::CryptFunc(
    IPKIFRawCryptContext* cryptContext,
    unsigned char* pData,
    int nDataLen,
    unsigned char* pResult,
    int* pnResultLen,
    bool final)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::CryptFunc(IPKIFRawCryptContext* cryptContext, unsigned char* pData, int nDataLen, unsigned char* pResult, int* pnResultLen, bool final)", TOOLKIT_CRYPTO_CAPIRAW, 0, this);

    CPKIFCAPIRawCryptContext* icc = dynamic_cast<CPKIFCAPIRawCryptContext*>(cryptContext);
    const unsigned char* iv = NULL;
    ULONG ivLen = 0;

    if(icc->m_iv != (CPKIFBuffer*)NULL)
    {
        iv = icc->m_iv->GetBuffer();
        ivLen = icc->m_iv->GetLength();
        // XXX *** Maybe assert IV == blocksize? That should really be handled elsewhere
    }
    NTSTATUS status = STATUS_UNSUCCESSFUL;
    // if no padding was requested, or if it's an asymmetric op, just pass it right through
    if(icc->m_bFromCert || !icc->m_bNeedsPad)
    {
        if(_CryptDirection)
        {
            DWORD cbCipherText = 0;
            if(!NT_SUCCESS(status = BCryptEncrypt(icc->m_hKey,pData,nDataLen,
                                            NULL,(PBYTE)iv,ivLen,NULL,0,&cbCipherText,0)))
            {
                std::ostringstream os;
                os << "BCryptEncrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
            }
            pkif_byte_array pbCipherText(new unsigned char[cbCipherText]);
            DWORD cbData = 0;
            if(!NT_SUCCESS(status = BCryptEncrypt(icc->m_hKey,pData,nDataLen,
                                                NULL,(PBYTE)iv,ivLen, 
                                                pbCipherText,cbCipherText,&cbData,0)))
            {
                std::ostringstream os;
                os << "BCryptEncrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
            }

            memcpy(pResult, pbCipherText.get(), cbData);
            *pnResultLen = cbData;
        }
        else
        {
            DWORD cbPlainText = 0;
            //get the output buffer size
            if(!NT_SUCCESS(status = BCryptDecrypt( icc->m_hKey,pData,nDataLen,NULL,
                                            (PBYTE)iv,ivLen,NULL,0,&cbPlainText,0)))
            {
                std::ostringstream os;
                os << "BCryptDecrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
            }
            pkif_byte_array pbPlainText(new unsigned char[cbPlainText]);
            DWORD cbData = 0;
            if(!NT_SUCCESS(status = BCryptDecrypt(icc->m_hKey, pData, nDataLen,
                                            NULL,(PBYTE)iv,ivLen,
                                            pbPlainText,cbPlainText,&cbData, 
                                            0)))
            {
                std::ostringstream os;
                os << "BCryptDecrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
            }

            memcpy(pResult, pbPlainText.get(), cbData);
            try {
                *pnResultLen = cbData;
            }catch(...){
                RAISE_CRYPTO_EXCEPTION("BCryptDecrypt gave invalid length", TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
            }
        }
        return;
    }
    // otherwise, we've been asked to handle the padding here.
    int maxOut = *pnResultLen;
    int inLen = nDataLen;
    unsigned char * start = pData;
    unsigned char * outBuf = pResult;

    DWORD updateLen = 0;
    DWORD padUpdateLen = 0;
    *pnResultLen = 0;
    unsigned int finalLen = 0;

    *pnResultLen = 0;
    int err = 0;

    DWORD dwMaxOut = 0;
    try {
        dwMaxOut = boost::numeric_cast<DWORD,int>(maxOut);
    } catch(...) {
        RAISE_CRYPTO_EXCEPTION("Invalid output length", TOOLKIT_CRYPTO, COMMON_INVALID_INPUT, NULL);
    }
    if(_CryptDirection)
    {   
        DWORD resLen = *pnResultLen;
        if(final)
        {
            // XXX *** assert maxout >= padlen + inlen + blocksize
            if(icc->m_padlen) {
                memcpy(outBuf,icc->m_padbuf,icc->m_padlen);
            }
            if(start && inLen) memcpy(outBuf + icc->m_padlen,start,inLen);
            updateLen = inLen + icc->m_padlen;
            DWORD cbCipherText = 0;
            
            // plaintext gets copied to outBuf because this code is derived from
            // our CAPI1 colleague, where CryptEncrypt used pbData as in/out.
            // refactoring would make this easier to read.
            if(!NT_SUCCESS(status = BCryptEncrypt(icc->m_hKey,outBuf,updateLen,
                                            NULL,(PBYTE)iv,ivLen,NULL,0,&cbCipherText,BCRYPT_BLOCK_PADDING)))
            {
                std::ostringstream os;
                os << "BCryptEncrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
            }
            if(cbCipherText > dwMaxOut) {
                RAISE_CRYPTO_EXCEPTION("Output buffer is too small for ciphertext.", TOOLKIT_CRYPTO, COMMON_INVALID_INPUT, NULL);
            }
            pkif_byte_array pbCipherText(new unsigned char[cbCipherText]);
            DWORD cbData = 0;
            if(!NT_SUCCESS(status = BCryptEncrypt(icc->m_hKey,outBuf,updateLen,
                                                NULL,(PBYTE)iv,ivLen, 
                                                pbCipherText,cbCipherText,&cbData,BCRYPT_BLOCK_PADDING)))
            {
                std::ostringstream os;
                os << "BCryptEncrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
            }
            memcpy(outBuf,pbCipherText.get(),cbData);
            try {
                *pnResultLen = boost::numeric_cast<int,DWORD>(cbData);
            }catch(...){
                RAISE_CRYPTO_EXCEPTION("BCryptEncrypt returned invalid length", TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
            }
            return;
        }

        // if it's not final, we need to have input
        if(!start || !inLen) return;
        int leftInBlock = icc->m_blockLen - icc->m_padlen;


        // if there's not enough to exceed the pad buffer, fill the pad buffer and bail
        if(leftInBlock >= inLen) {
            memcpy(icc->m_padbuf,start,inLen);
            icc->m_padlen += inLen;
            *pnResultLen = 0;
            return;
        }

        // if we're here, we got more than a cipherblock
        // 1. Empty the pad buffer
        memcpy(outBuf,icc->m_padbuf,icc->m_padlen);
        updateLen = icc->m_padlen;
        icc->m_padlen = 0;
        
        // 2. calculate how many bytes go into the pad buffer
        int trailing = (inLen + updateLen) % icc->m_blockLen ? 
            (inLen + updateLen) % icc->m_blockLen : icc->m_blockLen;

        // 3. empty the input buffer
        int copied = inLen - trailing;
        memcpy(outBuf+updateLen,start,copied);
        start += copied;
        updateLen += copied;

        // 4. encrypt
        DWORD cbCipherText = 0;
        if(!NT_SUCCESS(status = BCryptEncrypt(icc->m_hKey,outBuf,updateLen,
                                            NULL,(PBYTE)iv,ivLen,NULL,0,&cbCipherText,0)))
        {
            std::ostringstream os;
            os << "BCryptEncrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                << ")" << endl;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
        }
        if(cbCipherText > dwMaxOut) {
            RAISE_CRYPTO_EXCEPTION("Output buffer is too small for ciphertext.", TOOLKIT_CRYPTO, COMMON_INVALID_INPUT, NULL);
        }
        pkif_byte_array pbCipherText(new unsigned char[cbCipherText]);
        DWORD cbData = 0;
        if(!NT_SUCCESS(status = BCryptEncrypt(icc->m_hKey,outBuf,updateLen,
                                            NULL,(PBYTE)iv,ivLen, 
                                            pbCipherText,cbCipherText,&cbData,0)))
        {
            std::ostringstream os;
            os << "BCryptEncrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                << ")" << endl;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
        }
        memcpy(outBuf,pbCipherText.get(),cbData);
                
        // 5. copy off the trailing bytes for next time
        memcpy(icc->m_padbuf,start,trailing);
        icc->m_padlen += trailing;

        try {
            *pnResultLen = boost::numeric_cast<int,DWORD>(cbData);
        }catch(...){
            RAISE_CRYPTO_EXCEPTION("BCryptEncrypt returned invalid length", TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
        }
    }
    else
    {
        if(final) {
            if(icc->m_padlen) {
                memcpy(outBuf,icc->m_padbuf,icc->m_padlen);
            }
            if(start && inLen) memcpy(outBuf + icc->m_padlen,start,inLen);
            updateLen = inLen + icc->m_padlen;
            icc->m_padlen = 0;
            DWORD cbPlainText = 0;
            //get the output buffer size
            if(!NT_SUCCESS(status = BCryptDecrypt( icc->m_hKey,outBuf,updateLen,NULL,
                                            (PBYTE)iv,ivLen,NULL,0,&cbPlainText,BCRYPT_BLOCK_PADDING)))
            {
                std::ostringstream os;
                os << "BCryptDecrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
            }
            pkif_byte_array pbPlainText(new unsigned char[cbPlainText]);
            DWORD cbData = 0;
            if(!NT_SUCCESS(status = BCryptDecrypt(icc->m_hKey, outBuf, updateLen,
                                            NULL,(PBYTE)iv,ivLen,
                                            pbPlainText,cbPlainText,&cbData, 
                                            BCRYPT_BLOCK_PADDING)))
            {
                std::ostringstream os;
                os << "BCryptDecrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                    << ")" << endl;
                RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
            }
            // check this here since CAPI can't
            if(dwMaxOut < cbData) {
                RAISE_CRYPTO_EXCEPTION("Decrypt() called with insufficient buffer available", m_parent->thisComponent, COMMON_INVALID_INPUT, NULL);
            }

            memcpy(pResult, pbPlainText.get(), cbData);
            try {
                *pnResultLen = boost::numeric_cast<int,DWORD>(cbData);
            }catch(...){
                RAISE_CRYPTO_EXCEPTION("BCryptDecrypt returned invalid length", TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
            }
            return;
        }

        // if it's not final, we need to have input
        if(!start || !inLen) return;
        int leftInBlock = icc->m_blockLen - icc->m_padlen;
        // if there's not enough to exceed the pad buffer, fill the pad buffer and bail
        if(leftInBlock >= inLen) {
            memcpy(icc->m_padbuf,start,inLen);
            icc->m_padlen += inLen;
            *pnResultLen = 0;
            return;
        }

        // if we're here, we got more than a cipherblock
        // 1. Empty the pad buffer
        memcpy(outBuf,icc->m_padbuf,icc->m_padlen);
        updateLen = icc->m_padlen;
        icc->m_padlen = 0;
        
        // 2. calculate how many bytes go into the pad buffer
        int trailing = (inLen + updateLen) % icc->m_blockLen ? 
            (inLen + updateLen) % icc->m_blockLen : icc->m_blockLen;

        // 3. empty the input buffer
        int copied = inLen - trailing;
        memcpy(outBuf+updateLen,start,copied);
        start += copied;
        updateLen += copied;

        // 4. decrypt
        DWORD cbPlainText = 0;
        //get the output buffer size
        if(!NT_SUCCESS(status = BCryptDecrypt( icc->m_hKey,outBuf,updateLen,NULL,
                                        (PBYTE)iv,ivLen,NULL,0,&cbPlainText,0)))
        {
            std::ostringstream os;
            os << "BCryptDecrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                << ")" << endl;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
        }
        // check this here since CAPI can't
        if(dwMaxOut < cbPlainText) {
            RAISE_CRYPTO_EXCEPTION("Decrypt() called with insufficient buffer available", m_parent->thisComponent, COMMON_INVALID_INPUT, NULL);
        }
        pkif_byte_array pbPlainText(new unsigned char[cbPlainText]);
        DWORD cbData = 0;
        if(!NT_SUCCESS(status = BCryptDecrypt(icc->m_hKey, outBuf, updateLen,
                                        NULL,(PBYTE)iv,ivLen,
                                        pbPlainText,cbPlainText,&cbData, 
                                        0)))
        {
            std::ostringstream os;
            os << "BCryptDecrypt failed :(" << GetLastError() << ")" << "(NTSTATUS code " << status
                << ")" << endl;
            RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPING_DECRYPT_FAILED, NULL);
        }

        memcpy(pResult, pbPlainText.get(), cbData);
        
        // 5. copy off the trailing bytes for next time
        memcpy(icc->m_padbuf,start,trailing);
        icc->m_padlen += trailing;
        try {
            *pnResultLen = boost::numeric_cast<int,DWORD>(cbData);
        }catch(...){
            RAISE_CRYPTO_EXCEPTION("BCryptDecrypt returned invalid length", TOOLKIT_CRYPTO, PKIFCAPING_ENCRYPT_FAILED, NULL);
        }
    }
}


IPKIFRawCryptContext* CPKIFCNGCAPIRaw::HMACInit(const CPKIFKeyMaterial &key, PKIFCRYPTO::HASH_ALG ha)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::HMACInit(const CPKIFKeyMaterial& key, HASH_ALG ha)", thisComponent, 0, this);
    return 0;

    wchar_t* hashAlg;
    switch(ha)
    {
    case PKIFCRYPTO::SHA1:
        hashAlg = BCRYPT_SHA1_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA256:
        hashAlg = BCRYPT_SHA256_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA384:
        hashAlg = BCRYPT_SHA384_ALGORITHM;
        break;
    case PKIFCRYPTO::SHA512:
        hashAlg = BCRYPT_SHA512_ALGORITHM;
        break;
    default:
        std::ostringstream os;
        os << "Unsupported hash algorithm encountered: " << hashAlg;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), thisComponent, CRYPTO_ALG_NOT_SUPPORTED, NULL);
    }

    //create a hash context object and populate it with context and hash objects
    //throw bad_alloc; nothing to clean up in this function
    CPKIFCAPIRawCryptContext* cryptCtx = new CPKIFCAPIRawCryptContext();
    NTSTATUS                status          = STATUS_UNSUCCESSFUL;
    BCRYPT_ALG_HANDLE       hHashAlg            = NULL; 
    DWORD                   cbData          = 0,
                            cbHash          = 0,
                            cbHashObject    = 0;
    PBYTE                   pbHashObject    = NULL;
    PBYTE                   pbHash          = NULL;

    //open an algorithm handle
    if(!NT_SUCCESS(status = BCryptOpenAlgorithmProvider(
                                            &hHashAlg,
                                            hashAlg,
                                            NULL,
                                            BCRYPT_ALG_HANDLE_HMAC_FLAG)))
    {

        std::ostringstream os;
        os << "CryptCreateHash failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //calculate the size of the buffer to hold the hash object
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hHashAlg, 
                                        BCRYPT_OBJECT_LENGTH, 
                                        (PBYTE)&cbHashObject, 
                                        sizeof(DWORD), 
                                        &cbData, 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptGetProperty failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //allocate the hash object on the heap
    pbHashObject = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbHashObject);
    if(NULL == pbHashObject)
    {
        std::ostringstream os;
        os << "Memory allocation failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //calculate the length of the hash
    if(!NT_SUCCESS(status = BCryptGetProperty(
                                        hHashAlg, 
                                        BCRYPT_HASH_LENGTH, 
                                        (PBYTE)&cbHash, 
                                        sizeof(DWORD), 
                                        &cbData, 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptGetProperty failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    //create a hash
    if(!NT_SUCCESS(status = BCryptCreateHash(
                                        hHashAlg, 
                                        &cryptCtx->m_cngHashHandle, 
                                        pbHashObject, 
                                        cbHashObject, 
                                        (PBYTE)const_cast<unsigned char *>(key.GetSymmetricKey()), 
                                        key.GetSymmetricKeyLength(), 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptCreateHash failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }

    return cryptCtx;
}

void CPKIFCNGCAPIRaw::HMACUpdate(IPKIFRawCryptContext* ctx, unsigned char* pData, int nDataLen)
{
    LOG_STRING_DEBUG("CPKIFCNGCAPIRaw::HMACUpdate(IPKIFRawCryptContext* ctx, unsigned char* pData, int nDataLen)", thisComponent, 0, this);

        NTSTATUS                status          = STATUS_UNSUCCESSFUL;

    //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/* || NULL == pData || 0 >= nDataLen*/ || 0 > nDataLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL input passed to HMACUpdate.");

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

    if(NULL == cryptCtx->m_cngHashHandle)
        throw CPKIFCryptoException(thisComponent, PKIFCAPI_EMPTY_HASH_CONTEXT, "Empty hash context passed to HMACUpdate.");

    //hash some data
    if(!NT_SUCCESS(status = BCryptHashData(
                                        cryptCtx->m_cngHashHandle,
                                        (PBYTE)pData,
                                        nDataLen,
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptHashData failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }
}

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

    NTSTATUS                status          = STATUS_UNSUCCESSFUL;

    //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 == ctx || NULL == pResult || NULL == pnResultLen || 0 >= *pnResultLen)
        throw CPKIFCryptoException(thisComponent, COMMON_INVALID_INPUT, "NULL input passed to HMACFinal.");

    CPKIFCAPIRawCryptContext* cryptCtx = dynamic_cast<CPKIFCAPIRawCryptContext*>(ctx);
    if(NULL == cryptCtx)
        throw CPKIFCryptoException(thisComponent, PKIFCAPI_INCORRECT_HASH_CONTEXT, "Incorrect hash context passed to HMACFinal.");

    if(NULL == cryptCtx->m_cngHashHandle)
        throw CPKIFCryptoException(thisComponent, PKIFCAPI_EMPTY_HASH_CONTEXT, "Empty hash context passed to HMACFinal.");

    //terminate the hash and retrieve the hash value
    //close the hash
    if(!NT_SUCCESS(status = BCryptFinishHash(
                                        cryptCtx->m_cngHashHandle, 
                                        pResult, 
                                        *((DWORD*)pnResultLen), 
                                        0)))
    {
        std::ostringstream os;
        os << "BCryptFinishHash failed: " << GetLastError();;
        RAISE_CRYPTO_EXCEPTION(os.str().c_str(), TOOLKIT_CRYPTO, PKIFCAPI_CREATE_HASH_FAILED, NULL);
    }
}