SCVPCertID.cpp

Go to the documentation of this file.

#include "Certificate.h"
#include "PKIFMediators.h"
#include "SCVPCertID.h"
#include "PKIFSCVPErrors.h"
#include "SCVPException.h"
#include "ToolkitUtils.h"
#include "CPKIFCryptoMediator2.h"
#include "IPKIFHashContext.h"
#include "SCVP.h"
#include "ASN1Helper.h"
#include "AlgorithmIdentifier.h"

using namespace PKIFCRYPTO;

struct CPKIFSCVPCertIDImpl 
{
    CPKIFCertificatePtr m_issuer;
    IPKIFMediatorPtr m_mediator;
    CPKIFBufferPtr m_certHash;
    const char * m_issuerSerialNumber;
    CPKIFGeneralNameListPtr m_issuerName;
    CPKIFAlgorithmIdentifierPtr m_HashAlgID;
};


CPKIFSCVPCertID::CPKIFSCVPCertID() :m_impl(new CPKIFSCVPCertIDImpl)
{
    LOG_STRING_DEBUG("CPKIFSCVPCertID::CPKIFSCVPCertID()", TOOLKIT_SCVP_ASN, 0, this);

}
CPKIFSCVPCertID::CPKIFSCVPCertID(
    const CPKIFBufferPtr& pkcRef)
  :m_impl (new CPKIFSCVPCertIDImpl)
{
    if(pkcRef == (CPKIFBuffer*)NULL || 0 == pkcRef->GetLength())
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP_ASN, COMMON_INVALID_INPUT);
    }

    CACASNWRAPPER_CREATE(SCVPCertID, objPDU);
    objPDU.Decode(pkcRef->GetBuffer(), pkcRef->GetLength());


    CPKIFBufferPtr tmpCertHash(new CPKIFBuffer(objPDU->certHash.data, objPDU->certHash.numocts));
    m_impl->m_certHash = tmpCertHash;

    CPKIFOIDPtr algOID(new CPKIFOID(objPDU->hashAlgorithm.algorithm.subid, 
                objPDU->hashAlgorithm.algorithm.numids));

    CPKIFBufferPtr algParams; 
    if(objPDU->hashAlgorithm.m.parametersPresent == 1)
    {
        CPKIFBufferPtr tmpAlgParams(new CPKIFBuffer(objPDU->hashAlgorithm.parameters.data,
            objPDU->hashAlgorithm.parameters.numocts));

        algParams = tmpAlgParams;
    }
    CPKIFAlgorithmIdentifierPtr hashAlg(new CPKIFAlgorithmIdentifier(algOID, algParams));

    m_impl->m_HashAlgID = hashAlg;


    CPKIFGeneralNameListPtr tmpNameList(new CPKIFGeneralNameList());
    DListNode* cur = objPDU->issuerSerial.issuer.head;
    while(NULL != cur)
    {
        CACX509V3GeneralName* tmp = (CACX509V3GeneralName*)cur->data;
        CACASNWRAPPER_CREATE(CACX509V3GeneralName, objPDU);
        ASN1OpenType* data1 = objPDU.Encode(tmp);
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFGeneralNamePtr tmpName(new CPKIFGeneralName(tmpBuf));

        if(NULL != data1)
            delete data1;

        m_impl->m_issuerName->push_back(tmpName);

        cur = cur->next;
    }

    m_impl->m_issuerSerialNumber = strdup(objPDU->issuerSerial.serialNumber);
}
CPKIFSCVPCertID::~CPKIFSCVPCertID()
{
    LOG_STRING_DEBUG("CPKIFSCVPCertID::~CPKIFSCVPCertID()", TOOLKIT_SCVP_ASN, 0, this);

    if (m_impl) {
      delete m_impl;
    }   
}
void CPKIFSCVPCertID::SetIssuerName(
    CPKIFGeneralNameListPtr& issuerName)
{
    m_impl->m_issuerName = issuerName;
}
void CPKIFSCVPCertID::GetIssuerName(
    CPKIFGeneralNameListPtr& issuerName) const
{
    issuerName = m_impl->m_issuerName;
}

 void CPKIFSCVPCertID::SetSerialNumber(
     const char * issuerSerialNumber)
{
    m_impl->m_issuerSerialNumber = issuerSerialNumber;
}

const char * CPKIFSCVPCertID::GetSerialNumber() const
{
    return m_impl->m_issuerSerialNumber;
}
const CPKIFBufferPtr CPKIFSCVPCertID::GetCertHash() const
{
    return m_impl->m_certHash;
}
void CPKIFSCVPCertID::CalculateCertHash(
    CPKIFBufferPtr& cert)
{
    if(m_impl->m_mediator == (IPKIFMediator*)NULL)
    {
        throw CPKIFSCVPException(TOOLKIT_SCVP, SCVP_MISSING_MEDIATOR, "mediator not specified.");
    }
    CPKIFCryptoMediator2 *cm = m_impl->m_mediator->GetMediator<CPKIFCryptoMediator2>();

    char hashResult[MAXHASH];
    int nResultLen = MAXHASH;

    int length = cert->GetLength();

    IPKIFHashContext* hash = NULL;
    try
    {
        //create a hash object, pass the buffer and length we calculated and obtain the result
        HASH_ALG hashAlg = SHA1;
        if(m_impl->m_HashAlgID != (CPKIFAlgorithmIdentifier*)NULL)
        {
            if(*(m_impl->m_HashAlgID->oid()) == *g_md5)
            {
                hashAlg = MD5;
            }
            else if(*(m_impl->m_HashAlgID->oid()) == *g_sha256)
            {
                hashAlg = SHA256;
            }
            else if(*(m_impl->m_HashAlgID->oid()) == *g_sha384)
            {
                hashAlg = SHA384;
            }
            else if(*(m_impl->m_HashAlgID->oid()) == *g_sha512)
            {
                hashAlg = SHA512;
            }

        }
        hash = cm->HashInit(hashAlg);
        cm->HashUpdate(hash, (unsigned char*)cert->GetBuffer(), length);
        cm->HashFinal(hash, (unsigned char*)hashResult, &nResultLen);
    }
    catch(CPKIFException& e)
    {
        if(NULL != hash)
            delete hash;

        throw e;
    }

    CPKIFBufferPtr tmp(new CPKIFBuffer((unsigned char*)hashResult, nResultLen));
    m_impl->m_certHash = tmp;
    //clean up the hash
    if(NULL != hash)
        delete hash; 
}
void CPKIFSCVPCertID::SetHashAlgorithm(CPKIFAlgorithmIdentifierPtr& hashAlg)
{
    m_impl->m_HashAlgID = hashAlg;
}
const CPKIFAlgorithmIdentifierPtr CPKIFSCVPCertID::GetHashAlgorithm() const
{
    return m_impl->m_HashAlgID;
}

void CPKIFSCVPCertID::SetMediator(IPKIFMediatorPtr &med)
{
    m_impl->m_mediator = med;
}