PKIFXSECCryptoKeyDSA.cpp

Go to the documentation of this file.

#include "PKIFXSECCryptoKeyDSA.h"
#include "PKIFXSECCrypto.h"

#include <xsec/enc/XSCrypt/XSCryptCryptoBase64.hpp>
#include <xsec/enc/XSECCryptoException.hpp>
#include <xsec/enc/XSECCryptoUtils.hpp>
#include <xsec/framework/XSECError.hpp>
struct PKIFXSECCryptoKeyDSAImpl
{
    IPKIFMediatorPtr m_med;
    CPKIFKeyMaterialPtr m_km;
    CPKIFCredentialPtr m_cred;
};

PKIFXSECCryptoKeyDSA::PKIFXSECCryptoKeyDSA()
:m_impl(new PKIFXSECCryptoKeyDSAImpl())
{
}

PKIFXSECCryptoKeyDSA::~PKIFXSECCryptoKeyDSA()
{
    if(m_impl) {
        delete m_impl;
        m_impl = 0;
    }
}

XSECCryptoKey * PKIFXSECCryptoKeyDSA::clone() const
{
    PKIFXSECCryptoKeyDSA * rv = new PKIFXSECCryptoKeyDSA();
    rv->m_impl->m_cred = m_impl->m_cred;
    rv->m_impl->m_km = m_impl->m_km;
    rv->m_impl->m_med = m_impl->m_med;
    return rv;
}

bool PKIFXSECCryptoKeyDSA::verifyBase64Signature(
    unsigned char * hashBuf,
    unsigned int hashLen,
    char * base64Signature,
    unsigned int sigLen)
{
    if(!m_impl->m_km){
        throw XSECCryptoException(XSECCryptoException::DSAError,
        "PKIFXSECCryptoKeyDSA - No key available for DSA verification");
    }
    IPKIFCryptoRawOperations* cm = m_impl->m_med->GetMediator<IPKIFCryptoRawOperations>();
    if(!cm) {
        throw XSECCryptoException(XSECCryptoException::DSAError,
        "PKIFXSECCryptoKeyDSA - No appropriate mediator available for DSA verification");
    }
    // Decode the signature
    XSCryptCryptoBase64 b64;
    unsigned char * decSig = new unsigned char[sigLen];
    b64.decodeInit();
    unsigned int decSigLen = b64.decode((unsigned char *) base64Signature, sigLen, decSig, sigLen);
    decSigLen += b64.decodeFinish(&decSig[decSigLen], sigLen - decSigLen);
    bool ok = false;
    try {
        ok = cm->Verify(*(m_impl->m_km),hashBuf,hashLen,decSig,decSigLen,PKIFCRYPTO::SHA1);
    }catch(CPKIFException & e){
        throw XSECCryptoException(XSECCryptoException::DSAError, e.GetDescription());
    }
    // the key resolver class will have already verified the cert and set up the key material
    return ok;
}

unsigned int PKIFXSECCryptoKeyDSA::signBase64Signature(
    unsigned char * hashBuf,
    unsigned int hashLen,
    char * base64SignatureBuf,
    unsigned int base64SignatureBufLen)
{
    if(!m_impl->m_cred) {
        throw XSECCryptoException(XSECCryptoException::DSAError,
        "PKIFXSECCryptoKeyDSA - No key available for DSA signing");
    }
    IPKIFCryptoKeyIDOperations* cm = m_impl->m_med->GetMediator<IPKIFCryptoKeyIDOperations>();
    if(!cm) {
        throw XSECCryptoException(XSECCryptoException::DSAError,
        "PKIFXSECCryptoKeyDSA - No appropriate mediator available for DSA signing");
    }
    // XXX *** as the library is currently written, this will only ever be called for plain DSA signatures.
    // thus, always 40
    int sigOutLen = 40;
    unsigned char * sigOut = new unsigned char[sigOutLen];
    try {
        // XXX *** The hard coded hash is a limitation of the XML security library's treatment of DSA
        cm->Sign(*(m_impl->m_cred),hashBuf,hashLen,sigOut,&sigOutLen,PKIFCRYPTO::SHA1);
    }catch(CPKIFException & e){
        throw XSECCryptoException(XSECCryptoException::DSAError, e.GetDescription());
    }

    // Now encode
    XSCryptCryptoBase64 b64;
    b64.encodeInit();
    unsigned int ret = b64.encode(sigOut, 40, (unsigned char *) base64SignatureBuf, base64SignatureBufLen);
    ret += b64.encodeFinish((unsigned char *) &base64SignatureBuf[ret], base64SignatureBufLen - ret);
    return ret;
}


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

void PKIFXSECCryptoKeyDSA::SetCredential(
    CPKIFCredentialPtr & cred)
{
    m_impl->m_cred = cred;
}

void PKIFXSECCryptoKeyDSA::SetKeyMaterial(
    CPKIFKeyMaterialPtr & km)
{
    m_impl->m_km = km;
}

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

XSECCryptoKey::KeyType PKIFXSECCryptoKeyDSA::getKeyType() const
{
    if(!m_impl) return XSECCryptoKey::KEY_NONE;
    if(m_impl->m_cred) return XSECCryptoKey::KEY_DSA_PAIR;
    if(m_impl->m_km) return XSECCryptoKey::KEY_DSA_PUBLIC;
    return XSECCryptoKey::KEY_NONE;
}