Query.cpp

Go to the documentation of this file.

#include "PKIFSCVP.h"

#include "ASN1Helper.h"
#include "ToolkitUtils.h"
#include "SCVP.h"
#include "Buffer.h"
#include "AlgorithmIdentifier.h"
#include "PKIFMediators.h"
#include "IPKIFHashContext.h"
#include "IPKIFCryptoMisc.h"
#include "PKIFCryptUtils.h"
#include "PKIFTime.h"
#include "Query.h"
#include "PKIFX509Extensions2.h"
#include "ResponseFlags.h"
#include "Certificate.h"
#include "CertReferences.h"


struct CPKIFQueryImpl 
{
    //function to process extensions
    void populateExtensionsVector();

    CPKIFTimePtr m_validationTime;
    CPKIFTimePtr m_producedAt;
    CPKIFCertificateListPtr m_intermidiateCerts;
    CPKIFBufferPtr m_hashedMessage;
    CPKIFResponseFlagsPtr m_responseFlags;
    CPKIFValidationPolicyPtr m_validationPolicy; 
    CPKIFOIDListPtr m_checks;
    CPKIFOIDListPtr m_wantBack;
    CPKIFCertReferencesPtr m_certRefs;
    CPKIFBufferPtr m_serverContextInfo;
    CPKIFRevocationInfoListPtr m_revInfos;
    
    
    std::vector<CPKIFX509ExtensionPtr> m_exts;

    //member for decoding
    CPKIFASNWrapper<Query>* m_query;

    void ClearAllMembers();
    void MakeSCVPQuery();
    void FreeSCVPQuery();

    //member to maintain state when calling Set functions
    void CallingAllGets();
    
    CPKIFQuery * m_this;
};


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

    populateExtensionsVector();
    FreeSCVPQuery();
}

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

    FreeSCVPQuery();
    m_query = new CPKIFASNWrapper<Query>( BEREncQuery, BERDecQuery);
}
void CPKIFQueryImpl::FreeSCVPQuery()
{
    LOG_STRING_DEBUG("CPKIFQueryImpl::MakeSCVPR()", TOOLKIT_SCVP_ASN, 0, this);
    if(NULL != m_query)
        delete m_query;
    m_query = NULL;
}

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

    FreeSCVPQuery();
}

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

    if(NULL == m_query || NULL == m_query->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_query)->m.queryExtensionsPresent)
    {
        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);
}



CPKIFQuery::CPKIFQuery() :m_impl(new CPKIFQueryImpl)
{
    LOG_STRING_DEBUG("CPKIFQuery::CPKIFQuery()", TOOLKIT_SCVP_ASN, 0, this);

    m_impl->m_query = NULL;

    CPKIFValidationPolicyPtr tmpVP(new CPKIFValidationPolicy);
    m_impl->m_validationPolicy = tmpVP;

    CPKIFValidationPolRefPtr vpr(new CPKIFValidationPolRef(g_id_svp_defaultValPolicy));
    tmpVP->SetValidationPolRef(vpr);
}

