ArchiveTimestamp.cpp

Go to the documentation of this file.

//#include "StdAfx.h"

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

//PKIF includes
#include "Buffer.h"
#include "ASN1Helper.h"
#include "ToolkitUtils.h"
#include "OID.h"
#include "IPKIFCryptoMisc.h"
#include "PKIFAlgorithm.h"

//PKIFCMS includes
#include "ContentInfo.h"
#include "SignedData.h"
#include "EncapsulatedContentInfo.h"
#include "PKIFMessageErrors.h"

//PKIFTSP includes
#include "TSTInfo.h"
#include "MessageImprint.h"

//Objective includes
#include "ERS.h"


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

    ArchiveTimeStamp* pATS;
};
PKIFArchiveTimestampMemoryHelper::PKIFArchiveTimestampMemoryHelper()
{
    pATS = NULL;
}
PKIFArchiveTimestampMemoryHelper::~PKIFArchiveTimestampMemoryHelper()
{
    if(pATS)
        delete pATS;
}

struct CPKIFArchiveTimestampImpl 
{
    CPKIFArchiveTimestampImpl();
    void ClearContent();

    CPKIFAlgorithmIdentifierPtr m_digestAlgorithm;
    CPKIFPartialHashtreeListPtr m_reducedHashtree;
    CPKIFContentInfoPtr m_timestamp;

    ArchiveTimeStampType m_type;

    //member for decoding
    CPKIFASNWrapper<ArchiveTimeStamp>* m_ats;

    void MakeArchiveTimeStamp();
    void FreeArchiveTimeStamp();

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

    CPKIFArchiveTimestamp* m_parent;
    CPKIFBufferPtr m_decodeBuf;
};

CPKIFArchiveTimestampImpl::CPKIFArchiveTimestampImpl()
{
    m_ats = NULL;
    ClearContent();
}
void CPKIFArchiveTimestampImpl::CallingAllGets()
{
    if(!m_parent) return;

    m_parent->GetDigestAlgorithm();
    m_parent->GetReducedHashtree();
    m_parent->GetTimestamp();
}
void CPKIFArchiveTimestampImpl::ClearContent()
{
    CPKIFAlgorithmIdentifierPtr emptyAlg;
    m_digestAlgorithm = emptyAlg;

    CPKIFPartialHashtreeListPtr emptyHashtree;
    m_reducedHashtree = emptyHashtree;

    CPKIFContentInfoPtr emptyTimestamp;
    m_timestamp = emptyTimestamp;

    CPKIFBufferPtr emptyBuf;
    m_decodeBuf = emptyBuf;

    FreeArchiveTimeStamp();
}

void CPKIFArchiveTimestampImpl::MakeArchiveTimeStamp()
{
    LOG_STRING_DEBUG("CPKIFArchiveTimestampImpl::MakeArchiveTimeStamp()", TOOLKIT_ERS_ASN, 0, this);

    FreeArchiveTimeStamp();
    m_ats = new CPKIFASNWrapper<ArchiveTimeStamp>( BEREncArchiveTimeStamp, BERDecArchiveTimeStamp );
}
void CPKIFArchiveTimestampImpl::FreeArchiveTimeStamp()
{
    LOG_STRING_DEBUG("CPKIFArchiveTimestampImpl::FreeArchiveTimeStamp()", TOOLKIT_ERS_ASN, 0, this);
    if(NULL != m_ats)
        delete m_ats;
    m_ats = NULL;
}


