EvidenceRecord.cpp

Go to the documentation of this file.

//#include "StdAfx.h"

//PKIFERS includes
#include "EvidenceRecord.h"
#include "IPKIFCryptoInfo.h"
#include "ERSException.h"
#include "ArchiveTimestamp.h"

//PKIF includes
#include "AlgorithmIdentifier.h"
#include "ASN1Helper.h"
#include "ToolkitUtils.h"
#include "OID.h"
#include "PKIFMessageErrors.h"
#include "PKIFException.h"
#include "GottaMatch.h"


//PKIFCMS includes
#include "PKIFCMS.h"

//Objective includes
#include "ERS.h"
#include "PKIX1Explicit88.h"

//*****************************************************************************
//  Memory Helper and Impl
//*****************************************************************************

class PKIFERSMemoryHelper 
{
public:
    // Constructor and Destructor
    PKIFERSMemoryHelper();
    virtual ~PKIFERSMemoryHelper();

    EvidenceRecord* pERS;
};
PKIFERSMemoryHelper::PKIFERSMemoryHelper()
{
    pERS = NULL;
}
PKIFERSMemoryHelper::~PKIFERSMemoryHelper()
{
    if(pERS)
    {
        //clean up digest algorithms
        DListNode* cur = pERS->digestAlgorithms.head, *tmp = NULL;
        while(NULL != cur)
        {
            CACX509V3AlgorithmIdentifier* tmpDA = (CACX509V3AlgorithmIdentifier*)cur->data;
            delete tmpDA;

            tmp = cur->next;
            delete cur;
            cur = tmp;
        }
        
        cur = pERS->archiveTimeStampSequence.head;
        while(NULL != cur)
        {
            ArchiveTimeStampChain* tmpChain = (ArchiveTimeStampChain*)cur->data;

            DListNode* cur2 = tmpChain->head, *tmp2 = NULL;
            while(NULL != cur2)
            {
                ArchiveTimeStamp* tmpATS = (ArchiveTimeStamp*)cur2->data;
                delete tmpATS;

                tmp2 = cur2->next;
                delete cur2;
                cur2 = tmp2;
            }

            delete tmpChain;

            tmp = cur->next;
            delete cur;
            cur = tmp;
        }

        delete pERS;
    }
}

struct CPKIFEvidenceRecordImpl 
{
    //default constructor
    CPKIFEvidenceRecordImpl();

    //initialization (or re-initialization) function
    void ClearContent();

    //generate or destroy m_evidenceRecord member
    void MakeEvidenceRecord();
    void FreeEvidenceRecord();

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

    CPKIFEvidenceRecord* m_parent;

    int m_version;
//  CPKIFAlgorithmIdentifierListPtr m_digestAlgorithms;
    CPKIFArchiveTimestampSequencePtr m_archiveTimestampSequence;
    CPKIFASNWrapper<EvidenceRecord>* m_evidenceRecord;
    CPKIFBufferPtr m_decodeBuf;
};
CPKIFEvidenceRecordImpl::CPKIFEvidenceRecordImpl()
{
    //ClearContent frees evidence records, so initialize that here
    m_evidenceRecord = NULL;

    //everything else is initialized inside ClearContent
    ClearContent();
}
void CPKIFEvidenceRecordImpl::CallingAllGets()
{
    if(!m_parent) return;

    m_parent->GetArchiveTimestampSequence();
    m_parent->GetDigestAlgorithms();
    m_parent->GetVersion();
}

void CPKIFEvidenceRecordImpl::ClearContent()
{
    m_version = PKIFERSv1;

    //CPKIFAlgorithmIdentifierListPtr emptyAlgs;
    //m_digestAlgorithms = emptyAlgs;

    CPKIFArchiveTimestampSequencePtr emptyATS; 
    m_archiveTimestampSequence = emptyATS;

    CPKIFBufferPtr emptyBuf;
    m_decodeBuf = emptyBuf;

    FreeEvidenceRecord();
}

void CPKIFEvidenceRecordImpl::MakeEvidenceRecord()
{
    LOG_STRING_DEBUG("CPKIFEvidenceRecordImpl::MakeEvidenceRecord()", TOOLKIT_ERS_ASN, 0, this);

    FreeEvidenceRecord();
    m_evidenceRecord = new CPKIFASNWrapper<EvidenceRecord>( BEREncEvidenceRecord, BERDecEvidenceRecord );
}

