PKIFCryptoPPKeyMaterial.cpp

Go to the documentation of this file.

#include "PKIFCryptoPPKeyMaterial.h"

#include "ASN1HelperLib.h"

#include "Buffer.h"
#include "Certificate.h"
#include "SubjectPublicKeyInfo.h"
#include "AlgorithmIdentifier.h"
#include "ASN1Helper.h"
#include "PKIFAlgorithm.h"
#include "ooasn1.h"
#include "PKIX1Explicit88.h"
#include "PKIFCryptoException.h"
#include "PKIFCryptoPPErrors.h"
#include "ToolkitUtils.h"

#include "boost/numeric/conversion/cast.hpp"

using boost::numeric_cast;
using boost::bad_numeric_cast;

CPKIFCryptoPPKeyMaterial::CPKIFCryptoPPKeyMaterial(void)
:m_rawSPKI((CPKIFBuffer*)0),m_alg(0),CPKIFKeyMaterial(), m_hasParams(false)
{
}

CPKIFCryptoPPKeyMaterial::~CPKIFCryptoPPKeyMaterial(void)
{
}

CPKIFCryptoPPKeyMaterial::CPKIFCryptoPPKeyMaterial(const CPKIFCertificate & cert)
:m_rawSPKI((CPKIFBuffer*)0),m_alg(0),CPKIFKeyMaterial(), m_hasParams(false)
{
    InitWithCert(cert);
}

CPKIFCryptoPPKeyMaterial::CPKIFCryptoPPKeyMaterial(CPKIFSubjectPublicKeyInfoPtr & spki)
:m_rawSPKI((CPKIFBuffer*)0),m_alg(0),CPKIFKeyMaterial(), m_hasParams(false)
{
    InitWithSPKI(spki);
}

CPKIFCryptoPPKeyMaterial::CPKIFCryptoPPKeyMaterial(const CPKIFKeyMaterial & km)
:m_rawSPKI((CPKIFBuffer*)0),m_alg(0),CPKIFKeyMaterial(), m_hasParams(false)
{
    InitWithKeyMaterial(km);
}

CPKIFBufferPtr CPKIFCryptoPPKeyMaterial::GetRawSPKI(void) const
{
    return m_rawSPKI;
}

const CPKIFAlgorithm * CPKIFCryptoPPKeyMaterial::GetKeyAlg(void) const
{
    return m_alg;
}

void CPKIFCryptoPPKeyMaterial::SetRawSPKI(
    const CPKIFBufferPtr & key
    )
{
    m_rawSPKI = key;
    if(m_rawSPKI) {
        CACASNWRAPPER_CREATE(CACX509V3SubjectPublicKeyInfo, spkiPDU);
        CACX509V3SubjectPublicKeyInfo * spki = spkiPDU.Decode(m_rawSPKI->GetBuffer(),m_rawSPKI->GetLength());
        m_hasParams = (spki->algorithm.m.parametersPresent != 0);
        CPKIFOIDPtr algOid(new CPKIFOID(spki->algorithm.algorithm.subid, spki->algorithm.algorithm.numids));
        SetKeyAlg(CPKIFAlgorithm::GetAlg(algOid));
        CPKIFBufferPtr paramsBuf(new CPKIFBuffer());
        unsigned char * p = paramsBuf->AllocateBuffer(spki->algorithm.parameters.numocts);
        memcpy(p,spki->algorithm.parameters.data,spki->algorithm.parameters.numocts);
        CPKIFAlgorithmIdentifierPtr algID(new CPKIFAlgorithmIdentifier(algOid,paramsBuf));
        CPKIFBufferPtr keyBuf(new CPKIFBuffer());
        size_t keyLen = BitsToBytes(spki->subjectPublicKey.numbits);
        try {
            p = keyBuf->AllocateBuffer(numeric_cast<int>(keyLen));
        }catch(bad_numeric_cast &){
            throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_RAW_IMPORT_FAILED);
        }
        memcpy(p,spki->subjectPublicKey.data,keyLen);
        CPKIFSubjectPublicKeyInfoPtr pkifSPKI(new CPKIFSubjectPublicKeyInfo(algID,keyBuf));
        SetSubjectPublicKeyInfo(pkifSPKI);
    } else {
        m_hasParams = false;
    }
}

void CPKIFCryptoPPKeyMaterial::SetKeyAlg(
    const CPKIFAlgorithm * alg
    )
{
    m_alg = alg;
}


