CVRequest.cpp

Go to the documentation of this file.

#include "CVRequest.h" 

#include "ASN1Helper.h"
#include "AlgorithmIdentifier.h"
#include "Buffer.h"
#include "OID.h"
#include "Query.h" 
#include "ResponseFlags.h"
#include "PKIFTime.h"
#include "Certificate.h"
#include "ValidationPolicy.h"
#include "KeyUsage.h"
#include "PKCReference.h"
#include "GeneralName.h"
#include "Name.h"
#include "RevocationInfo.h"
#include "CRL.h"
#include "SCVPCertID.h"
#include "CertReferences.h"
#include "PKIFMessageErrors.h"
#include "ACReference.h"
#include "PKIFSCVPErrors.h"
#include "PKIFX509Extensions2.h"
#include "SCVP.h"
#include "ToolkitUtils.h"
#include "IPKIFCryptoMisc.h"
#include "PKIFCryptUtils.h"
#include "X509Extension.h"
#include "SCVPException.h"
#include "PolicyInformation.h"
#include "private/PKIFSCVPMemoryHelper.h"
#include "private/SCVPUtils.h"


struct CPKIFCVRequestImpl
{
    CPKIFCVRequest *m_parent;

    //function to process extensions
    void populateExtensionsVector();

    //convenience goo for auto-nonce generation
    bool m_bGenerateNonce;
    void GenerateNonce() const; //logical const
    IPKIFMediatorPtr m_mediator;

    //members for building
    int m_version;
    CPKIFBufferPtr m_nonce;
    CPKIFOIDPtr m_hashAlgorithm;
    CPKIFAlgorithmIdentifierPtr m_sigAlgorithm;
    CPKIFGeneralNamePtr m_requestorName;
    CPKIFGeneralNamePtr m_responderName;    
    CPKIFGeneralNameListPtr m_requestorRef;
    CPKIFQueryPtr m_query;
    CPKIFStringPtr m_requestorText;
    std::vector<CPKIFX509ExtensionPtr> m_exts;

    //member for decoding
    CPKIFASNWrapper<CVRequest>* m_scvpr;

    void ClearAllMembers();
    void MakeSCVPR();
    void FreeSCVPR();

    //member to maintain state when calling Set functions
    void CallingAllGets();

    CPKIFCVRequest * m_this;
};

void CPKIFCVRequestImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::CallingAllGets()", TOOLKIT_SCVP_ASN, 0, this);


    m_parent->GetVersion();
    m_parent->GetNonce();
    populateExtensionsVector();
    FreeSCVPR();
}

void CPKIFCVRequestImpl::MakeSCVPR()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);

    FreeSCVPR();
    m_scvpr = new CPKIFASNWrapper<CVRequest>( BEREncCVRequest, BERDecCVRequest );
}
void CPKIFCVRequestImpl::FreeSCVPR()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::FreeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);
    if(NULL != m_scvpr)
        delete m_scvpr;
    m_scvpr = NULL;
}

void CPKIFCVRequestImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::ClearAllMembers()", TOOLKIT_SCVP_ASN, 0, this);

    m_version = 1;
    m_bGenerateNonce = false;

    IPKIFMediatorPtr tmp;
    m_mediator = tmp;
    
    CPKIFBufferPtr tmpNonce;
    m_nonce = tmpNonce;

    CPKIFOIDPtr tmpHashAlg;
    m_hashAlgorithm = tmpHashAlg;

    CPKIFAlgorithmIdentifierPtr tmpSigAlg;
    m_sigAlgorithm = tmpSigAlg;
    
    CPKIFGeneralNamePtr tmpResuestorName;
    m_requestorName = tmpResuestorName;
    
    CPKIFGeneralNamePtr tmpResponderName;
    m_responderName = tmpResponderName; 

    CPKIFGeneralNameListPtr tmpRequestorRef;
    m_requestorRef = tmpRequestorRef;
    
    CPKIFQueryPtr tmpQuery;
    m_query = tmpQuery;
    
    CPKIFStringPtr tmpStr;
    m_requestorText = tmpStr;

    FreeSCVPR();
}