CPKIFQuery::CPKIFQuery(
    const CPKIFBufferPtr& name)
  :m_impl (new CPKIFQueryImpl)
{

    //if the input is empty - fail now
    if(name == (CPKIFBuffer*)NULL || 0 == name->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }
    m_impl->m_query = NULL;
    m_impl->MakeSCVPQuery();
    (*m_impl->m_query).Decode(name->GetBuffer(), name->GetLength());


    //CertReferences
    CACASNWRAPPER_CREATE(CertReferences, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(&(*m_impl->m_query)->queriedCerts);         
    CPKIFBufferPtr tmpBuf1(new CPKIFBuffer(data1->data, data1->numocts));
    CPKIFCertReferencesPtr tmpCertRefs(new CPKIFCertReferences(tmpBuf1));
    if(NULL != data1)
        delete data1;
    m_impl->m_certRefs = tmpCertRefs;


    //Validation Policy
    CACASNWRAPPER_CREATE(ValidationPolicy, objPDU2);
    ASN1OpenType* data2 = objPDU2.Encode(&(*m_impl->m_query)->validationPolicy);            
    CPKIFBufferPtr tmpBuf2(new CPKIFBuffer(data2->data, data2->numocts));
    CPKIFValidationPolicyPtr tmpValPol(new CPKIFValidationPolicy(tmpBuf2));
    if(NULL != data2)
        delete data2;

    m_impl->m_validationPolicy = tmpValPol;

    //Response Flags
    
    if(1 == (m_impl->m_query->data()->m.responseFlagsPresent)) {
        CACASNWRAPPER_CREATE(ResponseFlags, objPDU3);
        ASN1OpenType* data3 = objPDU3.Encode(&(*m_impl->m_query)->responseFlags);           
        CPKIFBufferPtr tmpBuf3(new CPKIFBuffer(data3->data, data3->numocts));
        CPKIFResponseFlagsPtr tmpResponseFlags(new CPKIFResponseFlags(tmpBuf3));
        if(NULL != data3)
            delete data3;

        m_impl->m_responseFlags = tmpResponseFlags;
    } else {
        m_impl->m_responseFlags = CPKIFResponseFlagsPtr(new CPKIFResponseFlags());
    }


    //CertChecks
    CPKIFOIDListPtr tmpChecks(new CPKIFOIDList());
    DListNode* cur = (*m_impl->m_query)->checks.head;
    while(NULL != cur)
    {
        ASN1OBJID* tmp = (ASN1OBJID*)cur->data;
        CPKIFOIDPtr tmpOID(new CPKIFOID(tmp->subid, tmp->numids));

        tmpChecks->push_back(tmpOID);

        cur = cur->next;
    }
    m_impl->m_checks = tmpChecks;

    if(0 < (*m_impl->m_query)->m.wantBackPresent)
    {
        CPKIFOIDListPtr tmpWantBack(new CPKIFOIDList());
        DListNode* cur = (*m_impl->m_query)->wantBack.head;
        while(NULL != cur)
        {
            ASN1OBJID* tmp = (ASN1OBJID*)cur->data;
            CPKIFOIDPtr tmpOID(new CPKIFOID(tmp->subid, tmp->numids));

            tmpWantBack->push_back(tmpOID);

            cur = cur->next;
        }
        m_impl->m_wantBack = tmpWantBack;
    }

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

        m_impl->m_serverContextInfo = tmpBuf;
    }
    if(0 < (*m_impl->m_query)->m.validationTimePresent)
    {
        CPKIFTimePtr tmpTime(new CPKIFTime((*m_impl->m_query)->validationTime));

        m_impl->m_validationTime = tmpTime;
    }

    if(0 < (*m_impl->m_query)->m.producedAtPresent)
    {
        CPKIFTimePtr tmpTime(new CPKIFTime((*m_impl->m_query)->producedAt));

        m_impl->m_producedAt = tmpTime;
    }

    if(0 < (*m_impl->m_query)->m.intermediateCertsPresent)
    {
        CPKIFCertificateListPtr certList(new CPKIFCertificateList());
        DListNode* cur = (*m_impl->m_query)->intermediateCerts.head;
        while(NULL != cur)
        {
            ASN1OpenType* tmp = (ASN1OpenType*)cur->data;
            CPKIFCertificatePtr tmpCert(new CPKIFCertificate());
            tmpCert->Decode(tmp->data, tmp->numocts);

            certList->push_back(tmpCert);

            cur = cur->next;
        }
        m_impl->m_intermidiateCerts = certList;
    }

    //RevocationInfos
    if(false /*0 < (*m_impl->m_query)->m.revInfosPresent*/)
    {
        CPKIFRevocationInfoListPtr revInfoList(new CPKIFRevocationInfoList());
        DListNode* cur = (*m_impl->m_query)->revInfos.head;
        while(NULL != cur)
        {
            RevocationInfo* tmp = (RevocationInfo*)cur->data;
            CACASNWRAPPER_CREATE(RevocationInfo, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(tmp);           
            CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
            CPKIFRevocationInfoPtr tmpRevInfo(new CPKIFRevocationInfo(tmpBuf));

            if(NULL != data1)
                delete data1;


            revInfoList->push_back(tmpRevInfo);

            cur = cur->next;
        }
        m_impl->m_revInfos = revInfoList;
    }

    m_impl->populateExtensionsVector();
}

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

    m_impl->FreeSCVPQuery();

    if (m_impl) {
      delete m_impl;
    }   
}

