SigningCertificateAttribute.cpp

Go to the documentation of this file.

#include "SigningCertificateAttribute.h"

#include "PKIFTime.h"
#include "ToolkitUtils.h"
#include "Buffer.h"
#include "OID.h"
#include "ASN1Helper.h"
#include "PolicyInformation.h"
#include "PolicyQualifier.h"
#include "ESSCertId.h"

#include "CryptographicMessageSyntax2004.h"
#include "ExtendedSecurityServices.h"

#include "PKIFMessageException.h"
#include "PKIFMessageErrors.h"



struct CPKIFSigningCertificateAttributeImpl
{
    CPKIFESSCertIdListPtr m_essCertIDList;
    CPKIFPolicyInformationListPtr m_policyList;

  void ParseAttributes (const unsigned char *buf, const unsigned int length);
  void populateASN1OBJID(std::string objIdStr, ASN1OBJID *asn1ObjIdPtr);
};
void CPKIFSigningCertificateAttributeImpl::ParseAttributes (
    const unsigned char *buf, 
    const unsigned int length)
{
    CACASNWRAPPER_CREATE(CACCMSAttributeValues, attrsVals);
    CACCMSAttributeValues* attributesList = attrsVals.Decode(buf, length);

    ASN1OpenType* ot = (ASN1OpenType*)((DListNode*)attributesList->head)->data;
    CPKIFASNWrapper<CACCMSSigningCertificate> cmsSigningCertificate(BEREncCACCMSSigningCertificate, BERDecCACCMSSigningCertificate);

    //eliminated check for 0 that was errorneously resulting in exceptions.  Decode will throw an
    //exception if it fails - 12/5/2003
    cmsSigningCertificate.Decode(ot->data, ot->numocts);

    CACCMSSigningCertificate* tmpCACCMSSigningCertificate = (CACCMSSigningCertificate*)cmsSigningCertificate.data();

    if(tmpCACCMSSigningCertificate->m.policiesPresent > 0)
    {
        CPKIFPolicyInformationListPtr tmpuserPolicySet(new CPKIFPolicyInformationList());
        DListNode* cur = tmpCACCMSSigningCertificate->policies.head;
        while(NULL != cur)
        {
            ASN1OBJID* tmp = (ASN1OBJID*)cur->data;
            CPKIFOIDPtr tmpOID(new CPKIFOID(tmp->subid, tmp->numids));

            CPKIFPolicyInformationPtr tmpPolInfo(new CPKIFPolicyInformation(tmpOID));
            tmpuserPolicySet->push_back(tmpPolInfo);

            cur = cur->next;
        }
        m_policyList = tmpuserPolicySet;
    }

    CPKIFESSCertIdListPtr tmpESSCertIdList(new CPKIFESSCertIdList());
    DListNode* cur2 = tmpCACCMSSigningCertificate->certs.head;
    while(NULL != cur2)
    {
        CACCMSESSCertID* tmp = (CACCMSESSCertID*)cur2->data;
        CACASNWRAPPER_CREATE(CACCMSESSCertID, objPDU2);
        ASN1OpenType* data1 = objPDU2.Encode(tmp);
        CPKIFBufferPtr tmpBuf(new CPKIFBuffer(data1->data, data1->numocts));
        CPKIFESSCertIdPtr tmpESSCertId(new CPKIFESSCertId(tmpBuf));

        tmpESSCertIdList->push_back(tmpESSCertId);

        cur2 = cur2->next;
    }
    m_essCertIDList = tmpESSCertIdList;
}



   //id-aa-signingCertificate OBJECT IDENTIFIER ::= { iso(1)
   //    member-body(2) us(840) rsadsi(113549) pkcs(1) pkcs9(9)
   //    smime(16) id-aa(2) 12 }
char CPKIFSigningCertificateAttribute::extOID[] = "1.2.840.113549.1.9.16.2.12";

CPKIFSigningCertificateAttribute::CPKIFSigningCertificateAttribute()
    :m_impl (new CPKIFSigningCertificateAttributeImpl)
{
    LOG_STRING_DEBUG("CPKIFSigningCertificateAttribute::CPKIFSigningCertificateAttribute()", TOOLKIT_MESSAGE_ASN, 0, this);
}

CPKIFSigningCertificateAttribute::CPKIFSigningCertificateAttribute(
    const CPKIFBufferPtr& buf)
    :m_impl (new CPKIFSigningCertificateAttributeImpl)
{
    LOG_STRING_DEBUG("CPKIFSigningCertificateAttribute::CPKIFSigningCertificateAttribute(const CACCMSAttribute& ext)", TOOLKIT_MESSAGE_ASN, 0, this);

    m_impl->ParseAttributes (buf->GetBuffer(), buf->GetLength());
}

