TSTInfo.cpp

Go to the documentation of this file.

#include "ASN1Helper.h"
#include "Accuracy.h"
#include "AlgorithmIdentifier.h"
#include "Buffer.h"
#include "GeneralName.h"
#include "MessageImprint.h"
#include "OID.h"
#include "PKIFTSP.h"
#include "pkiftsperrors.h"
#include "PKIFTime.h"
#include "PKIFX509Extensions2.h"
#include "PKIXTSP.h"
#include "TSPException.h"
#include "TSTInfo.h"
#include "ToolkitUtils.h"
#include "X509Extension.h"
#include "private/PKIFTSPMemoryHelper.h"


struct CPKIFTSTInfoImpl
{
    CPKIFTSTInfo *m_parent;

    //function to process extensions
    void populateExtensionsVector();

    int m_version;
    CPKIFMessageImprintPtr m_messageImprint;
    CPKIFOIDPtr m_policy;
    CPKIFStringPtr m_nonce;

    CPKIFStringPtr m_serialNum;
    CPKIFTimePtr m_time;

    CPKIFAccuracyPtr m_accuracy;
    bool m_bOrdering;
    CPKIFGeneralNamePtr m_tsa;

    ASN1CGeneralizedTime* m_gt;

    std::vector<CPKIFX509ExtensionPtr> m_exts;

    //member for decoding
    CPKIFASNWrapper<PKIFTSPTSTInfo>* m_tstInfo;

    void ClearAllMembers();
    void MakeTSTInfo();
    void FreeTSTInfo();

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

void CPKIFTSTInfoImpl::populateExtensionsVector()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::populateExtensionsVector()", TOOLKIT_TSP_ASN, 0, this);

    if(NULL == m_tstInfo->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_tstInfo)->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_parent->IPKIFHasExtensions::GetExtensions (mediator, m_exts);

}

void CPKIFTSTInfoImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::ClearAllMembers()", TOOLKIT_TSP_ASN, 0, this);

    CPKIFMessageImprintPtr tmpMI;
    m_messageImprint = tmpMI;

    CPKIFOIDPtr tmpPolicy;
    m_policy = tmpPolicy;

    CPKIFStringPtr tmpNonce; 
    m_nonce = tmpNonce;
    m_serialNum = tmpNonce;

    CPKIFTimePtr tmpTime;
    m_time = tmpTime;

    CPKIFAccuracyPtr tmpAccuracy;
    m_accuracy = tmpAccuracy;

    CPKIFGeneralNamePtr tmpGN;
    m_tsa = tmpGN;

    m_exts.clear();
    m_version = 1;
    m_bOrdering = false;
    FreeTSTInfo();
}

void CPKIFTSTInfoImpl::MakeTSTInfo()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::MakeTSTInfo()", TOOLKIT_TSP_ASN, 0, this);

    FreeTSTInfo();

    //throw bad_alloc
    m_tstInfo = new CPKIFASNWrapper<PKIFTSPTSTInfo>( BEREncPKIFTSPTSTInfo, BERDecPKIFTSPTSTInfo );
}
void CPKIFTSTInfoImpl::FreeTSTInfo()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::FreeTSTInfo()", TOOLKIT_TSP_ASN, 0, this);

    if(NULL != m_tstInfo)
        delete m_tstInfo;
    m_tstInfo = NULL;
}
void CPKIFTSTInfoImpl::CallingAllGets()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::CallingAllGets()", TOOLKIT_TSP_ASN, 0, this);

#ifdef WIN32
    GetVersion();
#endif
    m_parent->GetPolicy();
    m_parent->GetMessageImprint();
    m_parent->GetSerialNumber();
    m_parent->GetGeneralizedTime();
    m_parent->GetAccuracy();
    m_parent->GetOrdering();
    m_parent->GetNonce();
    m_parent->GetTSA();
    FreeTSTInfo();
}


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

CPKIFTSTInfo::CPKIFTSTInfo()
  :m_impl(new CPKIFTSTInfoImpl)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::CPKIFTSTInfo()", TOOLKIT_TSP_ASN, 0, this);

    m_impl->m_parent = this;
    m_impl->m_version = 1;
    m_impl->m_bOrdering = false;
    m_impl->m_tstInfo = NULL;
}
CPKIFTSTInfo::~CPKIFTSTInfo()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::~CPKIFTSTInfo()", TOOLKIT_TSP_ASN, 0, this);
    
    if (m_impl)
    {
      m_impl->FreeTSTInfo();

      delete m_impl;
    }
}

