PKIFXSECCrypto.cpp

Go to the documentation of this file.

#include "PKIFXSECCrypto.h"

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

#include "PKIFXSECCryptoHash.h"
#include "PKIFXSECCryptoKeyHMAC.h"
#include "PKIFXSECCryptoKeyDSA.h"
#include "PKIFXSECCryptoKeyRSA.h"
#include "PKIFXSECCryptoX509.h"
#include "PKIFXSECCryptoSymmetricKey.h"

struct PKIFXSECCryptoImpl
{
    PKIFXSECCryptoImpl();

    IPKIFMediatorPtr m_mediator;

    static bool s_bInitialized;
    static XMLCh * s_provName;
};

bool PKIFXSECCryptoImpl::s_bInitialized = false;
XMLCh * PKIFXSECCryptoImpl::s_provName = 0;
PKIFXSECCryptoImpl::PKIFXSECCryptoImpl()
{
    if(!s_bInitialized) {
        s_bInitialized = true;
        s_provName = XMLString::transcode("PKIF XML Security Crypto provider");
    }
}

PKIFXSECCrypto::PKIFXSECCrypto()
:m_impl(new PKIFXSECCryptoImpl)
{
    // XXX MAYBE TODO: have a default set load from resources
    // not doing this right now because it could unduly increase library load time
}

PKIFXSECCrypto::PKIFXSECCrypto(
                               IPKIFMediatorPtr & med
                               )
:m_impl(new PKIFXSECCryptoImpl)
{
    m_impl->m_mediator = med;
}

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

XSECCryptoHash * PKIFXSECCrypto::hashSHA1() const
{
    return hashSHA(160);
}

XSECCryptoHash * PKIFXSECCrypto::hashSHA(
    int length) const
{
    PKIFXSECCryptoHash * rv = 0;
    if(!m_impl->m_mediator) return rv;
        
    try {
        switch(length) {
            case 160:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA1));
                break;
            case 224:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA224));
                break;
            case 256:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA256));
                break;
            case 384:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA384));
                break;
            case 512:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA512));
                break;
        }
    } catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    return rv;
}

XSECCryptoHash * PKIFXSECCrypto::hashHMACSHA1() const
{
    return hashHMACSHA(160);
}

XSECCryptoHash * PKIFXSECCrypto::hashHMACSHA(
    int length) const
{

    PKIFXSECCryptoHash * rv = 0;
    if(!m_impl->m_mediator) return rv;  
    try {
        switch(length) {
            case 160:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA1));
                break;
            case 224:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA224));
                break;
            case 256:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA256));
                break;
            case 384:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA384));
                break;
            case 512:
                XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_SHA512));
                break;
        }
    } catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    return rv;
}

XSECCryptoHash * PKIFXSECCrypto::hashMD5() const
{
#if defined(PKIFXML_FIPSONLY)
    return 0;
#endif //defined(PKIFXML_FIPSONLY)
    PKIFXSECCryptoHash * rv = 0;
    if(!m_impl->m_mediator) return rv;
    try {
        XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_MD5));
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    return rv;
}

XSECCryptoHash * PKIFXSECCrypto::hashHMACMD5() const
{
#if defined(PKIFXML_FIPSONLY)
    return 0;
#endif //defined(PKIFXML_FIPSONLY)
    PKIFXSECCryptoHash * rv = 0;
    try {
        XSECnew(rv,PKIFXSECCryptoHash(m_impl->m_mediator,XSECCryptoHash::HASH_MD5));
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    return rv;
}

XSECCryptoKeyHMAC * PKIFXSECCrypto::keyHMAC() const
{
    XSECCryptoKeyHMAC * rv = 0;
    try {
        XSECnew(rv,PKIFXSECCryptoKeyHMAC());
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    return rv;
}

XSECCryptoBase64 * PKIFXSECCrypto::base64() const
{
    XSCryptCryptoBase64 * rv;
    XSECnew(rv,XSCryptCryptoBase64());
    return rv;
}

XSECCryptoKeyDSA * PKIFXSECCrypto::keyDSA() const
{
    PKIFXSECCryptoKeyDSA * rv;
    try {
        XSECnew(rv,PKIFXSECCryptoKeyDSA());
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    rv->SetMediator(m_impl->m_mediator);
    return rv;
}

XSECCryptoKeyRSA * PKIFXSECCrypto::keyRSA() const
{
    PKIFXSECCryptoKeyRSA * rv;
    try {
        XSECnew(rv,PKIFXSECCryptoKeyRSA());
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    rv->SetMediator(m_impl->m_mediator);
    return rv;
}

XSECCryptoX509 * PKIFXSECCrypto::X509() const
{
    PKIFXSECCryptoX509 * rv;
    try {
        XSECnew(rv,PKIFXSECCryptoX509());
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    rv->SetMediator(m_impl->m_mediator);
    return rv;
}

bool PKIFXSECCrypto::algorithmSupported(XSECCryptoSymmetricKey::SymmetricKeyType alg) const
{
    if( alg == XSECCryptoSymmetricKey::KEY_3DES_192 ||
        alg == XSECCryptoSymmetricKey::KEY_AES_128 ||
        alg == XSECCryptoSymmetricKey::KEY_AES_192 ||
        alg == XSECCryptoSymmetricKey::KEY_AES_256 )
    {
        return true;
    }
    return false;
}

bool PKIFXSECCrypto::algorithmSupported(XSECCryptoHash::HashType alg) const
{
    if( alg == XSECCryptoHash::HASH_SHA1 ||
        alg == XSECCryptoHash::HASH_MD5 ||
        alg == XSECCryptoHash::HASH_SHA224 ||
        alg == XSECCryptoHash::HASH_SHA256 ||
        alg == XSECCryptoHash::HASH_SHA384 ||
        alg == XSECCryptoHash::HASH_SHA512 )
    {
        return true;
    }
    return false;
}

XSECCryptoSymmetricKey  * PKIFXSECCrypto::keySymmetric(
    XSECCryptoSymmetricKey::SymmetricKeyType alg) const
{
    PKIFXSECCryptoSymmetricKey * rv = 0;
    IPKIFCryptoRawOperations * raw = m_impl->m_mediator->GetMediator<IPKIFCryptoRawOperations>();
    if(!raw) return 0;
    try {
        XSECnew(rv,PKIFXSECCryptoSymmetricKey(raw));
    }catch(XSECException &) {
        // PKIF Exceptions get eaten by XSECnew. The right thing to do here is return 0.
        rv = 0;
    }
    rv->setSymmetricType(alg);
    return rv;
}

unsigned int PKIFXSECCrypto::getRandom(
       unsigned char * buffer,
       unsigned int numOctets) const
{
    IPKIFCryptoMisc * misc = m_impl->m_mediator->GetMediator<IPKIFCryptoMisc>();
    if(!misc) return 0;
    try{
        misc->GenRandom(buffer,numOctets);
    } catch(CPKIFException &) {
        return 0;
    }
    return numOctets;
}


const XMLCh * PKIFXSECCrypto::getProviderName() const
{
    return m_impl->s_provName;
}

const XMLCh * pkifProvName()
{
    static PKIFXSECCrypto xsc;
    return xsc.getProviderName();
}