SignerInfo.cpp

Go to the documentation of this file.

#include "SignerInfo.h"

#include "IssuerAndSerialNumber.h"
#include "Buffer.h"
#include "Attribute.h"
#include "AlgorithmIdentifier.h"
#include "KeyUsage.h"
#include "Certificate.h"

#include "PKIFCredential.h"
#include "PKIFKeyMaterial.h"

#include "PKIFCMSAttributeMediator2.h"
#include "ToolkitUtils.h"
#include "PKIFMessageException.h"
#include "PKIFMessageErrors.h"
#include "ASN1Helper.h"

#include "CryptographicMessageSyntax2004.h"

#include <iterator>
struct CPKIFSignerInfoImpl
{
    //structure members
    CACCMSCMSVersion m_version;
    CPKIFIssuerAndSerialNumberPtr m_issAndSerialNum;    //part of SignerIdentifier
    CPKIFBufferPtr m_skid;                          //part of SignerIdentifier
    CPKIFAlgorithmIdentifierPtr m_digestAlg;
    CPKIFAttributeList m_signedAttributes;
    CPKIFAttributeList m_unsignedAttributes;
    //signature alg determined from credential, signature value calculated

    CPKIFAlgorithmIdentifierPtr m_sigAlg;
    CPKIFBufferPtr m_sig;

    void populateUnsignedAttributesVector(const CACCMSUnsignedAttributes& ua);
    void populateSignedAttributesVector(const CACCMSSignedAttributes& sa);

    CPKIFCredentialPtr m_cred;
    CPKIFKeyMaterial* m_keyMaterial;
    bool m_bDecoded;

    CPKIFBufferPtr signedUnencodedAttrBufferPtr;
    CPKIFBufferPtr unsignedUnencodedAttrBufferPtr;
};

CPKIFSignerInfo::CPKIFSignerInfo()
    :m_impl (new CPKIFSignerInfoImpl)
{
    m_impl->m_digestAlg = g_sha1AI;
    m_impl->m_keyMaterial = NULL;
    m_impl->m_bDecoded = false;
    m_impl->m_version = CACCMSv1;
}