//version - always set to 1 for now
int CPKIFTSTInfo::GetVersion() const
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::GetVersion()", TOOLKIT_TSP_ASN, 0, this);

    if(NULL != m_impl->m_tstInfo && NULL != (*m_impl->m_tstInfo).data() && m_impl->m_version != (*m_impl->m_tstInfo)->version)
    {
        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_version = (*m_impl->m_tstInfo)->version;
    }

    return m_impl->m_version;
}
void CPKIFTSTInfo::SetPolicy(
    CPKIFOIDPtr& policy)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetPolicy(CPKIFOIDPtr& policy)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_policy = policy;
}
CPKIFOIDPtr CPKIFTSTInfo::GetPolicy() const
{
    if(m_impl->m_policy == (CPKIFOID*)NULL && NULL != m_impl->m_tstInfo && NULL != (*m_impl->m_tstInfo).data())
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetPolicy()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFOIDPtr tmpRef(new CPKIFOID((*m_impl->m_tstInfo)->policy.subid, (*m_impl->m_tstInfo)->policy.numids)); 

        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_policy = tmpRef;
    }
    return m_impl->m_policy;
}
void CPKIFTSTInfo::SetMessageImprint(
    CPKIFMessageImprintPtr& messageImprint)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetMessageImprint(CPKIFMessageImprintPtr& messageImprint)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_messageImprint = messageImprint;
}
CPKIFMessageImprintPtr CPKIFTSTInfo::GetMessageImprint() const
{
    if(m_impl->m_messageImprint == (CPKIFMessageImprint*)NULL && NULL != m_impl->m_tstInfo && NULL != (*m_impl->m_tstInfo).data())
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetMessageImprint()", TOOLKIT_TSP_ASN, 0, this);

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

        CPKIFMessageImprintPtr tmpRef(new CPKIFMessageImprint(miBuf)); 
        //CPKIFMessageImprintPtr tmpRef(new CPKIFMessageImprint((*m_impl->m_tstInfo)->messageImprint)); 

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

        if (data)
        {
          delete data;
        }
    }
    return m_impl->m_messageImprint;
}
void CPKIFTSTInfo::SetSerialNumber(
    CPKIFStringPtr& serialNumber)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetSerialNumber(CPKIFStringPtr& serialNumber)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_serialNum = serialNumber;
}
const char* CPKIFTSTInfo::GetSerialNumber() const
{
    if(m_impl->m_serialNum == NULL && NULL != m_impl->m_tstInfo && NULL != (*m_impl->m_tstInfo).data())
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetSerialNumber()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFStringPtr tmpRef(new std::string((char*)(*m_impl->m_tstInfo)->serialNumber)); 

        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_serialNum = tmpRef;
    }

    if(m_impl->m_serialNum == NULL)
        return NULL;
    else
        return m_impl->m_serialNum->c_str();
}
void CPKIFTSTInfo::SetGeneralizedTime(
    CPKIFTimePtr& genTime)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetGeneralizedTime(CPKIFTimePtr& genTime)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_time = genTime;
}
CPKIFTimePtr CPKIFTSTInfo::GetGeneralizedTime() const
{
    if(m_impl->m_time == NULL && NULL != m_impl->m_tstInfo && NULL != (*m_impl->m_tstInfo).data())
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetGeneralizedTime()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFTimePtr tmpTime(new CPKIFTime((*m_impl->m_tstInfo)->genTime));

        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_time = tmpTime;
    }

    return m_impl->m_time;
}
void CPKIFTSTInfo::SetAccuracy(
    CPKIFAccuracyPtr& accuracy)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetAccuracy(CPKIFAccuracyPtr& accuracy)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_accuracy = accuracy;
}
CPKIFAccuracyPtr CPKIFTSTInfo::GetAccuracy() const
{
    if(m_impl->m_accuracy == (CPKIFMessageImprint*)NULL && NULL != m_impl->m_tstInfo && 1 == (*m_impl->m_tstInfo)->m.accuracyPresent)
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetAccuracy()", TOOLKIT_TSP_ASN, 0, this);

        CACASNWRAPPER_CREATE(PKIFTSPAccuracy, accuWrapper);
        ASN1OpenType *data  = accuWrapper.Encode(&(*m_impl->m_tstInfo)->accuracy);
        CPKIFBufferPtr accuBuf(new CPKIFBuffer(data->data, data->numocts));

        CPKIFAccuracyPtr tmpRef(new CPKIFAccuracy(accuBuf)); 
        //CPKIFAccuracyPtr tmpRef(new CPKIFAccuracy((*m_impl->m_tstInfo)->accuracy)); 

        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_accuracy = tmpRef;

        if (data)
        {
          delete data;
        }

    }
    return m_impl->m_accuracy;
}
void CPKIFTSTInfo::SetOrdering(
    bool ordering)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetOrdering(bool ordering)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_bOrdering = ordering;
}
bool CPKIFTSTInfo::GetOrdering() const
{
    return m_impl->m_bOrdering;
}
void CPKIFTSTInfo::SetNonce(
    CPKIFStringPtr& nonce)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetNonce(CPKIFStringPtr& nonce)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_nonce = nonce;
}
const char* CPKIFTSTInfo::GetNonce() const
{
    if(m_impl->m_nonce == NULL && NULL != m_impl->m_tstInfo && 1 == (*m_impl->m_tstInfo)->m.noncePresent)
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetNonce()", TOOLKIT_TSP_ASN, 0, this);

        CPKIFStringPtr tmpRef(new std::string((*m_impl->m_tstInfo)->nonce)); 

        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_nonce = tmpRef;
    }

    if(m_impl->m_nonce == NULL)
        return NULL;
    else
        return m_impl->m_nonce->c_str();
}
void CPKIFTSTInfo::SetTSA(
    CPKIFGeneralNamePtr& tsa)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::SetTSA(CPKIFGeneralNamePtr& tsa)", TOOLKIT_TSP_ASN, 0, this);

    m_impl->CallingAllGets();
    m_impl->m_tsa = tsa;
}
CPKIFGeneralNamePtr CPKIFTSTInfo::GetTSA() const
{
    if(m_impl->m_tsa == (CPKIFGeneralName*)NULL && NULL != m_impl->m_tstInfo && 1 == (*m_impl->m_tstInfo)->m.tsaPresent)
    {
        LOG_STRING_DEBUG("CPKIFTSTInfo::GetTSA()", TOOLKIT_TSP_ASN, 0, this);

        CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(&((*m_impl->m_tstInfo)->tsa));
        CPKIFBufferPtr tmpBuf;
        if (data1 != NULL)
        {
             tmpBuf = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
            delete data1;
        }
        CPKIFGeneralNamePtr tmpRef(new CPKIFGeneralName(tmpBuf));
        //CPKIFGeneralNamePtr tmpRef(new CPKIFGeneralName((*m_impl->m_tstInfo)->tsa)); 

        CPKIFTSTInfo* nonConst = const_cast<CPKIFTSTInfo*>(this);
        nonConst->m_impl->m_tsa = tmpRef;
    }
    return m_impl->m_tsa;
}