void CPKIFEvidenceRecordImpl::FreeEvidenceRecord()
{
    LOG_STRING_DEBUG("CPKIFEvidenceRecordImpl::FreeEvidenceRecord()", TOOLKIT_ERS_ASN, 0, this);
    if(NULL != m_evidenceRecord)
        delete m_evidenceRecord;
    m_evidenceRecord = NULL;
}


//*****************************************************************************
//  CPKIFEvidenceRecord implementation
//*****************************************************************************
CPKIFEvidenceRecord::CPKIFEvidenceRecord(void) : m_impl (new CPKIFEvidenceRecordImpl())
{
    m_impl->m_parent = this;
}
CPKIFEvidenceRecord::~CPKIFEvidenceRecord(void)
{
    if(m_impl)
    {
        m_impl->FreeEvidenceRecord();   
        delete m_impl;
    }
}

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

        CPKIFEvidenceRecord* nonConst = const_cast<CPKIFEvidenceRecord*>(this);
        nonConst->m_impl->m_version = (*m_impl->m_evidenceRecord)->version;
    }

    return m_impl->m_version;
}

CPKIFAlgorithmIdentifierListPtr CPKIFEvidenceRecord::GetDigestAlgorithms() const
{
//The commented out code below could be used if the list included in an evidence record by its creator is of 
//interest.  Since the list is simply a convenience, the archive timestamps are parsed upon decoding and the 
//list could be augmented when the archive timestamp  sequence is updated, the list is always calculated from 
//the archive timestamp sequence.  
/*
    if(m_impl->m_digestAlgorithms == (CPKIFAlgorithmIdentifierList*)NULL && NULL != m_impl->m_evidenceRecord && 
        NULL != (*m_impl->m_evidenceRecord).data())
    {
        LOG_STRING_DEBUG("CPKIFEvidenceRecord::GetDigestAlgorithms()", TOOLKIT_ERS_ASN, 0, this);

        CPKIFEvidenceRecord* nonConst = const_cast<CPKIFEvidenceRecord*>(this);
        CPKIFAlgorithmIdentifierListPtr newAlgList(new CPKIFAlgorithmIdentifierList);
        nonConst->m_impl->m_digestAlgorithms = newAlgList;

        DListNode* iter = (*m_impl->m_evidenceRecord)->digestAlgorithms.head;
        while(NULL != iter)
        {
            CACX509V3AlgorithmIdentifier* curAlg = (CACX509V3AlgorithmIdentifier*)iter->data;

            CPKIFOIDPtr algOID(new CPKIFOID(curAlg->algorithm.subid, curAlg->algorithm.numids));
            CPKIFBufferPtr paramBuf;
            if(curAlg->m.parametersPresent)
            {
                paramBuf = CPKIFBufferPtr(new CPKIFBuffer(curAlg->parameters.data, curAlg->parameters.numocts));
            }

            CPKIFAlgorithmIdentifierPtr newAlg(new CPKIFAlgorithmIdentifier(algOID, paramBuf));
            newAlgList->push_back(newAlg);

            iter = iter->next;
        }
    }

    return m_impl->m_digestAlgorithms;
*/
    CPKIFAlgorithmIdentifierListPtr rv(new CPKIFAlgorithmIdentifierList);
    if(!m_impl || !m_impl->m_archiveTimestampSequence)
        return rv;

    CPKIFArchiveTimestampSequence::iterator seqPos;
    CPKIFArchiveTimestampSequence::iterator seqEnd = m_impl->m_archiveTimestampSequence->end();
    for(seqPos = m_impl->m_archiveTimestampSequence->begin(); seqPos != seqEnd; ++seqPos)
    {
        CPKIFArchiveTimestampChain::iterator chainPos;
        CPKIFArchiveTimestampChain::iterator chainEnd = (*seqPos)->end();
        for(chainPos = (*seqPos)->begin(); chainPos != chainEnd; ++chainPos)
        {
            CPKIFAlgorithmIdentifierPtr algId = (*chainPos)->GetEffectiveDigestAlgorithm();
            CPKIFAlgorithmIdentifierPtr algIdCopy(new CPKIFAlgorithmIdentifier(*algId));
            GottaMatch<CPKIFAlgorithmIdentifierPtr> gm;
            gm.SetRHS(algIdCopy);
            if(rv->end() == find_if(rv->begin(), rv->end(), gm))
                rv->push_back(algIdCopy);
        }
    }

    return rv;
}
CPKIFArchiveTimestampSequencePtr CPKIFEvidenceRecord::GetArchiveTimestampSequence() const
{
    if(m_impl->m_archiveTimestampSequence == (CPKIFArchiveTimestampSequencePtr*)NULL && 
        NULL != m_impl->m_evidenceRecord && NULL != (*m_impl->m_evidenceRecord).data())
    {
        LOG_STRING_DEBUG("CPKIFEvidenceRecord::GetArchiveTimestampSequence()", TOOLKIT_ERS_ASN, 0, this);

        CPKIFEvidenceRecord* nonConst = const_cast<CPKIFEvidenceRecord*>(this);
        CPKIFArchiveTimestampSequencePtr newATSSeq(new CPKIFArchiveTimestampSequence);
        nonConst->m_impl->m_archiveTimestampSequence = newATSSeq;

        DListNode* iter = (*m_impl->m_evidenceRecord)->archiveTimeStampSequence.head;
        while(NULL != iter)
        {
            CPKIFArchiveTimestampChainPtr newChain(new CPKIFArchiveTimestampChain);

            ArchiveTimeStampChain* curAlg = (ArchiveTimeStampChain*)iter->data;
            DListNode* atsIter = curAlg->head;
            while(NULL != atsIter)
            {
                ArchiveTimeStamp* ats = (ArchiveTimeStamp*)atsIter->data;

                CACASNWRAPPER_CREATE(ArchiveTimeStamp, tmpPDU);
                ASN1OpenType* data1 = tmpPDU.Encode(ats);

                CPKIFBufferPtr tmpBP(new CPKIFBuffer(data1->data, data1->numocts));
                delete data1;

                CPKIFArchiveTimestampPtr newATS(new CPKIFArchiveTimestamp);
                newATS->Decode(tmpBP);
                newChain->push_back(newATS);

                atsIter = atsIter->next;
            }

            newATSSeq->push_back(newChain);         

            iter = iter->next;
        }
    }

    return m_impl->m_archiveTimestampSequence;
}
CPKIFBufferPtr CPKIFEvidenceRecord::Encode() const
{
    m_impl->CallingAllGets();
    if(!m_impl || !m_impl->m_archiveTimestampSequence || 0 == m_impl->m_archiveTimestampSequence->size())
        throw CPKIFException(TOOLKIT_ERS_ASN, COMMON_INVALID_INPUT);

    //create a new EvidenceRecord struct and hand it to a memory handler instance
    PKIFERSMemoryHelper ers;
    ers.pERS = new EvidenceRecord();
    memset(ers.pERS, 0, sizeof(EvidenceRecord));

    CPKIFAlgorithmIdentifierListPtr digAlgs = GetDigestAlgorithms();

    DListNode* cur = NULL;
    CPKIFAlgorithmIdentifierList::iterator pos; 
    CPKIFAlgorithmIdentifierList::iterator end = digAlgs->end();
    for(pos = digAlgs->begin(); pos != end; ++pos)
    {
        CPKIFAlgorithmIdentifierPtr digestAlg = (*pos);

        if(NULL == cur)
        {
            NEW_NODE(cur)
        }
        else
        {
            NEW_NEXT_AND_ADVANCE(cur)
        }

        //build list in Objective structure (throw bad_alloc - memory helper in caller will clean
        //up any previously allocated memory)
        CACX509V3AlgorithmIdentifier* tmpDA = new CACX509V3AlgorithmIdentifier;

        tmpDA->m.parametersPresent = 1;
        tmpDA->parameters.data = g_nullParams;
        tmpDA->parameters.numocts = 2;
        CPKIFStringPtr str(new std::string(digestAlg->oid()->ToString())); 
        ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);

        CopyOID(&tmpDA->algorithm, tmpOid);

        if( NULL != tmpOid)
            delete tmpOid;

        cur->data = (void*)tmpDA;

        SET_HEAD_TAIL_INCREMENT(ers.pERS->digestAlgorithms, cur)
    }

    CPKIFBufferList bpLifeExtender;
    DListNode* seqCur = NULL;
    CPKIFArchiveTimestampSequence::iterator seqPos;
    CPKIFArchiveTimestampSequence::iterator seqEnd = m_impl->m_archiveTimestampSequence->end();
    for(seqPos = m_impl->m_archiveTimestampSequence->begin(); seqPos != seqEnd; ++seqPos)
    {
        if(NULL == seqCur)
        {
            NEW_NODE(seqCur)
        }
        else
        {
            NEW_NEXT_AND_ADVANCE(seqCur)
        }

        ArchiveTimeStampChain* newChain = new ArchiveTimeStampChain;
        memset(newChain, 0, sizeof(ArchiveTimeStampChain));
        seqCur->data = newChain;

        DListNode* chainCur = NULL;
        CPKIFArchiveTimestampChain::iterator chainPos;
        CPKIFArchiveTimestampChain::iterator chainEnd = (*seqPos)->end();
        for(chainPos = (*seqPos)->begin(); chainPos != chainEnd; ++chainPos)
        {
            if(NULL == chainCur)
            {
                NEW_NODE(chainCur)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(chainCur)
            }

            //build list in Objective structure (throw bad_alloc - memory helper in caller will clean
            //up any previously allocated memory)
            ArchiveTimeStamp* tmpATS = new ArchiveTimeStamp;
            memset(tmpATS, 0, sizeof(ArchiveTimeStamp));

            CPKIFContentInfoPtr ci = (*chainPos)->GetTimestamp();
            CPKIFBufferPtr encodedTimestamp = ci->GetContent();
            bpLifeExtender.push_back(encodedTimestamp);

            tmpATS->timeStamp.content.data = encodedTimestamp->GetBuffer();
            tmpATS->timeStamp.content.numocts = encodedTimestamp->GetLength();

            CPKIFOIDPtr timestampType = ci->GetContentType();

            CPKIFStringPtr str(new std::string(timestampType->ToString())); 
            ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
            CopyOID(&tmpATS->timeStamp.contentType, tmpOid);

            if( NULL != tmpOid)
                delete tmpOid;

            chainCur->data = (void*)tmpATS;

            SET_HEAD_TAIL_INCREMENT((*newChain), chainCur)
        }
        SET_HEAD_TAIL_INCREMENT(ers.pERS->archiveTimeStampSequence, seqCur)
    }

    CACASNWRAPPER_CREATE(EvidenceRecord, objPDU);
    ASN1OpenType* data1 = NULL;
    
    try
    {
        data1 = objPDU.Encode(ers.pERS);
    }
    catch(...)
    {
        //we must remove pre-existing signer infos from the list in the memory helper before cleanup
        //re-throw any exception
        throw;
    }

    CPKIFBufferPtr tmp;
    try
    {
        //copy the buffer info a buffer ptr to be returned to the caller
        CPKIFBufferPtr tmpTmp(new CPKIFBuffer((unsigned char*)data1->data, data1->numocts));
        tmp = tmpTmp;
        delete data1; data1 = NULL;
    }
    catch(std::bad_alloc& ba)
    {
        if(data1)
            delete data1;
        throw ba;
    }

    //immediately after encoding - decode the message and remove all members
    //to keep the object in a suitable state
    //XXX-DEFER should the state be maintained in this clear and decode fashion
    //      or should another means be implemented (possibly storage of the
    //      encoded buffer with state-related macros at the beginning of every 
    //      function to trigger decodes as necessary)

    CPKIFEvidenceRecord* nonConst = const_cast<CPKIFEvidenceRecord*>(this);
    nonConst->Decode(tmp);
    m_impl->CallingAllGets();

    return tmp;
}

void CPKIFEvidenceRecord::Decode(
    CPKIFBufferPtr& msg)
{
    LOG_STRING_DEBUG("CPKIFEvidenceRecord::Decode(CPKIFBufferPtr& msg)", TOOLKIT_ERS_ASN, 0, this);

    m_impl->ClearContent();

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

    m_impl->MakeEvidenceRecord(); 

    try
    {
        //otherwise try to parse it into the m_impl->m_tsr member
        (*m_impl->m_evidenceRecord).Decode(msg->GetBuffer(), msg->GetLength());

        m_impl->m_decodeBuf = msg;
    }
    catch(CPKIFException&)
    {
        throw CPKIFERSException(TOOLKIT_ERS_ASN, MSG_DECODE_FAILED);
    }
}

void CPKIFEvidenceRecord::SetArchiveTimestampSequence(CPKIFArchiveTimestampSequencePtr& ats)
{
    m_impl->m_archiveTimestampSequence = ats;
}