TimeStampRequest.cpp

Go to the documentation of this file.

#include "ASN1Helper.h"
#include "AlgorithmIdentifier.h"
#include "Buffer.h"
#include "MessageImprint.h"
#include "OID.h"

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

#include "PKIFMessageErrors.h"
#include "PKIFTSP.h"
#include "pkiftsperrors.h"
#include "PKIFX509Extensions2.h"
#include "PKIXTSP.h"
#include "TSPException.h"
#include "TimeStampRequest.h"
#include "ToolkitUtils.h"
#include "IPKIFCryptoMisc.h"
#include "PKIFCryptUtils.h"
#include "X509Extension.h"
#include "private/PKIFTSPMemoryHelper.h"


struct CPKIFTimeStampRequestImpl
{
    CPKIFTimeStampRequest *m_parent;

    //function to process extensions
    void populateExtensionsVector();

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

    //members for building
    int m_version;
    CPKIFMessageImprintPtr m_messageImprint;
    CPKIFOIDPtr m_policy;
    CPKIFStringPtr m_nonce;
    bool m_bReqCert;
    std::vector<CPKIFX509ExtensionPtr> m_exts;

    //member for decoding
    CPKIFASNWrapper<PKIFTSPTimeStampReq>* m_tsr;

    void ClearAllMembers();
    void MakeTSR();
    void FreeTSR();

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

    CPKIFTimeStampRequest * m_this;
};

void CPKIFTimeStampRequestImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::CallingAllGets()", TOOLKIT_TSP_ASN, 0, this);


    m_parent->GetVersion();
    m_parent->GetMessageImprint();
    m_parent->GetPolicy();
    m_parent->GetNonce();
    m_parent->GetReqCert();
    populateExtensionsVector();
    FreeTSR();
}

void CPKIFTimeStampRequestImpl::MakeTSR()
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::MakeTSR()", TOOLKIT_TSP_ASN, 0, this);

    FreeTSR();
    m_tsr = new CPKIFASNWrapper<PKIFTSPTimeStampReq>( BEREncPKIFTSPTimeStampReq, BERDecPKIFTSPTimeStampReq );
}
void CPKIFTimeStampRequestImpl::FreeTSR()
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::FreeTSR()", TOOLKIT_TSP_ASN, 0, this);
    if(NULL != m_tsr)
        delete m_tsr;
    m_tsr = NULL;
}

void CPKIFTimeStampRequestImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::ClearAllMembers()", TOOLKIT_TSP_ASN, 0, this);

    m_version = PKIFTSPv1;
    m_bGenerateNonce = false;
    m_bReqCert = false;

    m_mediator = NULL;

    CPKIFMessageImprintPtr tmpMI;
    m_messageImprint = tmpMI;

    CPKIFOIDPtr tmpOID;
    m_policy = tmpOID;
    
    CPKIFStringPtr tmpStr;
    m_nonce = tmpStr;

    FreeTSR();
}

void CPKIFTimeStampRequestImpl::GenerateNonce() const
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::GenerateNonce()", TOOLKIT_TSP_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);
                
        //CPKIFCAPIRaw raw;
        //raw.GenRandom(buf, 20);
    }

    //need to put nonce in Objective format, i.e. ASCII hex preceded by 0x, in a CPKIFStringPtr
    std::string* asciiStr = new std::string();
    asciiStr->reserve(50);
    char* asciiBuf = const_cast<char*>(asciiStr->data());
    asciiBuf[0] = '0';
    asciiBuf[1] = 'x';

    //added 7/25/2004 - strip leading zeroes
    const unsigned char* bufEnd = buf + 20;
    unsigned char* bufP = buf;
    int nonZeroLen = 20;
    while(*bufP == 0x00)
    {
        ++bufP;
        --nonZeroLen;
    }

    //added leading zero handling 6/16/2004
    if(0x80 & bufP[0])
    {
        asciiBuf[2] = '0';
        btoa((char*)bufP, asciiBuf+3, nonZeroLen);
    }
    else
        btoa((char*)bufP, asciiBuf+2, nonZeroLen);

    CPKIFStringPtr tmpNonce(asciiStr);

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