//void CPKIFTSTInfo::AddExtension(CPKIFX509ExtensionPtr& ext)
//{
//  m_impl->CallingAllGets();
//  m_impl->m_exts.push_back(ext);
//}
bool CPKIFTSTInfo::ExtensionsPresent() const
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::ExtensionsPresent()", TOOLKIT_TSP_ASN, 0, this);

    if(NULL != m_impl->m_tstInfo && (*m_impl->m_tstInfo)->m.extensionsPresent)
        return true;
    else
        return false;
}
CPKIFBufferPtr CPKIFTSTInfo::Encode()
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::Encode()", TOOLKIT_TSP_ASN, 0, this);

    PKIFTSPMemoryHelper mhTSTInfo;
    mhTSTInfo.pTSTInfo = new PKIFTSPTSTInfo;
    memset(mhTSTInfo.pTSTInfo, 0, sizeof(PKIFTSPTSTInfo));

    //version
    mhTSTInfo.pTSTInfo->version = PKIFTSPv1_1;

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

         CopyOID(&mhTSTInfo.pTSTInfo->policy, tmpOid);

         if(NULL != tmpOid)
             delete tmpOid;
        //mhTSTInfo.pTSTInfo->policy = *policy->raw();
    }
    else
    {
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, TSP_MISSING_REQUIRED_FIELD, "Missing policy field.");
    }
    //messageImprint
    CPKIFMessageImprintPtr mi = GetMessageImprint();
    if(mi != (CPKIFMessageImprint*)NULL)
    {
        //hash alg
        mhTSTInfo.pTSTInfo->messageImprint.hashAlgorithm.m.parametersPresent = 1;
        mhTSTInfo.pTSTInfo->messageImprint.hashAlgorithm.parameters.data = g_nullParams;
        mhTSTInfo.pTSTInfo->messageImprint.hashAlgorithm.parameters.numocts = 2;
        CPKIFStringPtr str(new std::string(mi->GetHashAlgorithm()->oid()->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);

        CopyOID(&mhTSTInfo.pTSTInfo->messageImprint.hashAlgorithm.algorithm,tmpOid);

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

        //hashedMessage
        mhTSTInfo.pTSTInfo->messageImprint.hashedMessage.data = mi->GetHashedMessage()->GetBuffer();
        mhTSTInfo.pTSTInfo->messageImprint.hashedMessage.numocts = mi->GetHashedMessage()->GetLength();
    }
    else
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, TSP_MISSING_REQUIRED_FIELD, "Missing message imprint field.");

    //serialNumber
    const char* serialNumber = GetSerialNumber();
    if(NULL != serialNumber)
    {
        mhTSTInfo.pTSTInfo->serialNumber = serialNumber;
    }
    else
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, TSP_MISSING_REQUIRED_FIELD, "Missing serial number field.");

    //genTime
    CPKIFTimePtr genTime = GetGeneralizedTime();
    if(genTime != (CPKIFTime*)NULL)
    {
        mhTSTInfo.pTSTInfo->genTime = genTime->GetTime();
    }
    else
        throw CPKIFTSPException(TOOLKIT_TSP_ASN, TSP_MISSING_REQUIRED_FIELD, "Missing generalized time field.");

    //accuracy
    CPKIFAccuracyPtr acc = GetAccuracy();
    if(acc != (CPKIFAccuracy*)NULL)
    {
        mhTSTInfo.pTSTInfo->m.accuracyPresent = 1;
        mhTSTInfo.pTSTInfo->accuracy.m.secondsPresent = 0;
        mhTSTInfo.pTSTInfo->accuracy.m.millisPresent = 0;
        mhTSTInfo.pTSTInfo->accuracy.m.microsPresent = 0;
        if(acc->GetSecondsPresent())
        {
            mhTSTInfo.pTSTInfo->accuracy.m.secondsPresent = 1;
            mhTSTInfo.pTSTInfo->accuracy.seconds = acc->GetSeconds();
        }
        if(acc->GetMillisPresent())
        {
            mhTSTInfo.pTSTInfo->accuracy.m.millisPresent = 1;
            mhTSTInfo.pTSTInfo->accuracy.millis = acc->GetMillis();
        }
        if(acc->GetMicrosPresent())
        {
            mhTSTInfo.pTSTInfo->accuracy.m.microsPresent = 1;
            mhTSTInfo.pTSTInfo->accuracy.micros = acc->GetMicros();
        }
    }

    //ordering
    if(GetOrdering())
    {
        mhTSTInfo.pTSTInfo->ordering = 1;
    }

    //nonce
    const char* nonce = GetNonce();
    if(NULL != nonce)
    {
        mhTSTInfo.pTSTInfo->nonce = nonce;
        mhTSTInfo.pTSTInfo->m.noncePresent = 1;
    }

    //tsa
    CPKIFGeneralNamePtr tsa = GetTSA();
    if(tsa != (CPKIFGeneralName*)NULL)
    {
        mhTSTInfo.pTSTInfo->m.tsaPresent = 1;
        CopyGeneralName(mhTSTInfo.pTSTInfo->tsa, tsa);
    }

    //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(PKIFTSPTSTInfo, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(mhTSTInfo.pTSTInfo);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    delete data1;
    return tmp;
}
void CPKIFTSTInfo::Decode(
    CPKIFBufferPtr& msg)
{
    LOG_STRING_DEBUG("CPKIFTSTInfo::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->MakeTSTInfo();

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

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