BasicOCSPResponse.cpp

Go to the documentation of this file.

#include "BasicOCSPResponse.h"

#include "Buffer.h"
#include "Certificate.h"
#include "ResponseData.h"
#include "AlgorithmIdentifier.h"
#include "PKIFTime.h"
#include "SingleResponse.h"
#include "OCSPCertStatus.h"

#include "OCSPException.h"
#include "ToolkitUtils.h"
#include "PKIFX509Extensions2.h"
#include "ASN1Helper.h"
#include "OCSP.h"
#include "PKIFCommonErrors.h"
#include "SubjectPublicKeyInfo.h"
#include "ExtendedKeyUsage.h"
#include "AccessDescription.h"
#include "BasicOCSPResponse.h"

#include <iterator>

using namespace std;

struct CPKIFBasicOCSPResponseImpl
{
    CPKIFResponseDataPtr m_responseData;
    CPKIFAlgorithmIdentifierPtr m_sigAlg;
    CPKIFBufferPtr m_signature;
    CPKIFCertificateList m_certs;

    CPKIFASNWrapper<BasicOCSPResponse>* m_ocspResp;

    void ClearAllMembers();
    void MakeOCSPResponse();
    void FreeOCSPResponse();
};

CPKIFBasicOCSPResponse::CPKIFBasicOCSPResponse(void)
    :m_impl (new CPKIFBasicOCSPResponseImpl)
{
    LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::CPKIFBasicOCSPResponse(void)", TOOLKIT_OCSP_ASN, 0, this);

    m_impl->m_ocspResp = NULL;
}
CPKIFBasicOCSPResponse::~CPKIFBasicOCSPResponse(void)
{
    LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::~CPKIFBasicOCSPResponse(void)", TOOLKIT_OCSP_ASN, 0, this);

    if(NULL != m_impl->m_ocspResp)
        delete m_impl->m_ocspResp;

    delete m_impl;
    m_impl = NULL;
}

//tbsResponseData
CPKIFResponseDataPtr CPKIFBasicOCSPResponse::GetResponseData() const
{
    if(m_impl->m_responseData == (CPKIFResponseData*)NULL && NULL != m_impl->m_ocspResp && NULL != (*m_impl->m_ocspResp).data())
    {
        LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::GetResponseData()", TOOLKIT_OCSP_ASN, 0, this);

        CPKIFBufferPtr buffPtr(new CPKIFBuffer((*m_impl->m_ocspResp)->tbsResponseData.data, (*m_impl->m_ocspResp)->tbsResponseData.numocts));
        CPKIFResponseData* tmp = new CPKIFResponseData(buffPtr);
        CPKIFResponseDataPtr tmpRef(tmp); 

        CPKIFBasicOCSPResponse* nonConst = const_cast<CPKIFBasicOCSPResponse*>(this);
        nonConst->m_impl->m_responseData = tmpRef;
    }

    return m_impl->m_responseData;
}
void CPKIFBasicOCSPResponse::SetResponseData(
    CPKIFResponseDataPtr& rd)
{
    m_impl->m_responseData = rd;
}

//signatureAlg
CPKIFAlgorithmIdentifierPtr CPKIFBasicOCSPResponse::GetSignatureAlg() const
{
    if(m_impl->m_sigAlg == (CPKIFAlgorithmIdentifier*)NULL && NULL != m_impl->m_ocspResp && NULL != (*m_impl->m_ocspResp).data())
    {
        LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::GetSignatureAlg()", TOOLKIT_OCSP_ASN, 0, this);


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

        CPKIFAlgorithmIdentifierPtr tmpRef(new CPKIFAlgorithmIdentifier(algOID, paramBuf)); 

        CPKIFBasicOCSPResponse* nonConst = const_cast<CPKIFBasicOCSPResponse*>(this);
        nonConst->m_impl->m_sigAlg = tmpRef;
    }

    return m_impl->m_sigAlg;
}
void CPKIFBasicOCSPResponse::SetSignatureAlg(
    CPKIFAlgorithmIdentifierPtr& sa)
{
    m_impl->m_sigAlg = sa;
}

