ValPolResponse.cpp

Go to the documentation of this file.

#include "ValPolResponse.h"
#include "components.h"
#include "ToolkitUtils.h"
#include "Buffer.h"
#include "PKIFSCVPErrors.h"
#include "SCVPException.h"
#include "ASN1Helper.h"
#include "SCVP.h"

#include "AlgorithmIdentifier.h"
#include "Buffer.h"
#include "OID.h"
#include "PKIFTime.h"
#include "ValidationPolicy.h"
#include "Name.h"
#include "RevocationInfo.h"
#include "ReplyCheck.h"
#include "ReplyWantBack.h"
#include "private/PKIFSCVPMemoryHelper.h"
#include "KeyAgreePublicKey.h"
#include "PolicyInformation.h"
#include "PKCReference.h"
#include "Certificate.h"
#include "SCVPCertID.h"
#include "KeyUsage.h"
#include "PKIFMessageErrors.h"
#include "KeyAgreePublicKey.h"
#include "private/SCVPUtils.h"


struct CPKIFValPolResponseImpl 
{   
    int m_vpResponseVersion;
    int m_maxCVRequestVersion;
    int m_maxVPRequestVersion;
    int m_serverConfigurationID;
    CPKIFTimePtr m_thisUpdate;
    CPKIFTimePtr m_nextUpdate;
    CPKIFOIDListPtr m_supportedChecks;
    CPKIFOIDListPtr m_supportedWantBacks;
    CPKIFOIDListPtr m_validationPolicies;
    CPKIFOIDListPtr m_validationAlgs;
    CPKIFOIDListPtr m_authPolicies;
    SCVPResponseTypes m_responseTypes;
    CPKIFValidationPolicyPtr m_defaultPolicyValues; 
    std::bitset<4> m_revocationInfoTypes;
    CPKIFAlgorithmIdentifierListPtr m_signatureGeneration;
    CPKIFAlgorithmIdentifierListPtr m_signatureVerification;
    CPKIFOIDListPtr m_hashAlgorithms;
    CPKIFKeyAgreePublicKeyListPtr m_serverPublicKeys; 
    int m_clockSkew;
    CPKIFBufferPtr m_requestNonce;

    //member for decoding
    CPKIFASNWrapper<ValPolResponse>* m_scvpValPolResp;

    //void PopulateValidationPolicy(ValPolResponse* cvresponse);    //populates CVResponse.query.validationPolicy structure
    //void PopulateKeyUsage(CACX509V3KeyUsage* keyUsageStruct, CPKIFKeyUsagePtr& keyusage);     //populates CACX509V3KeyUsage structure

    void ClearAllMembers();
    void MakeValPolResp();
    void FreeValPolResp();

    void CallingAllGets();

    CPKIFValPolResponse * m_parent;
};

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

    m_parent->GetRequestNonce();
    FreeValPolResp();
}

