ParallelHash.cpp

Go to the documentation of this file.

#include "ParallelHash.h"
#include "ToolkitUtils.h"
#include "components.h"
#include "PKIFCommonErrors.h"
#include "PKIFMessageException.h"
#include "AlgorithmIdentifier.h"
#include "OID.h"
#include "Buffer.h"
#include "IPKIFCryptoMisc.h"
#include "IPKIFHashContext.h"
#include "PKIFMessageErrors.h"
#include "ASN1Helper.h"
#include "PKIFAlgorithm.h"

#include "private/PrivatePKIFCMSUtils.h"
#include "CryptographicMessageSyntax2004.h"

using namespace std;

struct CPKIFParallelHashImpl
{
    enum {thisComponent=TOOLKIT_MESSAGE_PARALLEL_HASH};
    std::vector<HashInfo*> m_hashCtx;
    bool m_bHashesFinalized;
    bool m_bIgnoreUnsupportedAlgorithms;
};

CPKIFParallelHash::CPKIFParallelHash()
    :m_impl (new CPKIFParallelHashImpl)
{
    LOG_STRING_DEBUG("CPKIFParallelHash::CPKIFParallelHash()", TOOLKIT_CRYPTO_MISC, 0, this);

    m_impl->m_bHashesFinalized = false;
    m_impl->m_bIgnoreUnsupportedAlgorithms = true;
}
CPKIFParallelHash::~CPKIFParallelHash()
{
    LOG_STRING_DEBUG("CPKIFParallelHash::~CPKIFParallelHash()", TOOLKIT_CRYPTO_MISC, 0, this);

    FreeHashVector();

    delete m_impl;
    m_impl = NULL;
}
void CPKIFParallelHash::SetDigestAlgs(
    IPKIFCryptoMisc* cMisc,
    CCACDigestAlgorithmIdentifiers& digestAlgs)  //added for TAP purposes 9/5/03
{
    LOG_STRING_DEBUG("CPKIFParallelHash::SetDigestAlgs(IPKIFCryptoMisc* cMisc, CCACDigestAlgorithmIdentifiers& digestAlgs)", TOOLKIT_CRYPTO_MISC, 0, this);

    // SAS add 03/10/2004
    if(NULL == cMisc)
        throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "cMisc was NULL.");


    //check to see if we already have some hash contexts
    if(m_impl->m_hashCtx.empty())
    {
        //if not, create some - if no hash algs are passed in throw an error
        if(digestAlgs.empty())
            throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "Empty algorithm list passed to SetDigestAlgs.");

        CCACDigestAlgorithmIdentifiers::iterator pos;
        CCACDigestAlgorithmIdentifiers::iterator end = digestAlgs.end();
        for(pos = digestAlgs.begin(); pos != end; ++pos)
        {
            CPKIFOIDPtr algOID = (*pos)->oid();

            PKIFCRYPTO::HASH_ALG hashAlg;

            //try to get a PKIF identifier for the hashing algorithm
            if(GetCACHashAlg(algOID, &hashAlg))
            {
                HashInfo* hi = NULL;
                try
                {
                    hi = new HashInfo();
                }
                catch(std::bad_alloc& ba)
                {
                    FreeHashVector();   //clean up anything allocated by an earlier loop and bail out
                    throw ba;
                }

                hi->m_hashAlg = hashAlg;
                hi->m_hashContext = cMisc->HashInit(hashAlg);
                m_impl->m_hashCtx.push_back(hi);
            }
            else
            {
                //if alg is not supported and ignore is set to false - clean up and bail out
                if(!m_impl->m_bIgnoreUnsupportedAlgorithms)
                    throw CPKIFMessageException(m_impl->thisComponent, COMMON_UNSUPPORTED_ALG, "Unsupported hashing algorithm passed to SetDigestAlgs");

                //typically, in CMS usage case, we can let an unsupported hashing algorithm pass
                //as long as we never attempt to verify the signature associated with that hash algorithm.
                //if we try to verify the signature associated with an unsupported algorithm then we can fail.
            }
        }
    }
    else
    {
        throw CPKIFMessageException(m_impl->thisComponent, MSG_INVALID_STATE, "You must call FreeHashVector before calling SetDigestAlgs.");
    }
}