CPKIFSignerInfo::CPKIFSignerInfo(
    //const CACCMSSignerInfo& si
    const CPKIFBufferPtr& siBuf)
    :m_impl (new CPKIFSignerInfoImpl)
{
    CACASNWRAPPER_CREATE(CACCMSSignerInfo, InfoWrapper);
    InfoWrapper.Decode(siBuf->GetBuffer(), siBuf->GetLength());

    m_impl->m_keyMaterial = NULL;

    m_impl->m_version = InfoWrapper->version;

    //CPKIFAlgorithmIdentifier creation
    CPKIFOIDPtr algOID(new CPKIFOID(InfoWrapper->digestAlgorithm.algorithm.subid,
                        InfoWrapper->digestAlgorithm.algorithm.numids));
    
    CPKIFBufferPtr paramBuf;
    if(InfoWrapper->digestAlgorithm.m.parametersPresent)
    {
        paramBuf = CPKIFBufferPtr(new CPKIFBuffer(InfoWrapper->digestAlgorithm.parameters.data,
                    InfoWrapper->digestAlgorithm.parameters.numocts));
    
    
    }
    
    CPKIFAlgorithmIdentifierPtr alg(new CPKIFAlgorithmIdentifier(algOID, paramBuf)); 
    //CPKIFAlgorithmIdentifierPtr alg(new CPKIFAlgorithmIdentifier(*(CACX509V3AlgorithmIdentifier*)&InfoWrapper->digestAlgorithm));
    
    
    m_impl->m_digestAlg = alg;

    switch(InfoWrapper->sid.t)
    {
    case 1:
        {

        CACASNWRAPPER_CREATE(CACCMSIssuerAndSerialNumber, isnWrapper);
        ASN1OpenType* rawIsn = isnWrapper.Encode(InfoWrapper->sid.u.issuerAndSerialNumber);
        CPKIFBufferPtr buf(new CPKIFBuffer(rawIsn->data, rawIsn->numocts));
        delete rawIsn;
        
        CPKIFIssuerAndSerialNumberPtr tmpISN(new CPKIFIssuerAndSerialNumber(buf));
        //CPKIFIssuerAndSerialNumberPtr tmpISN(new CPKIFIssuerAndSerialNumber(*si.sid.u.issuerAndSerialNumber));
        m_impl->m_issAndSerialNum = tmpISN;
        }
        break;
    case 2:
        {
        CPKIFBufferPtr tmpSID(new CPKIFBuffer(InfoWrapper->sid.u.subjectKeyIdentifier->data, InfoWrapper->sid.u.subjectKeyIdentifier->numocts));
        m_impl->m_skid = tmpSID;
        }
        break;
    }

    CPKIFBufferPtr tmpSig(new CPKIFBuffer(InfoWrapper->signature.data, InfoWrapper->signature.numocts));
    m_impl->m_sig = tmpSig;

    //CPKIFAlgorithmIdentifier creation
    CPKIFOIDPtr algOID2(new CPKIFOID(InfoWrapper->signatureAlgorithm.algorithm.subid,
                InfoWrapper->signatureAlgorithm.algorithm.numids));
    
    CPKIFBufferPtr paramBuf2;
    if(InfoWrapper->signatureAlgorithm.m.parametersPresent)
    {
        paramBuf2 = CPKIFBufferPtr(new CPKIFBuffer(InfoWrapper->signatureAlgorithm.parameters.data,
                InfoWrapper->signatureAlgorithm.parameters.numocts));
    
    
    }
    
    CPKIFAlgorithmIdentifierPtr tmpSigAlg(new CPKIFAlgorithmIdentifier(algOID2, paramBuf2));
    //CPKIFAlgorithmIdentifierPtr tmpSigAlg(new CPKIFAlgorithmIdentifier(*(CACX509V3AlgorithmIdentifier*)&InfoWrapper->signatureAlgorithm));
    m_impl->m_sigAlg = tmpSigAlg;

    if(InfoWrapper->m.signedAttrsPresent)
    {
      try
      {
        CACASNWRAPPER_CREATE(CACCMSSignedAttributes, attrWrapper);
        ASN1OpenType *data = attrWrapper.Encode (&InfoWrapper->signedAttrs);
        CPKIFBufferPtr tmp(new CPKIFBuffer(data->data, data->numocts));
        m_impl->signedUnencodedAttrBufferPtr = tmp;
        delete data;
      }
      catch (...)
      {}
    }

    if(InfoWrapper->m.unsignedAttrsPresent)
    {
      try
      {
        CACASNWRAPPER_CREATE(CACCMSUnsignedAttributes, attrWrapper);
        ASN1OpenType *data = attrWrapper.Encode (&InfoWrapper->unsignedAttrs);
        CPKIFBufferPtr tmp(new CPKIFBuffer(data->data, data->numocts));
        m_impl->unsignedUnencodedAttrBufferPtr = tmp;
        delete data;
      }
      catch (...)
      {}
    }

    m_impl->m_bDecoded = true;
}