void CPKIFQuery::GetEncodedExtensions (
    CPKIFBufferPtr& buf) 
{
    try 
    {
        if ((*m_impl->m_query)->m.queryExtensionsPresent)
        {
            CACASNWRAPPER_CREATE(CACX509V3Extensions, extsWrapper);
            ASN1OpenType *data = extsWrapper.Encode (&(*m_impl->m_query)->queryExtensions);
            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;
}


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

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

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

void CPKIFQuery::SetValidationTime(
    CPKIFTimePtr& validationTime)
{
    m_impl->m_validationTime = validationTime;
}
const CPKIFTimePtr CPKIFQuery::GetValidationTime() const
{
    return m_impl->m_validationTime;
}
void CPKIFQuery::SetProducedAt(
    CPKIFTimePtr& producedAt)
{
    m_impl->m_producedAt = producedAt;
}
const CPKIFTimePtr CPKIFQuery::GetProducedAt() const
{
    return m_impl->m_producedAt;
}
void CPKIFQuery::SetCertBundle(
    CPKIFCertificateListPtr & intermidiateCerts)
{
    m_impl->m_intermidiateCerts = intermidiateCerts;
}
void CPKIFQuery::GetCertBundle(
    CPKIFCertificateListPtr& intermidiateCerts) const
{
    intermidiateCerts = m_impl->m_intermidiateCerts;
}

void CPKIFQuery::AddToCertBundle(CPKIFCertificatePtr& cert)
{
    m_impl->m_intermidiateCerts->push_back(cert);
}
void CPKIFQuery::SetResponseFlags(
    CPKIFResponseFlagsPtr& responseFlags)
{
    m_impl->m_responseFlags = responseFlags;
}
const CPKIFResponseFlagsPtr CPKIFQuery::GetResponseFlags() const
{
    return m_impl->m_responseFlags;
}
void CPKIFQuery::SetValidationPolicy(
    CPKIFValidationPolicyPtr& validationPolicy)
{
    m_impl->m_validationPolicy = validationPolicy;
}
const CPKIFValidationPolicyPtr CPKIFQuery::GetValidationPolicy() const
{
    return m_impl->m_validationPolicy;
}

void CPKIFQuery::SetChecks(
    CPKIFOIDListPtr& checks) 
{
    m_impl->m_checks = checks;
}

void CPKIFQuery::GetChecks(
    CPKIFOIDListPtr& checks) const 
{
    checks = m_impl->m_checks;
}

void CPKIFQuery::SetWantBack(
    CPKIFOIDListPtr& wantBack) 
{
    m_impl->m_wantBack = wantBack;
}

void CPKIFQuery::GetWantBack(
    CPKIFOIDListPtr& wantBack) const 
{
    wantBack = m_impl->m_wantBack;
}

void CPKIFQuery::SetCertRef(
    CPKIFCertReferencesPtr& certRefs)
{
    m_impl->m_certRefs = certRefs;
}
void CPKIFQuery::GetCertRef(
    CPKIFCertReferencesPtr& certRefs) const
{
    certRefs = m_impl->m_certRefs;
}

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

void CPKIFQuery::SetRevInfos(
    CPKIFRevocationInfoListPtr& revInfos)
{
    m_impl->m_revInfos = revInfos;
}
void CPKIFQuery::GetRevInfos(
    CPKIFRevocationInfoListPtr& revInfos) const
{
    revInfos = m_impl->m_revInfos;
}

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