CPKIFArchiveTimestamp::CPKIFArchiveTimestamp(void) : m_impl (new CPKIFArchiveTimestampImpl())
{
    m_impl->m_parent = this;
}
CPKIFArchiveTimestamp::~CPKIFArchiveTimestamp(void)
{
    if(m_impl)
    {
        m_impl->FreeArchiveTimeStamp(); 
        delete m_impl;
    }
}
CPKIFAlgorithmIdentifierPtr CPKIFArchiveTimestamp::GetDigestAlgorithm() const
{
    if(m_impl->m_digestAlgorithm == (CPKIFAlgorithmIdentifier*)NULL && NULL != m_impl->m_ats && NULL != (*m_impl->m_ats).data() && (*m_impl->m_ats)->m.digestAlgorithmPresent)
    {
        LOG_STRING_DEBUG("CPKIFArchiveTimestamp::GetDigestAlgorithm()", TOOLKIT_ERS_ASN, 0, this);

        CPKIFArchiveTimestamp* nonConst = const_cast<CPKIFArchiveTimestamp*>(this);

        CACX509V3AlgorithmIdentifier* curAlg = &(*m_impl->m_ats)->digestAlgorithm;

        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));
        nonConst->m_impl->m_digestAlgorithm = newAlg;
    }

    return m_impl->m_digestAlgorithm;
}
CPKIFPartialHashtreeListPtr CPKIFArchiveTimestamp::GetReducedHashtree() const
{
    //XXX***IMPLEMENT ME
    return m_impl->m_reducedHashtree;
}
CPKIFContentInfoPtr CPKIFArchiveTimestamp::GetTimestamp() const
{
    if(m_impl->m_timestamp == (CPKIFContentInfo*)NULL && NULL != m_impl->m_ats && NULL != (*m_impl->m_ats).data())
    {
        LOG_STRING_DEBUG("CPKIFArchiveTimestamp::GetTimestamp()", TOOLKIT_ERS_ASN, 0, this);
        
        CPKIFArchiveTimestamp* nonConst = const_cast<CPKIFArchiveTimestamp*>(this);

        //CACCMSContentInfo* curTimestamp = &(*m_impl->m_ats)->timeStamp;

        CACASNWRAPPER_CREATE(CACCMSContentInfo, tmpPDU);
        ASN1OpenType* data1 = tmpPDU.Encode(&(*m_impl->m_ats)->timeStamp);

        CPKIFContentInfoPtr newTimestamp(new CPKIFContentInfo);
        newTimestamp->Decode(data1->data, data1->numocts);
        delete data1;

        nonConst->m_impl->m_timestamp = newTimestamp;
    }

    return m_impl->m_timestamp;
}
void CPKIFArchiveTimestamp::SetDigestAlgorithm(CPKIFAlgorithmIdentifierPtr& hashtree)
{
    m_impl->m_digestAlgorithm = hashtree;
}
void CPKIFArchiveTimestamp::SetReducedHashtree(CPKIFPartialHashtreeListPtr& reducedHashtree)
{
    m_impl->m_reducedHashtree = reducedHashtree;
}
void CPKIFArchiveTimestamp::SetTimestamp(CPKIFContentInfoPtr& timestamp)
{
    m_impl->m_timestamp = timestamp;
}

