TBSRequest.cpp

Go to the documentation of this file.

#include "TBSRequest.h"

#include "OID.h"
#include "Buffer.h"
#include "GeneralName.h"
#include "Request.h"
#include "CertID.h"
#include "X509Extension.h"
#include "AlgorithmIdentifier.h"
#include "PKIFOCSPConstants.h"

#include "ToolkitUtils.h"
//#include "PKIFCMS.h" //for NEW_NODE, etc. macros
#include "PKIFX509Extensions2.h"

#ifdef _WIN32
#include "PKIFCAPIRaw.h"
#endif

#include "ASN1Helper.h"
#include "PKIFOCSPMemoryHelper.h"

#include "OCSP.h"

// adding during porting
#include "IPKIFCryptoMisc.h"
#include "PKIFCryptUtils.h"

#include <iterator>

using namespace std;


struct CPKIFTBSRequestImpl
{
    CPKIFTBSRequestImpl ();
    CPKIFTBSRequestImpl (CPKIFTBSRequest  *p);
    CPKIFTBSRequest* m_parent;
    void populateExtensionsVector(CPKIFASNWrapper<TBSRequest>& r);
    std::vector<CPKIFX509ExtensionPtr> m_exts;
    CPKIFASNWrapper<TBSRequest> m_tBSRequest;

    //convenience goo for auto-nonce generation
    bool m_bGenerateNonce;
    void GenerateNonce() const; //logical const
    IPKIFMediator* m_mediator;
    CPKIFBufferPtr m_nonce;

    int m_version;
    CPKIFGeneralNamePtr m_requestorName;
    CPKIFRequestList m_requests;

    CPKIFTBSRequest * m_this;
};
CPKIFTBSRequestImpl::CPKIFTBSRequestImpl ()
: m_tBSRequest(BEREncTBSRequest, BERDecTBSRequest)
{
    m_parent = NULL;
}
CPKIFTBSRequestImpl::CPKIFTBSRequestImpl (CPKIFTBSRequest  *p) 
: m_tBSRequest(BEREncTBSRequest, BERDecTBSRequest)
{
    m_parent = p;
}

CPKIFTBSRequest::CPKIFTBSRequest()
    :m_impl (new CPKIFTBSRequestImpl)
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::CPKIFTBSRequest()", TOOLKIT_OCSP_ASN, 0, this);

    m_impl->m_parent = this;
    //added 7/25/2004
    m_impl->m_version = 0;

    m_impl->m_bGenerateNonce = true;
    m_impl->m_mediator = NULL;
    m_impl->m_this = this;
}
CPKIFTBSRequest::CPKIFTBSRequest(
    const CPKIFBufferPtr& r)
    :m_impl (new CPKIFTBSRequestImpl)
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::CPKIFTBSRequest(TBSRequest& r)", TOOLKIT_OCSP_ASN, 0, this);

    m_impl->m_this = this;
    
    m_impl->m_tBSRequest.Decode(r->GetBuffer(), r->GetLength());

    m_impl->m_parent = this;
    m_impl->m_bGenerateNonce = false;
    m_impl->m_mediator = NULL;

    m_impl->m_version = m_impl->m_tBSRequest->version;

    if(m_impl->m_tBSRequest->m.requestorNamePresent)
    {
        CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU2);
        ASN1OpenType* data1 = objPDU2.Encode(&(m_impl->m_tBSRequest->requestorName));
        CPKIFBufferPtr tmpBuf;
        if (data1 != NULL)
        {
             tmpBuf = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
            delete data1;
        }
            //CPKIFGeneralNamePtr tmpGN(new CPKIFGeneralName(m_impl->m_tBSRequest->requestorName));
        CPKIFGeneralNamePtr tmpGN(new CPKIFGeneralName(tmpBuf));
        m_impl->m_requestorName = tmpGN;
            
    }

    if(0 < m_impl->m_tBSRequest->requestList.count)
    {
        DListNode* cur =m_impl->m_tBSRequest->requestList.head;
        while(NULL != cur)
        {
            Request* tmpNode = (Request*)cur->data;
            CACASNWRAPPER_CREATE(Request, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(tmpNode);
            CPKIFBufferPtr buffPtr;
            if(NULL != data1)
            {
                buffPtr = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
                delete data1;
            }
            //CPKIFRequestPtr tmpReq(new CPKIFRequest(*tmpNode));
            CPKIFRequestPtr tmpReq(new CPKIFRequest(buffPtr));
            m_impl->m_requests.push_back(tmpReq);
    
            cur = cur->next;
        }
    }

    if(m_impl->m_tBSRequest->m.requestExtensionsPresent)
    {
        m_impl->populateExtensionsVector(m_impl->m_tBSRequest);
    }

    
}
void CPKIFTBSRequest::GetRequests(
    CPKIFRequestList& reqs)
{
    copy(m_impl->m_requests.begin(), m_impl->m_requests.end(), back_inserter(reqs));
}