void CPKIFCVRequestImpl::GenerateNonce() const
{
    LOG_STRING_DEBUG("CPKIFCVRequest::GenerateNonce()", TOOLKIT_SCVP_ASN, 0, this);

    IPKIFCryptoMisc* iMisc = NULL;
    if(NULL != m_mediator)
        iMisc = m_mediator->GetMediator<IPKIFCryptoMisc>();

    unsigned char buf[20];
    memset(buf, 0, 20); //avoid (unlikely) case of sending random memory to TSA

    if(NULL != iMisc)
    {
        //if we can get a pointer to an externally provided interface use it
        iMisc->GenRandom(buf, 20);
    }
    else
    {
        //otherwise create a temp object to generate the nonce
 
        IPKIFCryptoMisc *raw = GetPlatformCryptoMisc();
        raw->GenRandom(buf, 20);
    }


    //strip leading zeroes
    const unsigned char* bufEnd = buf + 20;
    unsigned char* bufP = buf;
    int nonZeroLen = 20;
    while(*bufP == 0x00)
    {
        ++bufP;
        --nonZeroLen;
    }
    CPKIFBufferPtr tmpNonce(new CPKIFBuffer(bufP, nonZeroLen));

    CPKIFCVRequestImpl* nonConst = const_cast<CPKIFCVRequestImpl*>(this);
    nonConst->m_nonce = tmpNonce;
}

void CPKIFCVRequestImpl::populateExtensionsVector()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::populateExtensionsVector()", TOOLKIT_SCVP_ASN, 0, this);

    if(NULL == m_scvpr || NULL == m_scvpr->data())
        return;

    //if we've already populated the extensions vector then return
    if(!m_exts.empty())
        return;

    //if there are no extensions then return
    if(0 == (*m_scvpr)->m.requestExtensionsPresent)
    {
        m_exts.clear();
        return;
    }

    // get the one and only extension mediator, with any additions an app might
    // have made
    CPKIFX509ExtensionMediator2 * mediator = CPKIFX509ExtensionMediator2::GetInstance();

    m_this->IPKIFHasExtensions::GetExtensions (mediator, m_exts);
}




void CPKIFCVRequest::GetExtensionByOID(
    const CPKIFOID& oid,    
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != (*m_impl->m_scvpr)->m.requestExtensionsPresent)
    m_impl->populateExtensionsVector();
    
    std::vector<CPKIFX509ExtensionPtr>::iterator pos;
    std::vector<CPKIFX509ExtensionPtr>::iterator end = m_impl->m_exts.end();
    for(pos = m_impl->m_exts.begin(); pos != end; ++pos)
    {
    if(oid == (*pos)->oid())
    {
        ref = *pos;
        return;
    }
    }       
}

CPKIFCVRequest::CPKIFCVRequest()
  :m_impl(new CPKIFCVRequestImpl)
{
    LOG_STRING_DEBUG("CPKIFCVRequest::CPKIFCVRequest()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_parent = this;
    m_impl->m_version = 1;
    m_impl->m_bGenerateNonce = false;

    m_impl->m_scvpr = NULL;

    m_impl->m_this = this;
}
CPKIFCVRequest::~CPKIFCVRequest()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::~CPKIFCVRequest()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->FreeSCVPR();

    if (m_impl) 
    {
      delete m_impl;
    }
}

int CPKIFCVRequest::GetVersion() const
{
    return m_impl->m_version;
}

void CPKIFCVRequest::SetVersion(int v)
{
    m_impl->m_version = v;
}