CPKIFSigningCertificateAttribute::~CPKIFSigningCertificateAttribute()
{
    LOG_STRING_DEBUG("CPKIFSigningCertificateAttribute::~CPKIFSigningCertificateAttribute()", TOOLKIT_MESSAGE_ASN, 0, this);
    
    delete m_impl;
    m_impl = NULL;
}

//generic attribute functions
CPKIFOIDPtr CPKIFSigningCertificateAttribute::GetOID() const
{
    return g_signingCertificateAttribute;
}
void CPKIFSigningCertificateAttribute::GetValues(
    CPKIFBufferList& values) const
{
    LOG_STRING_DEBUG("CPKIFSigningCertificateAttribute::GetValues(CPKIFBufferList& values)", TOOLKIT_MESSAGE_ASN, 0, this);

    CACCMSSigningCertificate theSigningCertificate;
    memset(&theSigningCertificate,0x00,sizeof(CACCMSSigningCertificate));

    if(m_impl->m_essCertIDList != (CPKIFESSCertIdList*)NULL && !m_impl->m_essCertIDList->empty())
    {
        DListNode* curCertID = NULL;
        //iterate over oids
        CPKIFESSCertIdList::iterator certIDPos; 
        CPKIFESSCertIdList::iterator certIDEnd = m_impl->m_essCertIDList->end();
        for(certIDPos = m_impl->m_essCertIDList->begin(); certIDPos != certIDEnd; ++certIDPos)
        {
            if(NULL == curCertID)
            {
                NEW_NODE(curCertID)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(curCertID)
            }

            CACCMSESSCertID* tmpCertID = new CACCMSESSCertID;
            memset(tmpCertID , 0, sizeof(CACCMSESSCertID));
                        

            tmpCertID->certHash.data = (*certIDPos)->GetCertHash()->GetBuffer();
            tmpCertID->certHash.numocts = (*certIDPos)->GetCertHash()->GetLength();

            // ESSCertIds produced by PKIF will always have ISN
            tmpCertID->m.issuerSerialPresent = 1;
            // the cert will hang around until this is done encoding, so there's no need to copy the string.
            // be sure not to free it later. the cert object owns it.
            tmpCertID->issuerSerial.serialNumber = (*certIDPos)->GetSerialNumber();
            
            CPKIFGeneralNameListPtr nameList;
            (*certIDPos)->GetIssuerName(nameList);
            if(nameList == (CPKIFGeneralNameList*)NULL)
            {
                throw CPKIFMessageException(TOOLKIT_MESSAGE_ASN, MSG_INCOMPLETE, "Issuer Names value not specified in ESSCertID.");
            }
            DListNode* curName = NULL;
            CPKIFGeneralNameList::iterator namePos; 
            CPKIFGeneralNameList::iterator nameEnd = nameList->end();
            for(namePos = nameList->begin(); namePos != nameEnd; ++namePos)
            {

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

                CACX509V3GeneralName *name = new CACX509V3GeneralName;
                memset(name, 0, sizeof(CACX509V3GeneralName));

                CopyGeneralName((*name), (*namePos));   

                curName->data = name;

                SET_HEAD_TAIL_INCREMENT(tmpCertID->issuerSerial.issuer, curName)
            }
            curCertID->data = tmpCertID;

            SET_HEAD_TAIL_INCREMENT(theSigningCertificate.certs, curCertID)
        }
    }
    else
    {
        throw CPKIFMessageException(TOOLKIT_MESSAGE_ASN, MSG_INCOMPLETE, "certs field of CACCMSSigningCertificate object is not specified");
    }

    if(m_impl->m_policyList != (CPKIFOIDList*)NULL && !m_impl->m_policyList->empty())
    {
        DListNode* curPol = NULL;
        //iterate over oids
        CPKIFPolicyInformationList::iterator oidPos;    
        CPKIFPolicyInformationList::iterator oidEnd = m_impl->m_policyList->end();
        for(oidPos = m_impl->m_policyList->begin(); oidPos != oidEnd; ++oidPos)
        {
            if(NULL == curPol)
            {
                NEW_NODE(curPol)
            }
            else
            {
                NEW_NEXT_AND_ADVANCE(curPol)
            }

            CACX509V3PolicyInformation *policyInfo = new CACX509V3PolicyInformation;
            memset(policyInfo, 0, sizeof(CACX509V3PolicyInformation));

            
            CPKIFStringPtr str(new std::string((*oidPos)->PolicyOID()->ToString())); 
            m_impl->populateASN1OBJID(str->c_str(), &policyInfo->policyIdentifier);

            CPKIFPolicyQualifierListPtr qList = (*oidPos)->Qualifiers();

            if(qList != (CPKIFPolicyQualifierList*)NULL)
            {
                DListNode* curQualifier = NULL;
                CPKIFPolicyQualifierList::iterator qualifierPos;    
                CPKIFPolicyQualifierList::iterator qualifierEnd = qList->end();
                for(qualifierPos = qList->begin(); qualifierPos != qualifierEnd; ++qualifierPos)
                {

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

                    CACX509V3PolicyQualifierInfo *q = new CACX509V3PolicyQualifierInfo;
                    memset(q, 0, sizeof(CACX509V3PolicyQualifierInfo));

                    m_impl->populateASN1OBJID((*qualifierPos)->QualifierID()->ToString(), &q->policyQualifierId);
                    q->qualifier.data = new unsigned char[(*qualifierPos)->Qualifier()->GetLength()];
                    memcpy((void*)q->qualifier.data, (*qualifierPos)->Qualifier()->GetBuffer(), (*qualifierPos)->Qualifier()->GetLength());

                    CACASNWRAPPER_CREATE(CACX509V3PolicyQualifierInfo, objPDUCACX509V3PolicyQualifierInfo);
                    ASN1OpenType* data1 = objPDUCACX509V3PolicyQualifierInfo.Encode(q);
                    
                    curQualifier->data = new unsigned char[data1->numocts];
                    memcpy((void*)curQualifier->data,  data1->data, data1->numocts);

                    SET_HEAD_TAIL_INCREMENT(policyInfo->policyQualifiers, curQualifier)
                }
            }
            
            curPol->data = policyInfo;

            SET_HEAD_TAIL_INCREMENT(theSigningCertificate.policies, curPol)
        }
        theSigningCertificate.m.policiesPresent = 1;
    }

    CPKIFASNWrapper<CACCMSSigningCertificate> objPDU(BEREncCACCMSSigningCertificate, BERDecCACCMSSigningCertificate);
    ASN1OpenType* data1 = objPDU.Encode(&theSigningCertificate);

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


    //delete allocated stuff
    DListNode* cur = NULL, *tmp = NULL;
    if(theSigningCertificate.certs.count > 0)
    {
        cur = theSigningCertificate.certs.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
            {
                CACCMSESSCertID* tmpCertID = (CACCMSESSCertID*)cur->data;
                // !!! Don't free this. Rather than copying, we're content to let someone else own it
                //if(tmpCertID->issuerSerial.serialNumber != NULL)
                //  delete tmpCertID->issuerSerial.serialNumber;
                delete cur->data;
            }
            delete cur;
            cur = tmp;
        }
    }
    if(theSigningCertificate.m.policiesPresent && theSigningCertificate.policies.count > 0)
    {
        cur = theSigningCertificate.policies.head;
        while(NULL != cur)
        {
            tmp = cur->next;
            
            if(NULL != cur && NULL != cur->data)
            {
                CACX509V3PolicyInformation* tmpPolInfo= (CACX509V3PolicyInformation*)cur->data;
                DListNode* cur2 = NULL, *tmp2 = NULL;
                cur2 = tmpPolInfo->policyQualifiers.head;
                while(NULL != cur2)
                {
                    tmp2 = cur2->next;
                    if(NULL != cur2 && NULL != cur2->data)
                    {
                        delete cur2->data;
                    }
                    cur2 = tmp;
                }
                delete cur->data;
            }
            delete cur;
            cur = tmp;
        }
    }
}
CPKIFESSCertIdListPtr CPKIFSigningCertificateAttribute::GetCerts() const
{
    return m_impl->m_essCertIDList;
}
CPKIFPolicyInformationListPtr CPKIFSigningCertificateAttribute::GetPolicies() const
{
    return m_impl->m_policyList;
}
void CPKIFSigningCertificateAttribute::SetCerts(
    CPKIFESSCertIdListPtr& certIDList)
{
    m_impl->m_essCertIDList = certIDList;
}
void CPKIFSigningCertificateAttribute::SetPolicies(
    CPKIFPolicyInformationListPtr& policyList)
{
    m_impl->m_policyList = policyList;
}
void CPKIFSigningCertificateAttributeImpl::populateASN1OBJID(
    std::string objIdStr,
    ASN1OBJID *asn1ObjIdPtr)
{
    unsigned int    start = 0;
    int             offset;
    std::string         subStr, remainingStr;
    
    offset = objIdStr.find_first_of(".");
    while (start < objIdStr.length())
    {
        if (offset == -1)
        {
            offset = objIdStr.length() - start;
        }
        subStr =  objIdStr.substr(start, offset);
        asn1ObjIdPtr->subid[asn1ObjIdPtr->numids] = strtoul(subStr.c_str(),
                                                            NULL, 10);
        asn1ObjIdPtr->numids++;
        assert(asn1ObjIdPtr->numids < ASN_K_MAXSUBIDS);
        start += offset + 1;
        if (start < objIdStr.length())
        {   
            remainingStr = objIdStr.substr(start, objIdStr.length() - start);
            offset = remainingStr.find_first_of(".");
        }
    }
}