void CPKIFTBSRequestImpl::populateExtensionsVector(
    CPKIFASNWrapper<TBSRequest>& r)
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::populateExtensionsVector(TBSRequest& r)", TOOLKIT_OCSP_ASN, 0, this);

    m_exts.clear();

    if(0 == r->m.requestExtensionsPresent)
        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);
}

//this function is for use when retrieving an extension for which no proper class exists
void CPKIFTBSRequest::GetExtension(
    const CPKIFOID& oid,
    CPKIFX509ExtensionPtr& ref)
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::GetExtension(const CPKIFOID& oid, CPKIFX509ExtensionPtr& ref)", TOOLKIT_OCSP_ASN, 0, this);

    vector<CPKIFX509ExtensionPtr>::iterator pos;
    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;
        }
    }       
}
CPKIFTBSRequest::~CPKIFTBSRequest()
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::~CPKIFTBSRequest()", TOOLKIT_OCSP_ASN, 0, this);

    delete m_impl;
    m_impl = NULL;
}

//version
int CPKIFTBSRequest::GetVersion() const
{
    return m_impl->m_version;
}

//requestorName
void CPKIFTBSRequest::SetRequestorName(
    CPKIFGeneralNamePtr& gn)
{
    m_impl->m_requestorName = gn;
}
CPKIFGeneralNamePtr CPKIFTBSRequest::GetRequestorName() const
{
    return m_impl->m_requestorName;
}
void CPKIFTBSRequest::AddRequest(
    CPKIFRequestPtr& request)
{
    m_impl->m_requests.push_back(request);
}