void CPKIFParallelHash::SetDigestAlgs(
    IPKIFCryptoMisc* cMisc,
    CPKIFBufferPtr digestAlgsBuf) 
{
    LOG_STRING_DEBUG("CPKIFParallelHash::SetDigestAlgs(IPKIFCryptoMisc* cMisc, CACCMSDigestAlgorithmIdentifiers* digestAlgs)", TOOLKIT_CRYPTO_MISC, 0, this);

    CACASNWRAPPER_CREATE(CACCMSDigestAlgorithmIdentifiers, digestAlgsVal);
    digestAlgsVal.Decode(digestAlgsBuf->GetBuffer(), digestAlgsBuf->GetLength());
    
    // SAS add 03/10/2004
    if(NULL == cMisc)
        throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "cMisc was NULL.");


    //check to see if we already have some hash contexts
    if(m_impl->m_hashCtx.empty())
    {
        //if not, create some - if no hash algs are passed in throw an error
        if(NULL == digestAlgsVal.data() || 0 == digestAlgsVal->count || NULL == digestAlgsVal->head)
            throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "Empty algorithm list passed to SetDigestAlgs.");

        DListNode* cur = digestAlgsVal->head;
        while(NULL != cur)
        {
            CACX509V3AlgorithmIdentifier* algID = (CACX509V3AlgorithmIdentifier*)cur->data;

            //try to get a PKIF identifier for the hashing algorithm
            CPKIFAlgorithm * pkifAlg = GetCACHashAlg(algID);
            
            if(pkifAlg)
            {
                PKIFCRYPTO::HASH_ALG hashAlg = pkifAlg->HashAlg();
                HashInfo* hi = NULL;
                try
                {
                    hi = new HashInfo();
                }
                catch(std::bad_alloc& ba)
                {
                    FreeHashVector();   //clean up anything allocated by an earlier iteration and bail out
                    throw ba;
                }

                hi->m_hashAlg = hashAlg;
                hi->m_hashContext = cMisc->HashInit(hashAlg);
                m_impl->m_hashCtx.push_back(hi);
            }
            else
            {
                //if alg is not supported and ignore is set to false - clean up and bail out
                if(!m_impl->m_bIgnoreUnsupportedAlgorithms)
                    throw CPKIFMessageException(m_impl->thisComponent, COMMON_UNSUPPORTED_ALG, "Unsupported hashing algorithm passed to SetDigestAlgs");

                //typically, in CMS usage case, we can let an unsupported hashing algorithm pass
                //as long as we never attempt to verify the signature associated with that hash algorithm.
                //if we try to verify the signature associated with an unsupported algorithm then we can fail.
            }

            cur = cur->next;
        }
    }
    else
    {
        //if so, bail out
        throw CPKIFMessageException(m_impl->thisComponent, MSG_INVALID_STATE, "You must call FreeHashVector before calling SetDigestAlgs.");
    }
}


/*void CPKIFParallelHash::SetDigestAlgs(
    IPKIFCryptoMisc* cMisc,
    CACCMSDigestAlgorithmIdentifiers* digestAlgs) 
{
    LOG_STRING_DEBUG("CPKIFParallelHash::SetDigestAlgs(IPKIFCryptoMisc* cMisc, CACCMSDigestAlgorithmIdentifiers* digestAlgs)", TOOLKIT_CRYPTO_MISC, 0, this);

    // SAS add 03/10/2004
    if(NULL == cMisc)
        throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "cMisc was NULL.");


    //check to see if we already have some hash contexts
    if(m_impl->m_hashCtx.empty())
    {
        //if not, create some - if no hash algs are passed in throw an error
        if(NULL == digestAlgs || 0 == digestAlgs->count || NULL == digestAlgs->head)
            throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "Empty algorithm list passed to SetDigestAlgs.");

        DListNode* cur = digestAlgs->head;
        while(NULL != cur)
        {
            CACX509V3AlgorithmIdentifier* algID = (CACX509V3AlgorithmIdentifier*)cur->data;

            HASH_ALG hashAlg;

            //try to get a PKIF identifier for the hashing algorithm
            if(GetCACHashAlg(algID, &hashAlg))
            {
                HashInfo* hi = NULL;
                try
                {
                    hi = new HashInfo();
                }
                catch(std::bad_alloc& ba)
                {
                    FreeHashVector();   //clean up anything allocated by an earlier iteration and bail out
                    throw ba;
                }

                hi->m_hashAlg = hashAlg;
                hi->m_hashContext = cMisc->HashInit(hashAlg);
                m_impl->m_hashCtx.push_back(hi);
            }
            else
            {
                //if alg is not supported and ignore is set to false - clean up and bail out
                if(!m_impl->m_bIgnoreUnsupportedAlgorithms)
                    throw CPKIFMessageException(m_impl->thisComponent, COMMON_UNSUPPORTED_ALG, "Unsupported hashing algorithm passed to SetDigestAlgs");

                //typically, in CMS usage case, we can let an unsupported hashing algorithm pass
                //as long as we never attempt to verify the signature associated with that hash algorithm.
                //if we try to verify the signature associated with an unsupported algorithm then we can fail.
            }

            cur = cur->next;
        }
    }
    else
    {
        //if so, bail out
        throw CPKIFMessageException(m_impl->thisComponent, MSG_INVALID_STATE, "You must call FreeHashVector before calling SetDigestAlgs.");
    }
}
*/