void CPKIFCVRequest::GetEncodedExtensions (
    CPKIFBufferPtr& buf) 
{
    try 
    {
        if ((*m_impl->m_scvpr)->m.requestExtensionsPresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
            ASN1OpenType *data = extsWrapper.Encode (&(*m_impl->m_scvpr)->requestExtensions);
            CPKIFBufferPtr tmp(new CPKIFBuffer(data->data, data->numocts));
            buf = tmp;
            delete data;
            return;
        }
    }
    catch (... /*CPKIFException& e*/)
    {
        // How do we want to handle the exception?
    }

    CPKIFBufferPtr nullExt;
    buf = nullExt;
}

bool CPKIFCVRequest::ExtensionsPresent() const
{
    LOG_STRING_DEBUG("CPKIFCVRequest::ExtensionsPresent()", TOOLKIT_SCVP_ASN, 0, this);

    if(NULL != m_impl->m_scvpr && (*m_impl->m_scvpr)->m.requestExtensionsPresent)
        return true;
    else
        return false;
}

void CPKIFCVRequest::SetNonce(
    CPKIFBufferPtr& nonce)
{
    LOG_STRING_DEBUG("CPKIFCVRequest::SetNonce(CPKIFStringPtr& nonce)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_nonce = nonce;
}
const CPKIFBufferPtr CPKIFCVRequest::GetNonce() const
{
    //corrected casting of NULL 6/16/2004
    //if(m_impl->m_nonce == (std::string*)NULL && NULL != m_impl->m_scvpr && (*m_impl->m_scvpr)->m.requestNoncePresent)
    //{
    //  LOG_STRING_DEBUG("CPKIFCVRequest::GetNonce()", TOOLKIT_SCVP_ASN, 0, this);

    //  CPKIFBufferPtr tmpBuf(new CPKIFBuffer((*m_impl->m_scvpr)->requestNonce.data, (*m_impl->m_scvpr)->requestNonce.numocts));

    //  CPKIFCVRequest* nonConst = const_cast<CPKIFCVRequest*>(this);
    //  nonConst->m_impl->m_nonce = tmpBuf;
    //}

    if(m_impl->m_nonce == NULL)
    {
        CPKIFBufferPtr t;
        return t;
    }
    else
        return m_impl->m_nonce;
}
void CPKIFCVRequest::SetGenerateNonce(
    bool generateNonce)
{
    LOG_STRING_DEBUG("CPKIFCVRequest::SetGenerateNonce(bool generateNonce, IPKIFMediatorPtr m)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_bGenerateNonce = generateNonce;
}

void CPKIFCVRequest::SetGenerateNonce(
    bool generateNonce, 
    IPKIFMediatorPtr& m)
{
    LOG_STRING_DEBUG("CPKIFCVRequest::SetGenerateNonce(bool generateNonce, IPKIFMediatorPtr m)", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_bGenerateNonce = generateNonce;
    m_impl->m_mediator = m;
}
bool CPKIFCVRequest::GetGenerateNonce() const
{
    return m_impl->m_bGenerateNonce;
}

void CPKIFCVRequest::SetHashAlgorithm(
    CPKIFOIDPtr& hashAlgorithm)
{
    m_impl->m_hashAlgorithm = hashAlgorithm;
}

const CPKIFOIDPtr CPKIFCVRequest::GetHashAlgorithm() const
{
    return m_impl->m_hashAlgorithm;
}

void CPKIFCVRequest::SetSigAlgorithm(
    CPKIFAlgorithmIdentifierPtr& sigAlgorithm)
{
    m_impl->m_sigAlgorithm = sigAlgorithm;
}

const CPKIFAlgorithmIdentifierPtr CPKIFCVRequest::GetSigAlgorithm() const
{
    return m_impl->m_sigAlgorithm;
}

void CPKIFCVRequest::SetRequestorName(
    CPKIFGeneralNamePtr& requestorName)
{
    m_impl->m_requestorName = requestorName;
}
const CPKIFGeneralNamePtr CPKIFCVRequest::GetRequestorName() const
{
    return m_impl->m_requestorName;
}

void CPKIFCVRequest::SetResponderName(
    CPKIFGeneralNamePtr& responderName)
{
    m_impl->m_responderName = responderName;
}
const CPKIFGeneralNamePtr CPKIFCVRequest::GetResponderName() const
{
    return m_impl->m_responderName;
}

void CPKIFCVRequest::SetRequestorRef(
    CPKIFGeneralNameListPtr& requestorRef)
{
    m_impl->m_requestorRef = requestorRef;
}
void CPKIFCVRequest::GetRequestorRef(
    CPKIFGeneralNameListPtr& requestorRef) const
{
    requestorRef = m_impl->m_requestorRef;
}

void CPKIFCVRequest::SetRequestorText(
    CPKIFStringPtr& requestorText)
{
    m_impl->m_requestorText = requestorText;
}
const CPKIFStringPtr CPKIFCVRequest::GetRequestorText() const
{
    return m_impl->m_requestorText;
}
void CPKIFCVRequest::SetQuery(
    CPKIFQueryPtr& query)
{
    m_impl->m_query = query;
}
const CPKIFQueryPtr CPKIFCVRequest::GetQuery() const
{
    return m_impl->m_query;
}

CPKIFBufferPtr CPKIFCVRequest::Encode() const
{
    LOG_STRING_DEBUG("CPKIFCVRequest::Encode()", TOOLKIT_SCVP_ASN, 0, this);

    //Whether the message is being created or regenerated after parsing a previous message
    //always create and populate a new request object (use Getxxx functions to access fields).
    //throw bad_alloc
    PKIFSCVPMemoryHelper mhSCVPRequest;
    mhSCVPRequest.pRequest = new CVRequest;
    memset(mhSCVPRequest.pRequest, 0, sizeof(CVRequest));

    //version - hardcode to 1 for the time being (no other versions are supported at this time)
    mhSCVPRequest.pRequest->cvRequestVersion = m_impl->m_version;

    OOCTXT ctxt;
    initContext (&ctxt);

    //Populate query
    PopulateQuery(&mhSCVPRequest.pRequest->query, m_impl->m_query, ctxt);       
    
    //requestorRef
    CPKIFGeneralNameListPtr requestorRef;       
    GetRequestorRef(requestorRef);
    if(requestorRef != (CPKIFGeneralNameList*)NULL && !requestorRef->empty())
    {
        DListNode* curName = NULL;
        //iterate over oids
        CPKIFGeneralNameList::iterator namePos; 
        CPKIFGeneralNameList::iterator nameEnd = requestorRef->end();
        for(namePos = requestorRef->begin(); namePos != nameEnd; ++namePos)
        {
            if(NULL == curName)
            {
                NEW_NODE(curName)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(curName)
            }

            CACX509V3GeneralName* tmpName= new CACX509V3GeneralName;
            memset(tmpName, 0, sizeof(CACX509V3GeneralName));
            

            CopyGeneralName((*tmpName), (*namePos));
            
            curName->data = tmpName;

            SET_HEAD_TAIL_INCREMENT(mhSCVPRequest.pRequest->requestorRef, curName)
        }
        mhSCVPRequest.pRequest->m.requestorRefPresent = 1;
    
    }

    //nonce
    if(m_impl->m_bGenerateNonce)
    {
        m_impl->GenerateNonce();
    }

    const CPKIFBufferPtr nonce = GetNonce();
    if(nonce != (CPKIFBuffer*)NULL)
    {
        mhSCVPRequest.pRequest->requestNonce.data = nonce->GetBuffer();
        mhSCVPRequest.pRequest->requestNonce.numocts = nonce->GetLength();
        mhSCVPRequest.pRequest->m.requestNoncePresent = 1;

    }

    //requestorName
    CPKIFGeneralNamePtr requestorName = GetRequestorName();
    if(requestorName != (CPKIFGeneralName*)NULL)
    {
        mhSCVPRequest.pRequest->m.requestorNamePresent = 1;
        CopyGeneralName(mhSCVPRequest.pRequest->requestorName, requestorName);      
    }

    //responderName
    CPKIFGeneralNamePtr responderName = GetResponderName();
    if(responderName != (CPKIFGeneralName*)NULL)
    {
        mhSCVPRequest.pRequest->m.responderNamePresent = 1;
        CopyGeneralName(mhSCVPRequest.pRequest->responderName, responderName);  
    }

    //extensions XXX*** NOT IMPLEMENTED FOR NOW
    if(!m_impl->m_exts.empty())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_NOT_IMPLEMENTED, "There is currently no support for including extensions in a CPKIFCVRequest");
    }

    //signatureAlg
    const CPKIFAlgorithmIdentifierPtr sigAlgorithm = GetSigAlgorithm();
    if(sigAlgorithm != (CPKIFAlgorithmIdentifier*)NULL)
    {
        CPKIFStringPtr str(new std::string(sigAlgorithm->oid()->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
        CopyOID(&mhSCVPRequest.pRequest->signatureAlg.algorithm, tmpOid);

        if(NULL != tmpOid)
            delete tmpOid;

        if(sigAlgorithm->hasParameters())
        {
            mhSCVPRequest.pRequest->signatureAlg.m.parametersPresent = 1;

            mhSCVPRequest.pRequest->signatureAlg.parameters.data = sigAlgorithm->parameters()->GetBuffer();
            mhSCVPRequest.pRequest->signatureAlg.parameters.numocts = sigAlgorithm->parameters()->GetLength();
        }

        mhSCVPRequest.pRequest->m.signatureAlgPresent = 1;
    }

    //hashAlg
    const CPKIFOIDPtr hashAlgorithm = GetHashAlgorithm();
    if(hashAlgorithm != (CPKIFAlgorithmIdentifier*)NULL)
    {
        CPKIFStringPtr str(new std::string(hashAlgorithm->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
        CopyOID(&mhSCVPRequest.pRequest->hashAlg, tmpOid);

        if(NULL != tmpOid)
            delete tmpOid;

        mhSCVPRequest.pRequest->m.hashAlgPresent = 1;
    }

    //requestorText
    const CPKIFStringPtr text = GetRequestorText();
    if(text != NULL)
    {
        mhSCVPRequest.pRequest->requestorText = strdup(text->c_str());
        mhSCVPRequest.pRequest->m.requestorTextPresent = 1;
    }

    CACASNWRAPPER_CREATE(CVRequest, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhSCVPRequest.pRequest);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;

    freeEncodeBuffer(&ctxt);
    memFreeAll(&ctxt);

    return tmp;
}

void CPKIFCVRequest::Decode(
    CPKIFBufferPtr& msg)
{
    m_impl->ClearAllMembers();

    //if the input is empty - fail now
    if(msg == (CPKIFBuffer*)NULL || 0 == msg->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    m_impl->MakeSCVPR();

    try
    {
        //otherwise try to parse it into the m_impl->m_scvpr member
        const unsigned char* tmpP = msg->GetBuffer();
        (*m_impl->m_scvpr).Decode(msg->GetBuffer(), msg->GetLength());

        m_impl->m_version = (*m_impl->m_scvpr)->cvRequestVersion;

        //Query
        CACASNWRAPPER_CREATE(Query, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpr)->query);
        CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
        if(data1 != NULL)
            delete data1;
        CPKIFQueryPtr tmpQuery(new CPKIFQuery(tmp));

        m_impl->m_query = tmpQuery;

        if(0 < (*m_impl->m_scvpr)->m.requestNoncePresent)
        {
            CPKIFBufferPtr tmpNonce(new CPKIFBuffer((*m_impl->m_scvpr)->requestNonce.data, (*m_impl->m_scvpr)->requestNonce.numocts));

            m_impl->m_nonce = tmpNonce;
        }

        if(0 < (*m_impl->m_scvpr)->m.requestorNamePresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpr)->requestorName);
            CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFGeneralNamePtr tmpName(new CPKIFGeneralName(tmp));
            m_impl->m_requestorName = tmpName;
            if(NULL != data1)
                delete data1;
        }
        

        if(0 < (*m_impl->m_scvpr)->m.responderNamePresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpr)->responderName);
            CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFGeneralNamePtr tmpName(new CPKIFGeneralName(tmp));
            m_impl->m_responderName = tmpName;
            if(NULL != data1)
                delete data1;
        }

        if(0 < (*m_impl->m_scvpr)->m.signatureAlgPresent)
        {
            CPKIFOIDPtr algOID(new CPKIFOID((*m_impl->m_scvpr)->signatureAlg.algorithm.subid, 
                    (*m_impl->m_scvpr)->signatureAlg.algorithm.numids));

            CPKIFBufferPtr algParams; 
            if((*m_impl->m_scvpr)->signatureAlg.m.parametersPresent == 1)
            {
                CPKIFBufferPtr tmpAlgParams(new CPKIFBuffer((*m_impl->m_scvpr)->signatureAlg.parameters.data,
                    (*m_impl->m_scvpr)->signatureAlg.parameters.numocts));

                algParams = tmpAlgParams;
            }
            CPKIFAlgorithmIdentifierPtr sigAlg(new CPKIFAlgorithmIdentifier(algOID, algParams));

            m_impl->m_sigAlgorithm = sigAlg;
        }

        if(0 < (*m_impl->m_scvpr)->m.hashAlgPresent)
        {
            CPKIFOIDPtr hashAlgOID(new CPKIFOID((*m_impl->m_scvpr)->hashAlg.subid, 
                    (*m_impl->m_scvpr)->hashAlg.numids));

            m_impl->m_hashAlgorithm = hashAlgOID;
        }

        if(0 < (*m_impl->m_scvpr)->m.requestorTextPresent)
        {
            CPKIFStringPtr tmpRequestorTest(new std::string((*m_impl->m_scvpr)->requestorText));

            m_impl->m_requestorText = tmpRequestorTest;
        }

        if(0 < (*m_impl->m_scvpr)->m.requestorRefPresent)
        {
            CPKIFGeneralNameListPtr tmpRequestorRef(new CPKIFGeneralNameList());
            DListNode* cur = (*m_impl->m_scvpr)->requestorRef.head;
            while(NULL != cur)
            {
                CACX509V3GeneralName* tmp = (CACX509V3GeneralName*)cur->data;
                CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU);
                ASN1OpenType* data1 = objPDU.Encode(tmp);
                CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
                CPKIFGeneralNamePtr tmpName(new CPKIFGeneralName(tmpBuf));

                if(NULL != data1)
                    delete data1;

                tmpRequestorRef->push_back(tmpName);
        
                cur = cur->next;
            }
            m_impl->m_requestorRef = tmpRequestorRef;

        }

        m_impl->populateExtensionsVector();

    }
    catch(CPKIFException&)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, MSG_DECODE_FAILED);
    }

}

bool CPKIFCVRequest::AreThereAnyUnprocessedCriticalExtensions()
{
    LOG_STRING_DEBUG("CPKIFCVRequest::AreThereAnyUnprocessedCriticalExtensions()", TOOLKIT_OCSP_ASN, 0, this);

    std::vector<CPKIFX509ExtensionPtr>::iterator pos;
    std::vector<CPKIFX509ExtensionPtr>::iterator end = m_impl->m_exts.end();
    for(pos = m_impl->m_exts.begin(); pos != end; ++pos)
    {
        if((*pos)->isCritical())
            return true;
    }

    return false;
}