/*
CPKIFSignerInfo::CPKIFSignerInfo(
    const CACCMSSignerInfo& si)
    :m_impl (new CPKIFSignerInfoImpl)
{
    m_impl->m_keyMaterial = NULL;

    m_impl->m_version = si.version;

    CPKIFAlgorithmIdentifierPtr alg(new CPKIFAlgorithmIdentifier(*(CACX509V3AlgorithmIdentifier*)&si.digestAlgorithm));
    m_impl->m_digestAlg = alg;

    switch(si.sid.t)
    {
    case 1:
        {

        CACASNWRAPPER_CREATE(CACCMSIssuerAndSerialNumber, isnWrapper);
        ASN1OpenType* rawIsn = isnWrapper.Encode(si.sid.u.issuerAndSerialNumber);
        CPKIFBufferPtr buf(new CPKIFBuffer(rawIsn->data, rawIsn->numocts));
        delete rawIsn;
        
        CPKIFIssuerAndSerialNumberPtr tmpISN(new CPKIFIssuerAndSerialNumber(buf));
        //CPKIFIssuerAndSerialNumberPtr tmpISN(new CPKIFIssuerAndSerialNumber(*si.sid.u.issuerAndSerialNumber));
        m_impl->m_issAndSerialNum = tmpISN;
        }
        break;
    case 2:
        {
        CPKIFBufferPtr tmpSID(new CPKIFBuffer(si.sid.u.subjectKeyIdentifier->data, si.sid.u.subjectKeyIdentifier->numocts));
        m_impl->m_skid = tmpSID;
        }
        break;
    }

    CPKIFBufferPtr tmpSig(new CPKIFBuffer(si.signature.data, si.signature.numocts));
    m_impl->m_sig = tmpSig;

    CPKIFAlgorithmIdentifierPtr tmpSigAlg(new CPKIFAlgorithmIdentifier(*(CACX509V3AlgorithmIdentifier*)&si.signatureAlgorithm));
    m_impl->m_sigAlg = tmpSigAlg;

    if(si.m.signedAttrsPresent)
    {
      try
      {
        CACASNWRAPPER_CREATE(CACCMSSignedAttributes, attrWrapper);
        ASN1OpenType *data = attrWrapper.Encode (&si.signedAttrs);
        CPKIFBufferPtr tmp(new CPKIFBuffer(data->data, data->numocts));
        m_impl->signedUnencodedAttrBufferPtr = tmp;
        delete data;
      }
      catch (...)
      {}
    }

    if(si.m.unsignedAttrsPresent)
    {
      try
      {
        CACASNWRAPPER_CREATE(CACCMSUnsignedAttributes, attrWrapper);
        ASN1OpenType *data = attrWrapper.Encode (&si.unsignedAttrs);
        CPKIFBufferPtr tmp(new CPKIFBuffer(data->data, data->numocts));
        m_impl->unsignedUnencodedAttrBufferPtr = tmp;
        delete data;
      }
      catch (...)
      {}
    }

    m_impl->m_bDecoded = true;
}
*/
void CPKIFSignerInfo::GetEncodedSignedAttributes (
    CPKIFBufferPtr& buf) {
  if (m_impl)
  {
    buf = m_impl->signedUnencodedAttrBufferPtr;
  }
  else
  {
    CPKIFBufferPtr nullExt;
    buf = nullExt;
  }
}
void CPKIFSignerInfo::GetEncodedUnsignedAttributes (
    CPKIFBufferPtr& buf) {
  if (m_impl)
  {
    buf = m_impl->unsignedUnencodedAttrBufferPtr;
  }
  else
  {
    CPKIFBufferPtr nullExt;
    buf = nullExt;
  }
}

