CVResponse.cpp

Go to the documentation of this file.

#include "CVResponse.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 "ResponseStatus.h"
#include "HashValue.h"
#include "RequestReference.h"
#include "CertReply.h"
#include "ReplyCheck.h"
#include "ReplyWantBack.h"
#include "SCVPCertID.h"
#include "ResponseStatus.h"
#include "ACReference.h"
#include "CertReference.h"


#include "PKIFMessageErrors.h"
#include "PKIFSCVPErrors.h"
#include "PKIFX509Extensions2.h"
#include "SCVP.h"
#include "ToolkitUtils.h"
#include "X509Extension.h"
#include "SCVPException.h"
#include "PolicyInformation.h"
#include "private/PKIFSCVPMemoryHelper.h"
#include "private/SCVPUtils.h"


using namespace std;

struct CPKIFCVResponseImpl
{
    CPKIFCVResponse *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;
    int m_serverConfigurationID;
    CPKIFTimePtr m_producedAt;
    CPKIFResponseStatusPtr m_responseStatus;
    CPKIFValidationPolicyPtr m_validationPolicy; 
    CPKIFRequestReferencePtr m_requestReference;
    CPKIFGeneralNameListPtr m_requestorRef;
    CPKIFGeneralNameListPtr m_requestorName;    
    CPKIFCertReplyListPtr m_replyObjects;
    CPKIFBufferPtr m_respNonce;
    CPKIFBufferPtr m_serverContextInfo;
    CPKIFStringPtr m_requestorText;

    std::vector<CPKIFX509ExtensionPtr> m_exts;

    //member for decoding
    CPKIFASNWrapper<CVResponse>* m_scvpresp;

    void ClearAllMembers();
    void MakeSCVPResp();
    void FreeSCVPResp();

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

    CPKIFCVResponse * m_this;
};

void CPKIFCVResponseImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFCVResponse::CallingAllGets()", TOOLKIT_SCVP_ASN, 0, this);

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

void CPKIFCVResponseImpl::MakeSCVPResp()
{
    LOG_STRING_DEBUG("CPKIFCVResponse::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);

    FreeSCVPResp();
    m_scvpresp = new CPKIFASNWrapper<CVResponse>( BEREncCVResponse, BERDecCVResponse );
}
void CPKIFCVResponseImpl::FreeSCVPResp()
{
    LOG_STRING_DEBUG("CPKIFCVResponse::FreeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);
    if(NULL != m_scvpresp)
        delete m_scvpresp;
    m_scvpresp = NULL;
}

void CPKIFCVResponseImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFCVResponse::ClearAllMembers()", TOOLKIT_SCVP_ASN, 0, this);

    m_version = 1;
    
    CPKIFBufferPtr tmpStr;
    m_respNonce = tmpStr;

    m_serverConfigurationID = 0;

    FreeSCVPResp();
}

void CPKIFCVResponseImpl::populateExtensionsVector()
{
    LOG_STRING_DEBUG("CPKIFCVResponse::populateExtensionsVector()", TOOLKIT_SCVP_ASN, 0, this);

    if(NULL == m_scvpresp || NULL == m_scvpresp->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_scvpresp)->m.cvResponseExtensionsPresent)
    {
        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);
}

CPKIFCVResponse::CPKIFCVResponse()
  :m_impl(new CPKIFCVResponseImpl)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::CPKIFTimeStampRequest()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_parent = this;
    m_impl->m_version = 1;
    m_impl->m_serverConfigurationID = 0;

    m_impl->m_scvpresp = NULL;

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

    m_impl->FreeSCVPResp();

    if (m_impl) 
    {
      delete m_impl;
    }
}

int CPKIFCVResponse::GetVersion() const
{
    return m_impl->m_version;
}
void CPKIFCVResponse::SetVersion(int v)
{
    m_impl->m_version = v;
}

void CPKIFCVResponse::GetEncodedExtensions (
    CPKIFBufferPtr& buf) 
{
    try 
    {
        if ((*m_impl->m_scvpresp)->m.cvResponseExtensionsPresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
            ASN1OpenType *data = extsWrapper.Encode (&(*m_impl->m_scvpresp)->cvResponseExtensions);
            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 CPKIFCVResponse::ExtensionsPresent() const
{
    LOG_STRING_DEBUG("CPKIFCVResponse::ExtensionsPresent()", TOOLKIT_SCVP_ASN, 0, this);

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

void CPKIFCVResponse::GetExtensionByOID(
    const CPKIFOID& oid,    
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != (*m_impl->m_scvpresp)->m.cvResponseExtensionsPresent)
    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;
    }
    }       
}


void CPKIFCVResponse::SetValidationPolicy(
    CPKIFValidationPolicyPtr& validationPolicy)
{
    m_impl->m_validationPolicy = validationPolicy;
}
const CPKIFValidationPolicyPtr CPKIFCVResponse::GetValidationPolicy() const
{
    return m_impl->m_validationPolicy;
}

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

    m_impl->CallingAllGets();
    m_impl->m_respNonce = nonce;
}
const CPKIFBufferPtr CPKIFCVResponse::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("CPKIFCVResponse::GetNonce()", TOOLKIT_SCVP_ASN, 0, this);

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

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

    if(m_impl->m_respNonce == NULL)
    {
        CPKIFBufferPtr t;
        return t;
    }
    else
        return m_impl->m_respNonce;
}