void CPKIFValPolResponseImpl::MakeValPolResp()
{
    LOG_STRING_DEBUG("CPKIFValPolResponseImpl::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);

    FreeValPolResp();
    m_scvpValPolResp = new CPKIFASNWrapper<ValPolResponse>( BEREncValPolResponse, BERDecValPolResponse );
}

void CPKIFValPolResponseImpl::FreeValPolResp()
{
    LOG_STRING_DEBUG("CPKIFValPolResponseImpl::FreeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);
    if(NULL != m_scvpValPolResp)
        delete m_scvpValPolResp;
    m_scvpValPolResp = NULL;
}

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

    
    CPKIFBufferPtr tmpStr;
    m_requestNonce = tmpStr;

    m_vpResponseVersion = 0;
    m_maxCVRequestVersion = 0;
    m_maxVPRequestVersion = 0;
    m_serverConfigurationID = 0;

    // clock skew defaults to 10, so reset to that instead
    m_clockSkew = 10;

    FreeValPolResp();
}


CPKIFValPolResponse::CPKIFValPolResponse() :m_impl(new CPKIFValPolResponseImpl)
{
    LOG_STRING_DEBUG("CPKIFValPolResponse::CPKIFValPolResponse()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_parent = this;

    m_impl->m_vpResponseVersion = 1;
    m_impl->m_maxCVRequestVersion = 1;
    m_impl->m_maxVPRequestVersion = 1;
    m_impl->m_serverConfigurationID = 0;

    // this was being read in Encode() without being initialized
    m_impl->m_clockSkew = 10;


    m_impl->m_scvpValPolResp = NULL;
}
CPKIFValPolResponse::CPKIFValPolResponse(
    const CPKIFBufferPtr& valPolResponse)
  :m_impl (new CPKIFValPolResponseImpl)
{
    if(valPolResponse == (CPKIFBuffer*)NULL || 0 == valPolResponse->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    CACASNWRAPPER_CREATE(ValPolResponse, objPDU);
    objPDU.Decode(valPolResponse->GetBuffer(), valPolResponse->GetLength());


}
CPKIFValPolResponse::~CPKIFValPolResponse()
{
    LOG_STRING_DEBUG("CPKIFValPolResponse::~CPKIFValPolResponse()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->FreeValPolResp();

    if (m_impl) 
    {
      delete m_impl;
    }
}
int CPKIFValPolResponse::GetVersion() const
{
    return m_impl->m_vpResponseVersion;
}

void CPKIFValPolResponse::SetVersion(int v)
{
    m_impl->m_vpResponseVersion = v;
}
void CPKIFValPolResponse::SetVpResponseVersion(
    int vpResponseVersion)
{
    m_impl->m_vpResponseVersion = vpResponseVersion;
}
const int CPKIFValPolResponse::GetVpResponseVersion() const
{
    return m_impl->m_vpResponseVersion;
}
void CPKIFValPolResponse::SetMaxCVRequestVersion(
    int maxCVRequestVersion)
{
    m_impl->m_maxCVRequestVersion = maxCVRequestVersion;
}
const int CPKIFValPolResponse::GetMaxCVRequestVersion() const
{
    return m_impl->m_maxCVRequestVersion;
}
void CPKIFValPolResponse::SetMaxVPRequestVersion(
    int maxVPRequestVersion)
{
    m_impl->m_maxVPRequestVersion = maxVPRequestVersion;
}
const int CPKIFValPolResponse::GetMaxVPRequestVersion() const
{
    return m_impl->m_maxVPRequestVersion;
}
void CPKIFValPolResponse::SetServerConfigurationID(
    int serverConfigurationID)
{
    m_impl->m_serverConfigurationID = serverConfigurationID;
}
const int CPKIFValPolResponse::GetServerConfigurationID() const
{
    return m_impl->m_serverConfigurationID;
}
void CPKIFValPolResponse::SetThisUpdate(
    const CPKIFTimePtr& thisUpdate)
{
    m_impl->m_thisUpdate = thisUpdate;
}
const CPKIFTimePtr CPKIFValPolResponse::GetThisUpdate() const
{
    return m_impl->m_thisUpdate;
}
void CPKIFValPolResponse::SetSupportedChecks(
    CPKIFOIDListPtr& supportedChecks)
{
    m_impl->m_supportedChecks = supportedChecks;
}
void CPKIFValPolResponse::GetSupportedChecks(
    CPKIFOIDListPtr& supportedChecks)
{
    supportedChecks = m_impl->m_supportedChecks;
}
void CPKIFValPolResponse::SetSupportedWantBacks(
    CPKIFOIDListPtr& supportedWantBacks)
{
    m_impl->m_supportedWantBacks = supportedWantBacks;
}
void CPKIFValPolResponse::GetSupportedWantBacks(
    CPKIFOIDListPtr& supportedWantBacks)
{
    supportedWantBacks = m_impl->m_supportedWantBacks;
}
void CPKIFValPolResponse::SetValidationPolicies(
    CPKIFOIDListPtr& validationPolicies)
{
    m_impl->m_validationPolicies = validationPolicies;
}
void CPKIFValPolResponse::GetValidationPolicies(
    CPKIFOIDListPtr& validationPolicies)
{
    validationPolicies = m_impl->m_validationPolicies;
}
void CPKIFValPolResponse::SetValidationAlgs(
    CPKIFOIDListPtr& validationAlgs)
{
    m_impl->m_validationAlgs = validationAlgs;
}
void CPKIFValPolResponse::GetValidationAlgs(
    CPKIFOIDListPtr& validationAlgs)
{
    validationAlgs = m_impl->m_validationAlgs;
}
void CPKIFValPolResponse::SetAuthPolicies(
    CPKIFOIDListPtr& authPolicies)
{
    m_impl->m_authPolicies = authPolicies;
}
void CPKIFValPolResponse::GetAuthPolicies(
    CPKIFOIDListPtr& authPolicies)
{
    authPolicies = m_impl->m_authPolicies;
}
void CPKIFValPolResponse::SetResponseTypes(
    SCVPResponseTypes responseTypes)
{
    m_impl->m_responseTypes = responseTypes;
}
const SCVPResponseTypes CPKIFValPolResponse::GetResponseTypes() const
{
    return m_impl->m_responseTypes;
}
void CPKIFValPolResponse::SetRespValidationPolicy(
    CPKIFValidationPolicyPtr& respValidationPolicy)
{
    m_impl->m_defaultPolicyValues = respValidationPolicy;
}
const CPKIFValidationPolicyPtr CPKIFValPolResponse::GetRespValidationPolicy() const
{
    return m_impl->m_defaultPolicyValues;
}
void CPKIFValPolResponse::SetRevocationInfoTypes(
    std::bitset<4> revocationInfoTypes)
{
    m_impl->m_revocationInfoTypes = revocationInfoTypes;
}
const std::bitset<4> CPKIFValPolResponse::GetRevocationInfoTypes() const
{
    return m_impl->m_revocationInfoTypes;
}
void CPKIFValPolResponse::SetSignatureGeneration(
    CPKIFAlgorithmIdentifierListPtr & signatureGeneration)
{
    m_impl->m_signatureGeneration = signatureGeneration;
}
void CPKIFValPolResponse::GetSignatureGeneration(
    CPKIFAlgorithmIdentifierListPtr & signatureGeneration)
{
    signatureGeneration = m_impl->m_signatureGeneration;
}
void CPKIFValPolResponse::SetSignatureVerification(
    CPKIFAlgorithmIdentifierListPtr & signatureVerification)
{
    m_impl->m_signatureVerification = signatureVerification;
}
void CPKIFValPolResponse::GetSignatureVerification(
    CPKIFAlgorithmIdentifierListPtr & signatureVerification)
{
    signatureVerification = m_impl->m_signatureVerification;
}
void CPKIFValPolResponse::SetHashAlgorithms(
    CPKIFOIDListPtr& hashAlgorithms)
{
    m_impl->m_hashAlgorithms = hashAlgorithms;
}
void CPKIFValPolResponse::GetHashAlgorithms(
    CPKIFOIDListPtr& hashAlgorithms)
{
    hashAlgorithms = m_impl->m_hashAlgorithms;
}
void CPKIFValPolResponse::SetClockSkew(
    int clockSkew)
{
    m_impl->m_clockSkew = clockSkew;
}
const int CPKIFValPolResponse::GetClockSkew() const
{
    return m_impl->m_clockSkew; 
}

//Optional fields
void CPKIFValPolResponse::SetNextUpdate(
    CPKIFTimePtr& nextUpdate)
{
    m_impl->m_nextUpdate = nextUpdate;
}
const CPKIFTimePtr CPKIFValPolResponse::GetNextUpdate() const
{
    return m_impl->m_nextUpdate;
}
void CPKIFValPolResponse::SetRequestNonce(
    CPKIFBufferPtr& requestNonce)
{
    m_impl->m_requestNonce = requestNonce;
}
const CPKIFBufferPtr CPKIFValPolResponse::GetRequestNonce() const
{
    return m_impl->m_requestNonce;
}
void CPKIFValPolResponse::SetKeyAgreePublicKeys(
    CPKIFKeyAgreePublicKeyListPtr& keyAgreePublicKey)
{
    m_impl->m_serverPublicKeys = keyAgreePublicKey;
}
void CPKIFValPolResponse::GetKeyAgreePublicKeys(
    CPKIFKeyAgreePublicKeyListPtr& keyAgreePublicKey)
{
    keyAgreePublicKey = m_impl->m_serverPublicKeys;
}

CPKIFBufferPtr CPKIFValPolResponse::Encode() const
{
    LOG_STRING_DEBUG("CPKIFValPolResponse::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 mhValPolResponse;
    mhValPolResponse.pValPolResponse = new ValPolResponse;
    memset(mhValPolResponse.pValPolResponse, 0, sizeof(ValPolResponse));

    OOCTXT ctxt;
    initContext (&ctxt);


    if(0 ==  m_impl->m_vpResponseVersion )
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "vpResponseVersion value not specified.");
    }
    else
    {
        mhValPolResponse.pValPolResponse->vpResponseVersion =  m_impl->m_vpResponseVersion;
    }

    if(0 ==  m_impl->m_maxCVRequestVersion )
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "maxCVRequestVersion value not specified.");
    }
    else
    {
        mhValPolResponse.pValPolResponse->maxCVRequestVersion =  m_impl->m_maxCVRequestVersion;
    }

    if(0 ==  m_impl->m_maxVPRequestVersion)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "maxVPRequestVersion value not specified.");
    }
    else
    {
        mhValPolResponse.pValPolResponse->maxVPRequestVersion =  m_impl->m_maxVPRequestVersion;
    }

    if(0 ==  m_impl->m_serverConfigurationID)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "serverConfigurationID value not specified.");
    }
    else
    {
        mhValPolResponse.pValPolResponse->serverConfigurationID =  m_impl->m_serverConfigurationID;
    }
    // default clock skew is 10 minutes per RFC 5055
    if(10 !=  m_impl->m_clockSkew)
    {
        mhValPolResponse.pValPolResponse->clockSkew = m_impl->m_clockSkew;
    }

    if(m_impl->m_thisUpdate != (CPKIFTime*)NULL)
    {
        mhValPolResponse.pValPolResponse->thisUpdate = m_impl->m_thisUpdate->GetTime();
    }
    else
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_REQUIRED_FIELD, "thisUpdate value not specified.");
    }

    if(m_impl->m_nextUpdate != (CPKIFTime*)NULL)
    {
        mhValPolResponse.pValPolResponse->nextUpdate = m_impl->m_nextUpdate->GetTime();

        mhValPolResponse.pValPolResponse->m.nextUpdatePresent = 1;
    }

    PopulateDListWithASN1OBJID(&mhValPolResponse.pValPolResponse->supportedChecks, m_impl->m_supportedChecks);

    PopulateDListWithASN1OBJID(&mhValPolResponse.pValPolResponse->supportedWantBacks, m_impl->m_supportedWantBacks);

    PopulateDListWithASN1OBJID(&mhValPolResponse.pValPolResponse->validationPolicies, m_impl->m_validationPolicies);

    PopulateDListWithASN1OBJID(&mhValPolResponse.pValPolResponse->validationAlgs, m_impl->m_validationAlgs);

    PopulateDListWithASN1OBJID(&mhValPolResponse.pValPolResponse->authPolicies, m_impl->m_authPolicies);

    mhValPolResponse.pValPolResponse->responseTypes = m_impl->m_responseTypes;

    PopulateValidationPolicy(&mhValPolResponse.pValPolResponse->defaultPolicyValues, m_impl->m_defaultPolicyValues, ctxt);

    if(m_impl->m_revocationInfoTypes[FULLCRLS])
    {
        mhValPolResponse.pValPolResponse->revocationInfoTypes.data[0] |= BitMfullCRLs;
        mhValPolResponse.pValPolResponse->revocationInfoTypes.numbits = 1;
    }
    if(m_impl->m_revocationInfoTypes[DELTACRLS])
    {
        mhValPolResponse.pValPolResponse->revocationInfoTypes.data[0] |= BitMdeltaCRLs;
        mhValPolResponse.pValPolResponse->revocationInfoTypes.numbits = 2;
    }
    if(m_impl->m_revocationInfoTypes[INDIRECTCRLS])
    {
        mhValPolResponse.pValPolResponse->revocationInfoTypes.data[0] |= BitMindirectCRLs;
        mhValPolResponse.pValPolResponse->revocationInfoTypes.numbits = 3;
    }
    if(m_impl->m_revocationInfoTypes[OCSPRESPONSES])
    {
        mhValPolResponse.pValPolResponse->revocationInfoTypes.data[0] |= BitMoCSPResponses;
        mhValPolResponse.pValPolResponse->revocationInfoTypes.numbits = 4;
    }

    PopulateDListWithCACX509V3AlgorithmIdentifier(&mhValPolResponse.pValPolResponse->signatureGeneration, m_impl->m_signatureGeneration);

    PopulateDListWithCACX509V3AlgorithmIdentifier(&mhValPolResponse.pValPolResponse->signatureVerification, m_impl->m_signatureVerification);

    PopulateDListWithASN1OBJID(&mhValPolResponse.pValPolResponse->hashAlgorithms, m_impl->m_hashAlgorithms);


    if(m_impl->m_serverPublicKeys!= (CPKIFKeyAgreePublicKeyList*)NULL && !m_impl->m_serverPublicKeys->empty())
    {
        DListNode* cur = NULL;
        //iterate over oids
        CPKIFKeyAgreePublicKeyList::iterator pos;   
        CPKIFKeyAgreePublicKeyList::iterator end = m_impl->m_serverPublicKeys->end();
        for(pos = m_impl->m_serverPublicKeys->begin(); pos != end; ++pos)
        {
            if(NULL == cur)
            {
                NEW_NODE(cur)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(cur)
            }
                KeyAgreePublicKey* tmpKeyAgreePubKey = new KeyAgreePublicKey;
                memset(tmpKeyAgreePubKey, 0, sizeof(KeyAgreePublicKey));

                PopulateKeyAgreePublicKey(&tmpKeyAgreePubKey->algorithm, (*pos)->GetAlgorithm());

                PopulateKeyAgreePublicKey(&tmpKeyAgreePubKey->macAlgorithm, (*pos)->GetMACAlgorithm());

                if((*pos)->GetKDF() != (CPKIFAlgorithmIdentifier*)NULL)
                {       
                    PopulateKeyAgreePublicKey(&tmpKeyAgreePubKey->kDF, (*pos)->GetKDF());

                    tmpKeyAgreePubKey->m.kDFPresent = 1;
                }

                tmpKeyAgreePubKey->publicKey.data = (*pos)->GetPublicKey()->GetBuffer();
                tmpKeyAgreePubKey->publicKey.numbits = (*pos)->GetPublicKey()->GetLength()*8;

            
            cur->data = tmpKeyAgreePubKey;

            SET_HEAD_TAIL_INCREMENT(mhValPolResponse.pValPolResponse->serverPublicKeys, cur)
        }

        mhValPolResponse.pValPolResponse->m.serverPublicKeysPresent = 1;
    }

    if(m_impl->m_requestNonce != (CPKIFBuffer*)NULL)
    {
        mhValPolResponse.pValPolResponse->requestNonce.data = m_impl->m_requestNonce->GetBuffer();
        mhValPolResponse.pValPolResponse->requestNonce.numocts = m_impl->m_requestNonce->GetLength();
        mhValPolResponse.pValPolResponse->m.requestNoncePresent = 1;

    }

    CACASNWRAPPER_CREATE(ValPolResponse, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhValPolResponse.pValPolResponse);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;

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

    return tmp;
}