CPKIFSignerInfo::~CPKIFSignerInfo()
{
    delete m_impl;
    m_impl = NULL;
}
bool CPKIFSignerInfo::Decoded() const
{
    return m_impl->m_bDecoded;
}
CPKIFSignerInfo::SignerIdentifierChoice CPKIFSignerInfo::GetSignerIdentifierChoice() const
{
    CPKIFIssuerAndSerialNumberPtr issAndSN = GetIssuerAndSerialNumber();
    if(issAndSN != (CPKIFIssuerAndSerialNumber*)NULL)
        return CPKIFSignerInfo::ISSUERANDSERIAL;

    CPKIFBufferPtr skid = GetSKID();
    if(skid != (CPKIFBuffer*)NULL)
        return CPKIFSignerInfo::SKID;

    return CPKIFSignerInfo::UNSET;
}
CPKIFCredentialPtr CPKIFSignerInfo::GetCredential() const 
{
    return m_impl->m_cred;
}
/*CACCMSCMSVersion*/ unsigned int CPKIFSignerInfo::Version() 
{
    return (unsigned int) m_impl->m_version;
}
CPKIFAlgorithmIdentifierPtr CPKIFSignerInfo::GetSignatureAlgorithm() const
{
    return m_impl->m_sigAlg;
}
CPKIFBufferPtr CPKIFSignerInfo::GetSignature() const
{
    return m_impl->m_sig;
}
CPKIFAlgorithmIdentifierPtr CPKIFSignerInfo::GetDigestAlg() const 
{
    return m_impl->m_digestAlg;
}
void CPKIFSignerInfo::SetDigestAlg(
    CPKIFAlgorithmIdentifierPtr& digAlg) 
{
    //accept no NULLs
    if(digAlg == (CPKIFAlgorithmIdentifier*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE, COMMON_INVALID_INPUT);

    m_impl->m_digestAlg = digAlg;
}
void CPKIFSignerInfo::SetIssuerAndSerialNumber(
    CPKIFIssuerAndSerialNumberPtr& iasn)
{
    //accept no NULLs
    if(iasn == (CPKIFIssuerAndSerialNumber*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE, COMMON_INVALID_INPUT);

    m_impl->m_issAndSerialNum = iasn;
}
CPKIFIssuerAndSerialNumberPtr CPKIFSignerInfo::GetIssuerAndSerialNumber() const 
{
    return m_impl->m_issAndSerialNum;
}
void CPKIFSignerInfo::SetSKID(CPKIFBufferPtr& skid)
{
    //accept no NULLs
    if(skid == (CPKIFBuffer*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE, COMMON_INVALID_INPUT);

    m_impl->m_skid = skid;
}
CPKIFBufferPtr CPKIFSignerInfo::GetSKID() const 
{
    return m_impl->m_skid;
}
void CPKIFSignerInfo::SetCredential(
    CPKIFCredentialPtr& cred,
    bool enforceKeyUsage) 
{
    if(cred == (CPKIFCredential*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE_ASN, COMMON_INVALID_INPUT, "NULL credential.");

    CPKIFCertificatePtr cert = cred->GetCertificate();
    if(cert == (CPKIFCertificate*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE_ASN, MSG_INVALID_CREDENTIAL, "Credential does not contain a certificate.");

    CPKIFKeyUsagePtr keyUsage = cert->GetExtension<CPKIFKeyUsage>();
    if(!enforceKeyUsage || keyUsage == (CPKIFKeyUsage*)NULL || keyUsage->DigitalSignature() || keyUsage->NonRepudiation())
        m_impl->m_cred = cred;
    else
        throw CPKIFMessageException(TOOLKIT_MESSAGE_ASN, MSG_INVALID_CREDENTIAL, "Credential is not valid for signature generation purposes.");
}
void CPKIFSignerInfo::GetUnsignedAttributes(
    CPKIFAttributeList& ual)
{
    CPKIFCMSAttributeMediator2* mediator = CPKIFCMSAttributeMediator2::GetInstance();

    std::vector<CPKIFAttributePtr> tmpList;
    this->IPKIFHasAttributes::GetUnsignedAttributes(mediator, tmpList);

    copy(tmpList.begin(),tmpList.end(), back_inserter(ual));
}
void CPKIFSignerInfo::GetSignedAttributes(
    CPKIFAttributeList& sal)
{
    sal.clear();

    CPKIFCMSAttributeMediator2* mediator = CPKIFCMSAttributeMediator2::GetInstance();
    
    std::vector<CPKIFAttributePtr> tmpList;
    this->IPKIFHasAttributes::GetSignedAttributes(mediator, tmpList);

    copy(tmpList.begin(),tmpList.end(), back_inserter(sal));
}
void CPKIFSignerInfo::AddUnsignedAttribute(
    CPKIFAttributePtr& ua)
{
    //accept no NULLs
    if(ua == (CPKIFAttribute*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE, COMMON_INVALID_INPUT);

    m_impl->m_unsignedAttributes.push_back(ua);
}
void CPKIFSignerInfo::AddSignedAttribute(CPKIFAttributePtr& sa)
{
    //accept no NULLs
    if(sa == (CPKIFAttribute*)NULL)
        throw CPKIFMessageException(TOOLKIT_MESSAGE, COMMON_INVALID_INPUT);

    m_impl->m_signedAttributes.push_back(sa);
}
void CPKIFSignerInfoImpl::populateUnsignedAttributesVector(
    const CACCMSUnsignedAttributes& ua)
{
    //if we've already populated the extensions vector then return
    if(!m_unsignedAttributes.empty())
        return;

    //if there are no extensions then return
    if(0 == ua.count)
    {
        m_unsignedAttributes.clear();
        return;
    }

    //create an extensions mediator using the default extension colleagues and initialize it
    CPKIFCMSAttributeMediator2* mediator = CPKIFCMSAttributeMediator2::GetInstance();

    //iterate over the list of extensions and populate the extensions vector
    DListNode* cur = ua.head;
    for(unsigned int ii = 0; ii < ua.count; ++ii)
    {
        CACCMSAttribute* attr = (CACCMSAttribute*) cur->data;
        CPKIFOIDPtr oid(new CPKIFOID(attr->attrType.subid, attr->attrType.numids));
        CPKIFBufferPtr buf(new CPKIFBuffer(attr->attrValues.data, attr->attrValues.numocts));

        m_unsignedAttributes.push_back(mediator->getAttribute(oid, buf));
        cur = cur->next;
    }
}
void CPKIFSignerInfoImpl::populateSignedAttributesVector(
    const CACCMSSignedAttributes& sa)
{
    //if we've already populated the extensions vector then return
    if(!m_signedAttributes.empty())
        return;

    //if there are no extensions then return
    if(0 == sa.count)
    {
        m_signedAttributes.clear();
        return;
    }

    //create an extensions mediator using the default extension colleagues and initialize it
    CPKIFCMSAttributeMediator2* mediator = CPKIFCMSAttributeMediator2::GetInstance();

    //iterate over the list of extensions and populate the extensions vector
    DListNode* cur = sa.head;
    for(unsigned int ii = 0; ii < sa.count; ++ii)
    {
        CACCMSAttribute* attr = (CACCMSAttribute*) cur->data;
        CPKIFOIDPtr oid(new CPKIFOID(attr->attrType.subid, attr->attrType.numids));
        CPKIFBufferPtr buf(new CPKIFBuffer(attr->attrValues.data, attr->attrValues.numocts));

        m_signedAttributes.push_back(mediator->getAttribute(oid, buf));
        cur = cur->next;
    }
}
void CPKIFSignerInfo::_GetSignedAttributes(
    std::vector<CPKIFAttributePtr>& attrVector)
{
    CPKIFCMSAttributeMediator2* mediator = CPKIFCMSAttributeMediator2::GetInstance();
    this->IPKIFHasAttributes::GetSignedAttributes(mediator, attrVector);
}
void CPKIFSignerInfo::_GetUnsignedAttributes(
    std::vector<CPKIFAttributePtr>& attrVector)
{
    CPKIFCMSAttributeMediator2* mediator = CPKIFCMSAttributeMediator2::GetInstance();
    this->IPKIFHasAttributes::GetUnsignedAttributes(mediator, attrVector);
}
void CPKIFSignerInfo::GetAddedSignedAttributes(
    std::vector<CPKIFAttributePtr>& attr)
{
  CPKIFAttributeList::iterator pos;
  CPKIFAttributeList::iterator end = m_impl->m_signedAttributes.end();
  for (pos = m_impl->m_signedAttributes.begin(); pos != end; pos++)
  {
    attr.push_back (*pos);
  }
}
void CPKIFSignerInfo::GetAddedUnsignedAttributes(
    std::vector<CPKIFAttributePtr>& attr)
{
  CPKIFAttributeList::iterator pos;
  CPKIFAttributeList::iterator end = m_impl->m_unsignedAttributes.end();
  for (pos = m_impl->m_unsignedAttributes.begin(); pos != end; pos++)
  {
    attr.push_back (*pos);
  }
}