void CPKIFTimeStampRequestImpl::populateExtensionsVector()
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::populateExtensionsVector()", TOOLKIT_TSP_ASN, 0, this);

    if(NULL == m_tsr || NULL == m_tsr->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_tsr)->m.extensionsPresent)
    {
        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 CPKIFTimeStampRequest::GetExtensionByOID(
    const CPKIFOID& oid,    
    CPKIFX509ExtensionPtr& ref)
{
    if(m_impl->m_exts.empty() && 0 != (*m_impl->m_tsr)->m.extensionsPresent)
    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;
    }
    }       
}

CPKIFTimeStampRequest::CPKIFTimeStampRequest()
  :m_impl(new CPKIFTimeStampRequestImpl)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::CPKIFTimeStampRequest()", TOOLKIT_TSP_ASN, 0, this);

    m_impl->m_parent = this;
    m_impl->m_version = PKIFTSPv1;
    m_impl->m_bGenerateNonce = false;
    m_impl->m_bReqCert = false;

    m_impl->m_tsr = NULL;
    m_impl->m_mediator = NULL;

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

    m_impl->FreeTSR();

    if (m_impl) 
    {
      delete m_impl;
    }
}

int CPKIFTimeStampRequest::GetVersion() const
{
    if(NULL != m_impl->m_tsr && NULL != (*m_impl->m_tsr).data() && m_impl->m_version != (*m_impl->m_tsr)->version)
    {
        LOG_STRING_DEBUG("CPKIFTimeStampRequest::GetVersion()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFTimeStampRequest* nonConst = const_cast<CPKIFTimeStampRequest*>(this);
        nonConst->m_impl->m_version = (*m_impl->m_tsr)->version;
    }

    return m_impl->m_version;
}
void CPKIFTimeStampRequest::SetMessageImprint(
    CPKIFMessageImprintPtr& messageImprint)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::SetMessageImprint(CPKIFMessageImprintPtr& messageImprint)", TOOLKIT_TSP_ASN, 0, this);

    //m_impl->CallingAllGets();
    m_impl->m_messageImprint = messageImprint;
}
CPKIFMessageImprintPtr CPKIFTimeStampRequest::GetMessageImprint() const
{
    //if NULL and the m_impl->m_tsr member is not NULL then we have parsed a message
    //and need to return the message imprint from it (otherwise we either haven't
    //parsed anything or are building a message and should simply return
    //the m_impl->m_messageImprint member)
    if(m_impl->m_messageImprint == (CPKIFMessageImprint*)NULL && NULL != m_impl->m_tsr && NULL != (*m_impl->m_tsr).data())
    {
        LOG_STRING_DEBUG("CPKIFTimeStampRequest::GetMessageImprint()", TOOLKIT_TSP_ASN, 0, this);

        CACASNWRAPPER_CREATE(PKIFTSPMessageImprint, tmiWrapper);
        ASN1OpenType *data  = tmiWrapper.Encode(&(*m_impl->m_tsr)->messageImprint);
        CPKIFBufferPtr miBuf(new CPKIFBuffer(data->data, data->numocts));

        CPKIFMessageImprint* tmpMI = new CPKIFMessageImprint(miBuf);
        //CPKIFMessageImprint* tmpMI = new CPKIFMessageImprint((*m_impl->m_tsr)->messageImprint);
        CPKIFMessageImprintPtr tmpRef(tmpMI); 

        CPKIFTimeStampRequest* nonConst = const_cast<CPKIFTimeStampRequest*>(this);
        nonConst->m_impl->m_messageImprint = tmpRef;

        if (data)
        {
          delete data;
        }
    }

    return m_impl->m_messageImprint;
}
bool CPKIFTimeStampRequest::ExtensionsPresent() const
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::ExtensionsPresent()", TOOLKIT_TSP_ASN, 0, this);

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