void CPKIFCVResponse::SetProducedAt(
    CPKIFTimePtr& producedAt)
{
    m_impl->m_producedAt = producedAt;
}
const CPKIFTimePtr CPKIFCVResponse::GetProducedAt() const
{
    return m_impl->m_producedAt;
}
void CPKIFCVResponse::SetConfigurationID(
    int confID)
{
    m_impl->m_serverConfigurationID = confID;
}
const int CPKIFCVResponse::GetConfigurationID() const
{
    return m_impl->m_serverConfigurationID;
}

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

void CPKIFCVResponse::SetRequestorName(
    CPKIFGeneralNameListPtr& requestorRef)
{
    m_impl->m_requestorRef = requestorRef;
}
void CPKIFCVResponse::GetRequestorName(
    CPKIFGeneralNameListPtr& requestorRef) const
{
    requestorRef = m_impl->m_requestorRef;
}

void CPKIFCVResponse::SetServerContextInfo( 
    CPKIFBufferPtr& serverContextInfo)
{
    m_impl->m_serverContextInfo = serverContextInfo;
}
const CPKIFBufferPtr CPKIFCVResponse::GetServerContextInfo() const
{
    return m_impl->m_serverContextInfo;
}

void CPKIFCVResponse::SetRequestorText(
    CPKIFStringPtr& requestorText)
{
    m_impl->m_requestorText = requestorText;
}
const CPKIFStringPtr CPKIFCVResponse::GetRequestorText() const
{
    return m_impl->m_requestorText;
}
void CPKIFCVResponse::SetResponseStatus(
    CPKIFResponseStatusPtr& responseStatus)
{
    m_impl->m_responseStatus = responseStatus;
}
const CPKIFResponseStatusPtr CPKIFCVResponse::GetResponseStatus() const
{
    return m_impl->m_responseStatus;
}
void CPKIFCVResponse::SetRequestReference(
    CPKIFRequestReferencePtr& requestReference)
{
    m_impl->m_requestReference = requestReference;
}
const CPKIFRequestReferencePtr CPKIFCVResponse::GetRequestReference() const
{
    return m_impl->m_requestReference;
}
void CPKIFCVResponse::SetReplyObjects(
    CPKIFCertReplyListPtr& replyObjects)
{
    m_impl->m_replyObjects = replyObjects;
}
void CPKIFCVResponse::GetReplyObjects(
    CPKIFCertReplyListPtr& replyObjects) const
{
    replyObjects = m_impl->m_replyObjects;
}