void CPKIFParallelHash::UpdateMessage(
    IPKIFCryptoMisc* cMisc,
    unsigned char* buf, 
    int bufLen)
{
    LOG_STRING_DEBUG("CPKIFParallelHash::UpdateMessage(IPKIFCryptoMisc* cMisc, unsigned char* buf, int bufLen)", TOOLKIT_CRYPTO_MISC, 0, this);

    //see if we already have a hash context
    if(m_impl->m_hashCtx.empty())
    {
        //if not - fail
        throw CPKIFMessageException(m_impl->thisComponent, MSG_INVALID_STATE, "No supported hash algorithms have been set.");
    }
    else
    {
        //if so, then update each hash with the new data (let crypto exceptions pass back to caller)
        vector<HashInfo*>::iterator pos;
        vector<HashInfo*>::iterator end = m_impl->m_hashCtx.end();
        for(pos = m_impl->m_hashCtx.begin(); end != pos; ++pos)
        {
            //throw any exceptions from HashUpdate
            cMisc->HashUpdate((*pos)->m_hashContext, buf, bufLen);
        }
    }
}
void CPKIFParallelHash::FinalizeHashes(
    IPKIFCryptoMisc* cMisc)
{
    LOG_STRING_DEBUG("CPKIFParallelHash::FinalizeHashes(IPKIFCryptoMisc* cMisc)", TOOLKIT_CRYPTO_MISC, 0, this);

    // SAS add 03/10/2004
    if(NULL == cMisc)
        throw CPKIFMessageException(m_impl->thisComponent, COMMON_INVALID_INPUT, "cMisc was NULL.");

    //if hashes have already been finalized then silently do nothing
    if(m_impl->m_bHashesFinalized)
        return;
    else
    {
        //finalize all hashes - storing the results in the HashInfo object stored in the vector
        vector<HashInfo*>::iterator pos;
        vector<HashInfo*>::iterator end = m_impl->m_hashCtx.end();
        int nHashResult = MAXHASH;
        for(pos = m_impl->m_hashCtx.begin(); end != pos; ++pos)
        {
            nHashResult = MAXHASH;
            cMisc->HashFinal((*pos)->m_hashContext, (*pos)->m_hashResult, &nHashResult);
        }

        m_impl->m_bHashesFinalized = true;
    }
}
HashInfo* CPKIFParallelHash::GetHashInfo(
    PKIFCRYPTO::HASH_ALG alg)
{
    LOG_STRING_DEBUG("CPKIFParallelHash::GetHashInfo(HASH_ALG alg)", TOOLKIT_CRYPTO_MISC, 0, this);

    //iterate over all hash infos and return the first (and presumably only) one
    //that matches the alg passed in
    vector<HashInfo*>::iterator pos;
    vector<HashInfo*>::iterator end = m_impl->m_hashCtx.end();
    for(pos = m_impl->m_hashCtx.begin(); end != pos; ++pos)
    {
        if((*pos)->m_hashAlg == alg)
            return *pos;
    }

    return NULL;
}
void CPKIFParallelHash::FreeHashVector()
{
    LOG_STRING_DEBUG("CPKIFParallelHash::FreeHashVector()", TOOLKIT_CRYPTO_MISC, 0, this);

    //iterate over all HashInfo objects in the vector and set them free
    vector<HashInfo*>::iterator pos;
    vector<HashInfo*>::iterator end = m_impl->m_hashCtx.end();
    for(pos = m_impl->m_hashCtx.begin(); end != pos; ++pos)
    {
        try
        {
            delete (*pos)->m_hashContext;
        }
        catch(...)
        {
            //paranoid try - should never catch anything here
        }

        delete *pos;
    }
    m_impl->m_hashCtx.clear();
    m_impl->m_bHashesFinalized = false;
}
void CPKIFParallelHash::SetIgnoreUnsupportedAlgs(
    bool b)
{
    m_impl->m_bIgnoreUnsupportedAlgorithms = b;
}