//nonce is set in binary form
void CPKIFTBSRequest::SetNonce(
    CPKIFBufferPtr& nonce)
{
    m_impl->m_nonce = nonce;
}
CPKIFBufferPtr CPKIFTBSRequest::GetNonce() const
{
    if(m_impl->m_nonce == (CPKIFBuffer*)NULL && m_impl->m_bGenerateNonce)
        m_impl->GenerateNonce();
    return m_impl->m_nonce;
}
void CPKIFTBSRequest::SetGenerateNonce(
    bool generateNonce, 
    IPKIFMediator* m)
{
    m_impl->m_bGenerateNonce = generateNonce;
    m_impl->m_mediator = m;
}
bool CPKIFTBSRequest::GetGenerateNonce() const
{
    return m_impl->m_bGenerateNonce;
}
CPKIFBufferPtr CPKIFTBSRequest::Encode()
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::Encode()", TOOLKIT_OCSP_ASN, 0, this);

    PKIFOCSPMemoryHelper mhOCSPRequest;
    mhOCSPRequest.pTBSRequest = new TBSRequest;
    memset(mhOCSPRequest.pTBSRequest, 0, sizeof(TBSRequest));

    //requestorName
    if(m_impl->m_requestorName != (CPKIFGeneralName*)NULL)
    {
        mhOCSPRequest.pTBSRequest->m.requestorNamePresent = 1;
        CopyGeneralName(mhOCSPRequest.pTBSRequest->requestorName, m_impl->m_requestorName);
    }
    else
        mhOCSPRequest.pTBSRequest->m.requestorNamePresent = 0;

    //requestList
    mhOCSPRequest.pTBSRequest->requestList.count = 0;

    DListNode* cur = NULL;
    CPKIFRequestList::iterator pos;
    CPKIFRequestList::iterator end = m_impl->m_requests.end();
    for(pos = m_impl->m_requests.begin(); pos != end; ++pos)
    {
        if(NULL == cur)
        {
            NEW_NODE(cur)
        }
        else
        {
            NEW_NEXT_AND_ADVANCE(cur)
        }

        Request* tmpRequest = new Request;
        cur->data = tmpRequest;
        CPKIFCertIDPtr certID = (*pos)->GetCertID();

        tmpRequest->m.singleRequestExtensionsPresent = 0;

        //digest alg
        tmpRequest->reqCert.hashAlgorithm.m.parametersPresent = 1;
        tmpRequest->reqCert.hashAlgorithm.parameters.data = g_nullParams;
        tmpRequest->reqCert.hashAlgorithm.parameters.numocts = 2;

        CPKIFStringPtr str(new std::string(certID->GetHashAlg()->oid()->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
        //tmpRequest->reqCert.hashAlgorithm.algorithm = *(certID->GetHashAlg()->oid()->raw());
        CopyOID(&tmpRequest->reqCert.hashAlgorithm.algorithm, tmpOid);
        if(NULL != tmpOid)
            delete tmpOid;
        //tmpRequest->reqCert.hashAlgorithm.algorithm = *tmpOid;

        //issuerKeyHash
        tmpRequest->reqCert.issuerKeyHash.data = certID->GetIssuerKeyHash()->GetBuffer();
        tmpRequest->reqCert.issuerKeyHash.numocts = certID->GetIssuerKeyHash()->GetLength();

        //issuerNameHash
        tmpRequest->reqCert.issuerNameHash.data = certID->GetIssuerNameHash()->GetBuffer();
        tmpRequest->reqCert.issuerNameHash.numocts = certID->GetIssuerNameHash()->GetLength();

        //serialNumber
        tmpRequest->reqCert.serialNumber = certID->GetSerialNumber();

        SET_HEAD_TAIL_INCREMENT(mhOCSPRequest.pTBSRequest->requestList, cur)
    }

    //extensions (i.e. nonce)
    mhOCSPRequest.pTBSRequest->m.requestExtensionsPresent = 0;
    CPKIFBufferPtr nonce = GetNonce();
    if(nonce != (CPKIFBuffer*)NULL)
    {
        mhOCSPRequest.pTBSRequest->m.requestExtensionsPresent = 1;

        cur = NULL;
        if(NULL == cur)
        {
            NEW_NODE(cur)
        }

        CACX509V3Extension* tmpExt = new CACX509V3Extension;
        cur->data = tmpExt;
        tmpExt->critical = 0;
        CPKIFStringPtr str(new std::string(g_ocspNonce->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
        CopyOID(&tmpExt->extnID, tmpOid);
        if(NULL != tmpOid)
                delete tmpOid;
        //tmpExt->extnID = *tmpOid;
        //tmpExt->extnID = *g_ocspNonce->raw();
        tmpExt->extnValue.data = m_impl->m_nonce->GetBuffer();
        tmpExt->extnValue.numocts = m_impl->m_nonce->GetLength();

        SET_HEAD_TAIL_INCREMENT(mhOCSPRequest.pTBSRequest->requestExtensions, cur)
    }

    CACASNWRAPPER_CREATE(TBSRequest, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhOCSPRequest.pTBSRequest);

    if (data1 != NULL)
    {
      CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
      delete data1;
      return tmp;
    }
    else 
    {
      CPKIFBufferPtr tmp(new CPKIFBuffer());
      delete data1;
      return tmp;
    }
}
void CPKIFTBSRequestImpl::GenerateNonce() const
{
    LOG_STRING_DEBUG("CPKIFTBSRequest::GenerateNonce()", TOOLKIT_OCSP_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);
    }

    KeyHash n;
    memset(&n, 0x00, sizeof(KeyHash));
    n.data = new unsigned char[20];
    memcpy((void *)n.data, buf, 20);
    n.numocts = 20;
    //Using KeyHash structure to encode nonce as an OCTET STRING
    CACASNWRAPPER_CREATE(KeyHash, nonceWrapper);
    ASN1OpenType *data = nonceWrapper.Encode (&n);
    CPKIFBufferPtr tmpbuf(new CPKIFBuffer(data->data, data->numocts));
    delete data;
    if(n.data != NULL)
        delete[] n.data;

    //CPKIFBufferPtr tmpbuf(new CPKIFBuffer(buf, 20));

    CPKIFTBSRequest* nonConst = const_cast<CPKIFTBSRequest*>(m_parent);
    nonConst->m_impl->m_nonce = tmpbuf;
}


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

//this function is for use when retrieving an extension for which no proper class exists
void CPKIFTBSRequest::GetExtensionByOID(
    const CPKIFOID& oid,
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != m_impl->m_tBSRequest->requestExtensions.count)
        m_impl->populateExtensionsVector(m_impl->m_tBSRequest);

    vector<CPKIFX509ExtensionPtr>::iterator pos;
    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;
        }
    }       
}