CPKIFBufferPtr CPKIFCVResponse::Encode() const
{
    LOG_STRING_DEBUG("CPKIFCVResponse::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 mhSCVPResponse;
    mhSCVPResponse.pResponse = new CVResponse;
    memset(mhSCVPResponse.pResponse, 0, sizeof(CVResponse));

    OOCTXT ctxt;
    initContext (&ctxt);

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

    const int confID = GetConfigurationID();
    if(0 == confID )
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "Server Configuration ID value not specified.");
    }
    else
    {
        mhSCVPResponse.pResponse->serverConfigurationID = confID;
    }

    //producedAt Time
    CPKIFTimePtr producedAtTime = GetProducedAt();
    if(producedAtTime != (CPKIFTime*)NULL)
    {
        mhSCVPResponse.pResponse->producedAt = producedAtTime->GetTime();
    }
    else
    {
        producedAtTime = CPKIFTime::CurrentTime();
        mhSCVPResponse.pResponse->producedAt = producedAtTime->GetTime();
    }

    //Response Status
    CPKIFResponseStatusPtr responseStatus = GetResponseStatus();
    if(responseStatus != (CPKIFResponseStatus*)NULL)
    {
        int sc = responseStatus->GetStatusCode();
        string mess = responseStatus->GetErrorMessage();

        if(sc != 0)
        {
            mhSCVPResponse.pResponse->responseStatus.m.statusCodePresent = 1;
            mhSCVPResponse.pResponse->responseStatus.statusCode = sc;
        }

        if(mess != "")
        {
            mhSCVPResponse.pResponse->responseStatus.m.errorMessagePresent = 1;
            mhSCVPResponse.pResponse->responseStatus.errorMessage = strdup(mess.c_str());
        }   
    }
    //Validation Policy
    if(m_impl->m_validationPolicy == (CPKIFValidationPolicy*)NULL)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "Server validationPolicy value not specified.");
    }
    else
    {
        PopulateValidationPolicy(&mhSCVPResponse.pResponse->respValidationPolicy, m_impl->m_validationPolicy, ctxt);
        mhSCVPResponse.pResponse->m.respValidationPolicyPresent = 1;
    }
    //RequestReference
    CPKIFRequestReferencePtr requestRef = GetRequestReference();
    if(requestRef != (CPKIFRequestReference*)NULL)
    {   
        mhSCVPResponse.pResponse->m.requestRefPresent = 1;
        CPKIFHashValuePtr hashVal = requestRef->GetHashValue();
        if(hashVal != (CPKIFHashValue*)NULL)
        {
            mhSCVPResponse.pResponse->requestRef.t = T_RequestReference_requestHash;
            mhSCVPResponse.pResponse->requestRef.u.requestHash = new HashValue;
            CPKIFAlgorithmIdentifierPtr algID = hashVal->GetAlgID();
            if(algID != (CPKIFAlgorithmIdentifier*)NULL)
            {
                CPKIFStringPtr str(new std::string(algID->oid()->ToString())); 
                ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
                CopyOID(&mhSCVPResponse.pResponse->requestRef.u.requestHash->algorithm.algorithm, tmpOid);

                if(NULL != tmpOid)
                    delete tmpOid;

                if(algID->hasParameters())
                {
                    mhSCVPResponse.pResponse->requestRef.u.requestHash->algorithm.m.parametersPresent = 1;

                    mhSCVPResponse.pResponse->requestRef.u.requestHash->algorithm.parameters.data = algID->parameters()->GetBuffer();
                    mhSCVPResponse.pResponse->requestRef.u.requestHash->algorithm.parameters.numocts = algID->parameters()->GetLength();
                }

                mhSCVPResponse.pResponse->requestRef.u.requestHash->m.algorithmPresent = 1;
            }

        }
        CPKIFBufferPtr fullRequest = requestRef->GetFullRequest();
        if(fullRequest  != (CPKIFBuffer*)NULL)
        {
            mhSCVPResponse.pResponse->requestRef.t = T_RequestReference_fullRequest;

            mhSCVPResponse.pResponse->requestRef.u.fullRequest = new CVRequest;
            memset(mhSCVPResponse.pResponse->requestRef.u.fullRequest, 0, sizeof(CVRequest));

            setBERDecBufPtr(&ctxt, (unsigned char*)fullRequest->GetBuffer(), fullRequest->GetLength(), NULL, NULL);
            BERDecCVRequest(&ctxt, mhSCVPResponse.pResponse->requestRef.u.fullRequest, ASN1EXPL, NULL);

        }
    }

    //requestorRef
    CPKIFGeneralNameListPtr requestorRef;       
    GetRequestorRef(requestorRef);
    if(requestorRef != (CPKIFGeneralNameList*)NULL)
    {
        PopulateDListWithCACX509V3GeneralName(&mhSCVPResponse.pResponse->requestorRef, requestorRef);
        if(requestorRef->size() > 0)
        {
            mhSCVPResponse.pResponse->m.requestorRefPresent = 1;
        }
    }
    

    //requestorName
    CPKIFGeneralNameListPtr requestorName;      
    GetRequestorName(requestorName);
    if(requestorName != (CPKIFGeneralNameList*)NULL)
    {
        PopulateDListWithCACX509V3GeneralName(&mhSCVPResponse.pResponse->requestorName, requestorName);
        if(requestorName->size() > 0)
        {
            mhSCVPResponse.pResponse->m.requestorNamePresent = 1;
        }
    }
    
    //ReplyObjects
    PopulateReplyObjects(&mhSCVPResponse.pResponse->replyObjects, m_impl->m_replyObjects, ctxt);

    if(m_impl->m_replyObjects->size() > 0)
    {
        mhSCVPResponse.pResponse->m.replyObjectsPresent = 1; 
    }


    //respNonce This might need to chaange to read get the nonce from the request
    const CPKIFBufferPtr nonce = GetNonce();
    if(nonce != (CPKIFBuffer*)NULL)
    {
        mhSCVPResponse.pResponse->respNonce.data = nonce->GetBuffer();
        mhSCVPResponse.pResponse->respNonce.numocts = nonce->GetLength();
        mhSCVPResponse.pResponse->m.respNoncePresent = 1;

    }

    //respNonce This might need to chaange to read get the nonce from the request
    const CPKIFBufferPtr contextInfo = GetServerContextInfo();
    if(contextInfo != (CPKIFBuffer*)NULL)
    {
        mhSCVPResponse.pResponse->serverContextInfo.data = contextInfo->GetBuffer();
        mhSCVPResponse.pResponse->serverContextInfo.numocts = contextInfo->GetLength();
        mhSCVPResponse.pResponse->m.serverContextInfoPresent = 1;

    }

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

    CACASNWRAPPER_CREATE(CVResponse, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhSCVPResponse.pResponse);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;

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

    return tmp;
}