void CPKIFTimeStampRequest::SetPolicy(
    CPKIFOIDPtr& policy)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::SetPolicy(CPKIFOIDPtr& policy)", TOOLKIT_TSP_ASN, 0, this);

    //m_impl->CallingAllGets();
    m_impl->m_policy = policy;
}
CPKIFOIDPtr CPKIFTimeStampRequest::GetPolicy() const
{
    //if NULL and the m_impl->m_tsr member is not NULL then we have parsed a message
    //and need to return the policy from it (otherwise we either haven't
    //parsed anything or are building a message and should simple return
    //the m_impl->m_policy member)
    if(m_impl->m_policy == (CPKIFOID*)NULL && NULL != m_impl->m_tsr && (*m_impl->m_tsr)->m.reqPolicyPresent)
    {
        LOG_STRING_DEBUG("CPKIFTimeStampRequest::GetPolicy()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFOID* tmpPolicy = new CPKIFOID((*m_impl->m_tsr)->reqPolicy.subid, (*m_impl->m_tsr)->reqPolicy.numids);
        CPKIFOIDPtr tmpRef(tmpPolicy); 

        CPKIFTimeStampRequest* nonConst = const_cast<CPKIFTimeStampRequest*>(this);
        nonConst->m_impl->m_policy = tmpRef;
    }

    return m_impl->m_policy;
}

void CPKIFTimeStampRequest::SetNonce(
    CPKIFStringPtr& nonce)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::SetNonce(CPKIFStringPtr& nonce)", TOOLKIT_TSP_ASN, 0, this);

    //m_impl->CallingAllGets();
    m_impl->m_nonce = nonce;
}
const char* CPKIFTimeStampRequest::GetNonce() const
{
    //corrected casting of NULL 6/16/2004
    if(m_impl->m_nonce == (std::string*)NULL && NULL != m_impl->m_tsr && (*m_impl->m_tsr)->m.noncePresent)
    {
        LOG_STRING_DEBUG("CPKIFTimeStampRequest::GetNonce()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFStringPtr tmpStr(new std::string((char*)(*m_impl->m_tsr)->nonce));

        CPKIFTimeStampRequest* nonConst = const_cast<CPKIFTimeStampRequest*>(this);
        nonConst->m_impl->m_nonce = tmpStr;
    }

    if(m_impl->m_nonce == NULL)
        return NULL;
    else
        return m_impl->m_nonce->c_str();
}
void CPKIFTimeStampRequest::SetGenerateNonce(
    bool generateNonce, 
    IPKIFMediator* m)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::SetGenerateNonce(bool generateNonce, IPKIFMediator* m)", TOOLKIT_TSP_ASN, 0, this);

    //m_impl->CallingAllGets();
    m_impl->m_bGenerateNonce = generateNonce;
    m_impl->m_mediator = m;
}
bool CPKIFTimeStampRequest::GetGenerateNonce() const
{
    return m_impl->m_bGenerateNonce;
}
void CPKIFTimeStampRequest::SetReqCert(
    bool reqCert)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::SetReqCert(bool reqCert)", TOOLKIT_TSP_ASN, 0, this);

    //m_impl->CallingAllGets();
    m_impl->m_bReqCert = reqCert;
}
bool CPKIFTimeStampRequest::GetReqCert() const
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::GetReqCert()", TOOLKIT_TSP_ASN, 0, this);

    CPKIFTimeStampRequest* nonConst = const_cast<CPKIFTimeStampRequest*>(this);
    if( NULL != m_impl->m_tsr && 0 != (*m_impl->m_tsr)->certReq)
        nonConst->m_impl->m_bReqCert = true;
    else
        nonConst->m_impl->m_bReqCert = false;
    return m_impl->m_bReqCert;
}