void CPKIFCryptoPPKeyMaterial::InitWithKeyMaterial(const CPKIFKeyMaterial & km)
{
    CPKIFAlgorithmIdentifierPtr tmpAlgID = km.GetWorkingParameters();
    SetWorkingParameters(tmpAlgID);
    CPKIFSubjectPublicKeyInfoPtr spki = km.GetSubjectPublicKeyInfo();
    if(spki)
    {
        InitWithSPKI(spki);
    }else if(km.GetCertificateLength() > 0) {
        CPKIFCertificatePtr cert(new CPKIFCertificate);
        cert->Decode(km.GetCertificate(), km.GetCertificateLength());
        InitWithCert(*cert);
    } else {
        // XXX This should probably be a better exception, but it'll currently be reduced to
        // this by the caller and the caller should be checking to make sure this can never
        // be reached anyway.
        throw CPKIFCryptoException(TOOLKIT_CRYPTO_CRYPTOPPRAW, PKIF_CRYPTOPP_RAW_IMPORT_FAILED);
    }
}

void CPKIFCryptoPPKeyMaterial::InitWithSPKI(CPKIFSubjectPublicKeyInfoPtr & spki)
{
    m_hasParams = false;
    SetSubjectPublicKeyInfo(spki);
    // crypto++ likes its public keys in the form of DER-encoded subject public key info
    CACASNWRAPPER_CREATE(CACX509V3SubjectPublicKeyInfo, spkiPDU);
    CACX509V3SubjectPublicKeyInfo spkiStruct;
    memset(&spkiStruct,0x00,sizeof(CACX509V3SubjectPublicKeyInfo));
    spkiStruct.algorithm.m.parametersPresent = spki->alg()->hasParameters() ? 1 : 0;
    CPKIFStringPtr str(new std::string(spki->alg()->oid()->ToString())); 
    ASN1OBJID* tmpOid = ConvertStringToASN1OBJID(str);
    spkiStruct.algorithm.algorithm = *tmpOid;
    CPKIFBufferPtr params = spki->alg()->parameters();
    if(spki->alg()->hasParameters()) {
        spkiStruct.algorithm.parameters.data = params->GetBuffer();
        spkiStruct.algorithm.parameters.numocts = params->GetLength();
        m_hasParams = true;
    } else {
        CPKIFAlgorithmIdentifierPtr wp = GetWorkingParameters();
        if(wp && wp->hasParameters()) {
            m_hasParams = true;
            params = wp->parameters();
            spkiStruct.algorithm.m.parametersPresent = 1;
            spkiStruct.algorithm.parameters.data = params->GetBuffer();
            spkiStruct.algorithm.parameters.numocts = params->GetLength();
        }
    }
    CPKIFBufferPtr rk = spki->rawKey();
    spkiStruct.subjectPublicKey.data = rk->GetBuffer();
    spkiStruct.subjectPublicKey.numbits = rk->GetLength() * 8;
    ASN1OpenType * encSPKI = spkiPDU.Encode(&spkiStruct);
    delete tmpOid;
    m_rawSPKI = CPKIFBufferPtr(new CPKIFBuffer(encSPKI->data,encSPKI->numocts));
    // make sure the helper doesn't free memory the smart pointers want to take care of
    spkiStruct.subjectPublicKey.data = 0;
    spkiStruct.algorithm.parameters.data = 0;
    delete encSPKI;
    m_alg = CPKIFAlgorithm::GetAlg(spki->alg()->oid());
}

void CPKIFCryptoPPKeyMaterial::InitWithCert(const CPKIFCertificate & cert)
{
    CPKIFSubjectPublicKeyInfoPtr tmpSPKI = cert.GetSubjectPublicKeyInfo();
    InitWithSPKI(tmpSPKI);
    /* Since there's now a variant that accepts a CPKIFSubjectKeyInfo, just call that.
       The following is only here for reference.
    CPKIFBufferPtr encCert = cert.Encoded();
    CACASNWRAPPER_CREATE(CACX509V3Certificate, certPDU);
    certPDU.Decode(encCert->GetBuffer(),encCert->GetLength());
    CACASNWRAPPER_CREATE(CACX509V3SubjectPublicKeyInfo,spkiPDU);
    ASN1OpenType * encSPKI = spkiPDU.Encode(&(certPDU->tbsCertificate.subjectPublicKeyInfo));
    m_rawSPKI = CPKIFBufferPtr(new CPKIFBuffer(encSPKI->data,encSPKI->numocts));
    delete encSPKI;
    m_alg = CPKIFAlgorithm::GetAlg(cert.GetSubjectPublicKeyInfo()->alg()->oid());
    */
}

bool CPKIFCryptoPPKeyMaterial::HasParams() const
{
    return m_hasParams;
}