PKIFXSECCryptoX509.cpp

Go to the documentation of this file.

#include "PKIFXSECCryptoX509.h"

#include "PKIFXSECCrypto.h"
#include "PKIFXSECCryptoKeyRSA.h"
#include "PKIFXSECCryptoKeyDSA.h"
#include "PKIFAlgorithm.h"
#include "PKIFBase64.h"

#include <xsec/enc/XSCrypt/XSCryptCryptoBase64.hpp>
#include <xsec/enc/XSECCryptoException.hpp>
#include <xsec/enc/XSECCryptoUtils.hpp>
#include <xsec/framework/XSECError.hpp>


struct PKIFXSECCryptoX509Impl
{
    safeBuffer m_encoded;
    CPKIFCertificatePtr m_cert;
    IPKIFMediatorPtr m_med;
};

PKIFXSECCryptoX509::PKIFXSECCryptoX509()
:m_impl(new PKIFXSECCryptoX509Impl())
{
}

PKIFXSECCryptoX509::~PKIFXSECCryptoX509()
{
    if(m_impl) delete m_impl;
}

XSECCryptoKey::KeyType PKIFXSECCryptoX509::getPublicKeyType() const
{
    if (!m_impl->m_cert) {
        throw XSECCryptoException(XSECCryptoException::X509Error,
            "PKIFXSECCryptoX509 - getPublicKeyType called before X509 loaded");
    }
    // this shouldn't really happen...
    CPKIFSubjectPublicKeyInfoPtr spki = m_impl->m_cert->GetSubjectPublicKeyInfo();
    if(!spki) return XSECCryptoKey::KEY_NONE;
    CPKIFAlgorithm * alg = CPKIFAlgorithm::GetAlg(spki->alg()->oid());
    if(!alg) return XSECCryptoKey::KEY_NONE;
    // The XML security library only supports RSA and DSA
    switch(alg->AsymkeyAlg()) {
        case PKIFCRYPTO::RSA:
            return XSECCryptoKey::KEY_RSA_PUBLIC;
            break;
        case PKIFCRYPTO::DSS:
            return XSECCryptoKey::KEY_DSA_PUBLIC;
            break;
    }
    return XSECCryptoKey::KEY_NONE;
}

XSECCryptoKey * PKIFXSECCryptoX509::clonePublicKey() const
{
    // ideally, we'd build and validate here. the order of calls will often make that
    // impossible, though, so callers are advised to use the PKIFXSECKeyInfoResolver instead.
    CPKIFKeyMaterialPtr km(new CPKIFKeyMaterial());
    CPKIFBufferPtr encCert = m_impl->m_cert->Encoded();
    km->SetCertificate(encCert->GetBuffer(),encCert->GetLength());
    XSECCryptoKey * rv = 0;
    switch(getPublicKeyType()) {
        case XSECCryptoKey::KEY_RSA_PUBLIC:
            {
                PKIFXSECCryptoKeyRSA * rsaKey = new PKIFXSECCryptoKeyRSA();
                rsaKey->SetMediator(m_impl->m_med);
                rsaKey->SetKeyMaterial(km);
                rv = rsaKey;
                break;
            }
        case XSECCryptoKey::KEY_DSA_PUBLIC:
            {
                PKIFXSECCryptoKeyDSA * dsaKey = new PKIFXSECCryptoKeyDSA();
                dsaKey->SetMediator(m_impl->m_med);
                dsaKey->SetKeyMaterial(km);
                rv = dsaKey;
                break;
            }
    }
    return rv;
}

const XMLCh * PKIFXSECCryptoX509::getProviderName() const
{
    return pkifProvName();
}

void PKIFXSECCryptoX509::loadX509Base64Bin(
    const char * buf,
    unsigned int len)
{
    CPKIFBufferPtr derBuf(new CPKIFBuffer());
    unsigned char * rawCert = derBuf->AllocateBuffer(len);

    XSCryptCryptoBase64 b64;
    b64.decodeInit();
    unsigned int rawCertLen = b64.decode((unsigned char *) buf, len, rawCert, len);
    rawCertLen += b64.decodeFinish(&rawCert[rawCertLen], len - rawCertLen);

    m_impl->m_cert = CPKIFCertificatePtr(new CPKIFCertificate());
    m_impl->m_cert->Decode(rawCert,rawCertLen);

    m_impl->m_encoded.sbStrncpyIn(buf,len);
    m_impl->m_encoded.sbMemcpyIn(len,(void*)"\0",1);
    m_impl->m_encoded.setBufferType(safeBuffer::BUFFER_CHAR);
}

void PKIFXSECCryptoX509::SetCertificate(const CPKIFCertificatePtr & cert)
{
    m_impl->m_cert = cert;
    CPKIFBufferPtr encodedCert = cert->Encoded();
    char * b64encoded;
    if(!B64Encode(encodedCert->GetBuffer(), encodedCert->GetLength(), &b64encoded))
        throw XSECCryptoException(XSECCryptoException::X509Error,
            "PKIFXSECCryptoX509 - unable to encode certificate for later");
    m_impl->m_encoded.sbStrcpyIn(b64encoded);
    delete[] b64encoded;
    
}

safeBuffer & PKIFXSECCryptoX509::getDEREncodingSB(void)
{
    return m_impl->m_encoded;
}
const safeBuffer & PKIFXSECCryptoX509::getDEREncodingSB(void) const
{
    return m_impl->m_encoded;
}

void PKIFXSECCryptoX509::SetMediator(
    IPKIFMediatorPtr & med)
{
    m_impl->m_med = med;
}