void CPKIFValPolResponse::Decode(CPKIFBufferPtr& encoded) const
{
    m_impl->ClearAllMembers();

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

    m_impl->MakeValPolResp();

    try
    {
        (*m_impl->m_scvpValPolResp).Decode(encoded->GetBuffer(), encoded->GetLength());

        //vpResponseVersion
        m_impl->m_vpResponseVersion = (*m_impl->m_scvpValPolResp)->vpResponseVersion;

        //maxCVRequestVersion
        m_impl->m_maxCVRequestVersion = (*m_impl->m_scvpValPolResp)->maxCVRequestVersion;

        //maxVPRequestVersion
        m_impl->m_maxVPRequestVersion = (*m_impl->m_scvpValPolResp)->maxVPRequestVersion;

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

        //thisUpdate
        CPKIFTimePtr tmpTime(new CPKIFTime((*m_impl->m_scvpValPolResp)->thisUpdate));
        m_impl->m_thisUpdate = tmpTime;

        //nextUpdate
        if((*m_impl->m_scvpValPolResp)->m.nextUpdatePresent)
        {
            CPKIFTimePtr tmpTime2(new CPKIFTime((*m_impl->m_scvpValPolResp)->nextUpdate));
            m_impl->m_nextUpdate = tmpTime2;
        }

        //supportedChecks
        m_impl->m_supportedChecks = PopulatePKIFOIDList(&(*m_impl->m_scvpValPolResp)->supportedChecks);

        //supportedWantBacks
        m_impl->m_supportedWantBacks = PopulatePKIFOIDList(&(*m_impl->m_scvpValPolResp)->supportedWantBacks);
        
        //validationPolicies
        m_impl->m_validationPolicies = PopulatePKIFOIDList(&(*m_impl->m_scvpValPolResp)->validationPolicies);
        
        //validationAlgs
        m_impl->m_validationAlgs = PopulatePKIFOIDList(&(*m_impl->m_scvpValPolResp)->validationAlgs);

        //authPolicies
        m_impl->m_authPolicies = PopulatePKIFOIDList(&(*m_impl->m_scvpValPolResp)->authPolicies);   
        
        //responseTypes
        switch((*m_impl->m_scvpValPolResp)->responseTypes)
        {
            case 0:
                m_impl->m_responseTypes = CACHED_ONLY;
            case 1:
                m_impl->m_responseTypes = NON_CACHED_ONLY; 
            case 2:
                m_impl->m_responseTypes = CACHED_AND_NON_CACHED;
        }

        //defaultPolicyValues
        CACASNWRAPPER_CREATE(ValidationPolicy, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_scvpValPolResp)->defaultPolicyValues);         
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFValidationPolicyPtr tmpValPol(new CPKIFValidationPolicy(tmpBuf));
    
        m_impl->m_defaultPolicyValues = tmpValPol;
        


        if( (*m_impl->m_scvpValPolResp)->revocationInfoTypes.data[0] & BitMfullCRLs ) 
        {
            m_impl->m_revocationInfoTypes.set(FULLCRLS);
        }
        if( (*m_impl->m_scvpValPolResp)->revocationInfoTypes.data[0] & BitMdeltaCRLs ) 
        {
            m_impl->m_revocationInfoTypes.set(DELTACRLS);
        }
        if( (*m_impl->m_scvpValPolResp)->revocationInfoTypes.data[0] & BitMindirectCRLs ) 
        {
            m_impl->m_revocationInfoTypes.set(INDIRECTCRLS);
        }
        if( (*m_impl->m_scvpValPolResp)->revocationInfoTypes.data[0] & BitMoCSPResponses ) 
        {
            m_impl->m_revocationInfoTypes.set(OCSPRESPONSES);
        }

        //signatureGeneration
        m_impl->m_signatureGeneration = PopulatePKIFAlgorithmIdentifierList(&(*m_impl->m_scvpValPolResp)->signatureGeneration);

        //signatureVerification
        m_impl->m_signatureVerification = PopulatePKIFAlgorithmIdentifierList(&(*m_impl->m_scvpValPolResp)->signatureVerification);



        //hashAlgorithms
        m_impl->m_hashAlgorithms = PopulatePKIFOIDList(&(*m_impl->m_scvpValPolResp)->hashAlgorithms);

        //KeyAgreePublicKey
        if(0 < (*m_impl->m_scvpValPolResp)->m.serverPublicKeysPresent)
        {

            CPKIFKeyAgreePublicKeyListPtr tmpKeyAgreePublicKeyList(new CPKIFKeyAgreePublicKeyList());
            DListNode* cur = (*m_impl->m_scvpValPolResp)->serverPublicKeys.head;
            while(NULL != cur)
            {
                KeyAgreePublicKey* tmp = (KeyAgreePublicKey*)cur->data;
                //defaultPolicyValues
                CACASNWRAPPER_CREATE(KeyAgreePublicKey, objPDU);
                ASN1OpenType* data1 = objPDU.Encode(tmp);           
                CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
                CPKIFKeyAgreePublicKeyPtr tmpKeyAgreePublicKey(new CPKIFKeyAgreePublicKey(tmpBuf));
            
                tmpKeyAgreePublicKeyList->push_back(tmpKeyAgreePublicKey);

                cur = cur->next;

            }
            m_impl->m_serverPublicKeys = tmpKeyAgreePublicKeyList;

        }


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

            m_impl->m_requestNonce = tmpNonce;
        }

        if(10 != (*m_impl->m_scvpValPolResp)->clockSkew)
        {
            m_impl->m_clockSkew = (*m_impl->m_scvpValPolResp)->clockSkew;
        }
    }
    catch(CPKIFException&)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, MSG_DECODE_FAILED);
    }
}