CPKIFBufferPtr CPKIFArchiveTimestamp::Encode() const
{
    //We may be encoding:
    //  - using stuff added since creation of this instance
    //  - using stuff from m_ats
    //  - using stuff from m_ats plus stuff added since parsing

    if(m_impl->m_digestAlgorithm != (CPKIFAlgorithmIdentifier*)NULL)
    {

    }

    if(m_impl->m_reducedHashtree != (CPKIFPartialHashtreeList*)NULL)
    {

    }

    CPKIFBufferPtr encodedTimestamp = m_impl->m_timestamp->GetContent();

    PKIFArchiveTimestampMemoryHelper ats;
    ats.pATS = new ArchiveTimeStamp();
    ats.pATS->timeStamp.content.data = encodedTimestamp->GetBuffer();
    ats.pATS->timeStamp.content.numocts = encodedTimestamp->GetLength();

    CPKIFOIDPtr timestampType = m_impl->m_timestamp->GetContentType();

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

    CACASNWRAPPER_CREATE(ArchiveTimeStamp, objPDU);
    ASN1OpenType* data1 = NULL;
    
    try
    {
        data1 = objPDU.Encode(ats.pATS);
    }
    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)
    m_impl->ClearContent();
    CPKIFArchiveTimestamp* nonConst = const_cast<CPKIFArchiveTimestamp*>(this);
    nonConst->Decode(tmp);
    m_impl->CallingAllGets();

    return tmp;
}
void CPKIFArchiveTimestamp::Decode(CPKIFBufferPtr& msg)
{
    LOG_STRING_DEBUG("CPKIFArchiveTimestamp::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->MakeArchiveTimeStamp();

    try
    {
        //otherwise try to parse it into the m_impl->m_tsr member
        (*m_impl->m_ats).Decode(msg->GetBuffer(), msg->GetLength());
        
        m_impl->m_decodeBuf = msg;
    }
    catch(CPKIFException&)
    {
        throw CPKIFERSException(TOOLKIT_ERS_ASN, MSG_DECODE_FAILED);
    }
}
void CPKIFArchiveTimestamp::SetArchiveTimeStampType(ArchiveTimeStampType atst)
{
    m_impl->m_type = atst;
}
ArchiveTimeStampType CPKIFArchiveTimestamp::GetArchiveTimeStampType() const
{
    return m_impl->m_type;
}
CPKIFAlgorithmIdentifierPtr CPKIFArchiveTimestamp::GetEffectiveDigestAlgorithm() const
{
    CPKIFAlgorithmIdentifierPtr algId = GetDigestAlgorithm();
    if(!algId)
    {
        CPKIFContentInfoPtr ci = GetTimestamp();

        CPKIFSignedData sd;
        CPKIFBufferPtr content1 = ci->GetContent();
        sd.Decode(content1);

        CPKIFEncapsulatedContentInfoPtr ecip = sd.GetEncapsulatedContent();

        CPKIFTSTInfo tstInfo;
        CPKIFBufferPtr content2 = ecip->GetContent();
        tstInfo.Decode(content2);

        CPKIFMessageImprintPtr mi = tstInfo.GetMessageImprint();
        algId = mi->GetHashAlgorithm();
    }

    return algId;
}
CPKIFBufferPtr PKIFERS_API CalculateHashOfTimestamp(
    CPKIFContentInfoPtr& timestamp, 
    IPKIFMediatorPtr& m, 
    PKIFCRYPTO::HASH_ALG ha)
{
    CPKIFBufferPtr empty;

    //XXX***IMPLEMENT ME

    return empty;
}
CPKIFBufferPtr PKIFERS_API CalculateHashOfArchiveTimestampChain(
    CPKIFArchiveTimestampChainPtr& archiveTimestampChain, 
    IPKIFMediatorPtr& m, 
    PKIFCRYPTO::HASH_ALG ha)
{
    CPKIFBufferPtr rv;

    CPKIFBufferList bpLifeExtender;

    ArchiveTimeStampChain* newChain = new ArchiveTimeStampChain;
    memset(newChain, 0, sizeof(ArchiveTimeStampChain));

    DListNode* chainCur = NULL;
    CPKIFArchiveTimestampChain::iterator chainPos;
    CPKIFArchiveTimestampChain::iterator chainEnd = archiveTimestampChain->end();
    for(chainPos = archiveTimestampChain->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);

        chainCur->data = (void*)tmpATS;

        SET_HEAD_TAIL_INCREMENT((*newChain), chainCur)
    }

    CACASNWRAPPER_CREATE(ArchiveTimeStampChain, objPDU);
    ASN1OpenType* data1 = NULL;
    
    try
    {
        data1 = objPDU.Encode(newChain);
    }
    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;
    }

    chainCur = newChain->head;
    for(int ii = 0; ii < newChain->count; ++ii)
    {
        delete chainCur->data;
        chainCur = chainCur->next;
    }
    delete newChain;

    IPKIFCryptoMisc* cm = m->GetMediator<IPKIFCryptoMisc>();
    IPKIFHashContext* hc = cm->HashInit(ha);
    cm->HashUpdate(hc, (unsigned char*)tmp->GetBuffer(), tmp->GetLength());

    CPKIFAlgorithm* haAlg = CPKIFAlgorithm::GetAlg(ha);
    int rvLen = haAlg->DigestSize();

    CPKIFBufferPtr tmpBP(new CPKIFBuffer);
    unsigned char* rvBuf = tmpBP->AllocateBuffer(rvLen);
    cm->HashFinal(hc, rvBuf, &rvLen);
    rv = tmpBP;

    return rv;
}