//void CPKIFTimeStampRequest::AddExtension(CPKIFX509ExtensionPtr& ext)
//{
//  CallingAllGets();
//  m_exts.push_back(ext);
//}
CPKIFBufferPtr CPKIFTimeStampRequest::Encode() const
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::Encode()", TOOLKIT_TSP_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
    PKIFTSPMemoryHelper mhTSPRequest;
    mhTSPRequest.pRequest = new PKIFTSPTimeStampReq;
    memset(mhTSPRequest.pRequest, 0, sizeof(PKIFTSPTimeStampReq));

    //version - hardcode to 1 for the time being
    mhTSPRequest.pRequest->version = PKIFTSPv1;

    //messageImprint
    CPKIFMessageImprintPtr mi = GetMessageImprint();
    if(mi == (CPKIFMessageImprint*)NULL)
    {
        throw CPKIFTSPException(TOOLKIT_TSP, TSP_MISSING_REQUIRED_FIELD, "MessageImprint value not specified.");
    }
    else
    {
        //hash alg
        mhTSPRequest.pRequest->messageImprint.hashAlgorithm.m.parametersPresent = 1;
        mhTSPRequest.pRequest->messageImprint.hashAlgorithm.parameters.data = g_nullParams;
        mhTSPRequest.pRequest->messageImprint.hashAlgorithm.parameters.numocts = 2;
        CPKIFStringPtr str2(new std::string(mi->GetHashAlgorithm()->oid()->ToString()));
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str2);

        CopyOID(&mhTSPRequest.pRequest->messageImprint.hashAlgorithm.algorithm, tmpOid);

        if(tmpOid != NULL)
            delete tmpOid;
        //mhTSPRequest.pRequest->messageImprint.hashAlgorithm.algorithm = *(mi->GetHashAlgorithm()->oid()->raw());

        //hashedMessage
        mhTSPRequest.pRequest->messageImprint.hashedMessage.data = mi->GetHashedMessage()->GetBuffer();
        mhTSPRequest.pRequest->messageImprint.hashedMessage.numocts = mi->GetHashedMessage()->GetLength();
    }

    //reqPolicy
    CPKIFOIDPtr policy = GetPolicy();
    if(policy != (CPKIFOID*)NULL)
    {
        CPKIFStringPtr str(new std::string(policy->ToString()));
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);

        CopyOID(&mhTSPRequest.pRequest->reqPolicy, tmpOid);

        if( NULL != tmpOid )
            delete tmpOid;

        //mhTSPRequest.pRequest->reqPolicy = *policy->raw();
        mhTSPRequest.pRequest->m.reqPolicyPresent = 1;
    }

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

    const char* nonce = GetNonce();
    if(NULL != nonce)
    {
        mhTSPRequest.pRequest->nonce = (PKIFTSPTSPNonce)nonce;
        mhTSPRequest.pRequest->m.noncePresent = 1;
    }

    //certReq
    if(m_impl->m_bReqCert)
    {
        //do not set when false (default encoding will not be encoded anyway)
        mhTSPRequest.pRequest->certReq = 1;
    }

    //extensions
    if(!m_impl->m_exts.empty())
    {
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, COMMON_NOT_IMPLEMENTED, "There is currently no support for including extensions in a CPKIFTimeStampRequest");
    }

    CACASNWRAPPER_CREATE(PKIFTSPTimeStampReq, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhTSPRequest.pRequest);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;
    return tmp;
}
void CPKIFTimeStampRequest::Decode(
    CPKIFBufferPtr& msg)
{
    LOG_STRING_DEBUG("CPKIFTimeStampRequest::Decode(CPKIFBufferPtr& msg)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->ClearAllMembers();

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

    m_impl->MakeTSR();

    try
    {
        //otherwise try to parse it into the m_impl->m_tsr member
        (*m_impl->m_tsr).Decode(msg->GetBuffer(), msg->GetLength());
    }
    catch(CPKIFException&)
    {
        //delete e;
        //changed error code 3/2/2004
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, MSG_DECODE_FAILED);
    }
}

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