//signature
CPKIFBufferPtr CPKIFBasicOCSPResponse::GetSignature() const
{
    if(m_impl->m_signature == (CPKIFBuffer*)NULL && NULL != m_impl->m_ocspResp && NULL != (*m_impl->m_ocspResp).data())
    {
        LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::GetSignature()", TOOLKIT_OCSP_ASN, 0, this);

        CPKIFBuffer* tmp = new CPKIFBuffer((*m_impl->m_ocspResp)->signature.data,(*m_impl->m_ocspResp)->signature.numbits/8); 
        CPKIFBufferPtr tmpRef(tmp); 

        CPKIFBasicOCSPResponse* nonConst = const_cast<CPKIFBasicOCSPResponse*>(this);
        nonConst->m_impl->m_signature = tmpRef;
    }
    return m_impl->m_signature;
}
void CPKIFBasicOCSPResponse::SetSignature(
    CPKIFBufferPtr& sig)
{
    m_impl->m_signature = sig;
}

//certs
void CPKIFBasicOCSPResponse::GetCerts(
    CPKIFCertificateList& certs)
{
    copy(m_impl->m_certs.begin(), m_impl->m_certs.end(), back_inserter(certs));
}
void CPKIFBasicOCSPResponse::AddCert(
    CPKIFCertificatePtr& cert)
{
    m_impl->m_certs.push_back(cert);
}
void CPKIFBasicOCSPResponse::Decode(
    const CPKIFBufferPtr& msg)
{
    LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::Decode(CPKIFBufferPtr& msg)", TOOLKIT_OCSP_ASN, 0, this);

    m_impl->ClearAllMembers();

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

    m_impl->MakeOCSPResponse();

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

        if(0 < (*m_impl->m_ocspResp)->m.certsPresent)
        {
            DListNode* cur = (*m_impl->m_ocspResp)->certs.head;
            while(NULL != cur)
            {
                ASN1OpenType* tmpNode = (ASN1OpenType*)cur->data;
                CPKIFCertificatePtr tmpCert(new CPKIFCertificate());
                tmpCert->Decode(tmpNode->data, tmpNode->numocts);

                m_impl->m_certs.push_back(tmpCert);
        
                cur = cur->next;
            }
        }
    }
    catch(CPKIFException&)
    {
        //delete e;
        //changed error code 3/2/2004
        throw CPKIFOCSPException(TOOLKIT_OCSP_ASN, ASN1_DECODE_ERROR);
    }
}
void CPKIFBasicOCSPResponseImpl::ClearAllMembers()
{
    LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::ClearAllMembers()", TOOLKIT_OCSP_ASN, 0, this);

    //added 8/23/2004
    CPKIFResponseDataPtr responseData;
    m_responseData = responseData;
    CPKIFAlgorithmIdentifierPtr sigAlg;
    m_sigAlg = sigAlg;
    CPKIFBufferPtr signature;
    m_signature = signature;
    m_certs.clear();

    FreeOCSPResponse();
}
void CPKIFBasicOCSPResponseImpl::MakeOCSPResponse()
{
    LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::MakeOCSPResponse()", TOOLKIT_OCSP_ASN, 0, this);

    FreeOCSPResponse();
    m_ocspResp = new CPKIFASNWrapper<BasicOCSPResponse>( BEREncBasicOCSPResponse, BERDecBasicOCSPResponse );
}
void CPKIFBasicOCSPResponseImpl::FreeOCSPResponse()
{
    LOG_STRING_DEBUG("CPKIFBasicOCSPResponse::FreeOCSPResponse()", TOOLKIT_OCSP_ASN, 0, this);

    if(NULL != m_ocspResp)
        delete m_ocspResp;
    m_ocspResp = NULL;
}