void CPKIFCVResponse::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->MakeSCVPResp();

    try
    {
        (*m_impl->m_scvpresp).Decode(msg->GetBuffer(), msg->GetLength());
        
        //Version
        m_impl->m_version = (*m_impl->m_scvpresp)->cvResponseVersion;

        //serverConfigurationID
        m_impl->m_serverConfigurationID = (*m_impl->m_scvpresp)->serverConfigurationID;

        //ProducedAt
        CPKIFTimePtr tmpTime(new CPKIFTime((*m_impl->m_scvpresp)->producedAt));
        m_impl->m_producedAt = tmpTime;

        CACASNWRAPPER_CREATE(ResponseStatus, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpresp)->responseStatus);
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFResponseStatusPtr tmpRS(new CPKIFResponseStatus(tmpBuf));
        m_impl->m_responseStatus = tmpRS;

        if(0 < (*m_impl->m_scvpresp)->m.respValidationPolicyPresent)
        {
            CACASNWRAPPER_CREATE(ValidationPolicy, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpresp)->respValidationPolicy);          
            CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFValidationPolicyPtr tmpValPol(new CPKIFValidationPolicy(tmpBuf));
        
            m_impl->m_validationPolicy = tmpValPol;
        }

        if(0 < (*m_impl->m_scvpresp)->m.requestRefPresent)
        {
            CACASNWRAPPER_CREATE(RequestReference, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpresp)->requestRef);            
            CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFRequestReferencePtr tmpReqRef(new CPKIFRequestReference(tmpBuf));

            m_impl->m_requestReference = tmpReqRef;
        }

        if(0 < (*m_impl->m_scvpresp)->m.requestorRefPresent)
        {
            m_impl->m_requestorRef = PopulatePKIFGeneralNameList(&(*m_impl->m_scvpresp)->requestorRef); 

        }

        if(0 < (*m_impl->m_scvpresp)->m.requestorNamePresent)
        {
            m_impl->m_requestorName = PopulatePKIFGeneralNameList(&(*m_impl->m_scvpresp)->requestorName);   
        }

        if(0 < (*m_impl->m_scvpresp)->m.respNoncePresent)
        {
            CPKIFBufferPtr tmpNonce(new CPKIFBuffer((*m_impl->m_scvpresp)->respNonce.data, 
                (*m_impl->m_scvpresp)->respNonce.numocts));

            m_impl->m_respNonce = tmpNonce;
        }

        if(0 < (*m_impl->m_scvpresp)->m.serverContextInfoPresent)
        {
            CPKIFBufferPtr tmpBuf(new CPKIFBuffer((*m_impl->m_scvpresp)->serverContextInfo.data, 
                    (*m_impl->m_scvpresp)->serverContextInfo.numocts));

            m_impl->m_serverContextInfo = tmpBuf;
        }

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

        if(0 < (*m_impl->m_scvpresp)->m.replyObjectsPresent)
        {
            CPKIFCertReplyListPtr tmpCertReplyList(new CPKIFCertReplyList());
            DListNode* cur = (*m_impl->m_scvpresp)->replyObjects.head;
            while(NULL != cur)
            {
                CertReply* tmp = (CertReply*)cur->data;
                CACASNWRAPPER_CREATE(CertReply, objPDU);
                ASN1OpenType* data1 = objPDU.Encode(tmp);
                CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
                CPKIFCertReplyPtr tmpCertReply(new CPKIFCertReply(tmpBuf));

                if(NULL != data1)
                    delete data1;

                tmpCertReplyList->push_back(tmpCertReply);
        
                cur = cur->next;
            }
            m_impl->m_replyObjects = tmpCertReplyList;
        }
        m_impl->populateExtensionsVector();
    }
    catch(CPKIFException&)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, MSG_DECODE_FAILED);
    }
}

bool CPKIFCVResponse::AreThereAnyUnprocessedCriticalExtensions()
{
    LOG_STRING_DEBUG("CPKIFCVResponse::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;
}