Base64.cpp

Go to the documentation of this file.

#include <string>
#include <cstring>
#include "Base64Buffer.h"
#include "PKIFBase64.h"
#include "PKIFException.h"
#include "components.h"
#include "PKIFCommonErrors.h"

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

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


bool CAC_API B64Decode(const char * encoded, unsigned char ** decoded, unsigned long * decodedLen)
{
    CBase64Buffer b64;
    // better to spend a little memory than the time here

    unsigned long dlen = 0;
    try 
    {
        dlen = numeric_cast<unsigned long>(strlen(encoded));
    }
    catch(bad_numeric_cast &) 
    {
        throw CPKIFException(TOOLKIT_UTILS, COMMON_INVALID_INPUT, "string len is an impossibly long number.");
    }
    unsigned char * outbuf = new unsigned char[dlen];
    memset(outbuf,0x00,dlen);
    if(!b64.decode(encoded,dlen,outbuf,&dlen)) {
        delete[] outbuf;
        return false;
    }
    *decoded = outbuf;
    *decodedLen = dlen;
    return true;
}


bool CAC_API PEMDecode(const char * encoded, unsigned char ** decoded, unsigned long * decodedLen)
{
    if(!encoded)
        return false;
    else
    {
        unsigned long encodedLen = numeric_cast<unsigned long>(strlen(encoded));
        return PEMDecode_l(encoded, encodedLen, decoded, decodedLen);
    }
}

bool CAC_API PEMDecode_l(const char * encoded, unsigned long sourceLen, unsigned char ** decoded, unsigned long * decodedLen)
{
    if(NULL == encoded || 0 >= sourceLen)
        return false;
/*  int start = 0;
    // if a PEM-encoded blob was passed in, lop off the first line
    if('-' == encoded[start]) {
        while('\n' != *(encoded + start)) {
            start++;
        }
        start++;
    }
    // remove everything following and including the first '-'
    char * end = const_cast<char *>(strchr(encoded+start,'-'));
    size_t encodedlen;
    if(NULL != end) {
        encodedlen = end - (encoded + start);
    } else {
        encodedlen = sourceLen;
    }
    char * rawenc = new char[encodedlen+1];
    memset(rawenc,0x00,encodedlen+1);
    memcpy(rawenc,encoded+start,encodedlen);
    bool rv = B64Decode(rawenc,decoded,decodedLen);
    delete[] rawenc;
    return rv;
    */

    int start = 0;
    // if a PEM-encoded blob was passed in, lop off the first line
    if('-' == encoded[start]) {
        while('\n' != *(encoded + start)) {
            start++;
        }
        start++;
    }

    std::string copy(encoded+start, sourceLen-start);
    std::string::iterator pos = copy.begin();
    std::string::iterator copyEnd = copy.end();

    // if a PEM-encoded blob was passed in, lop off the first line
    if('-' == *pos)
    {
        while('\n' != *pos && copyEnd != pos)
        {
            ++pos;
        }
        ++pos;
    }

    size_t index = copy.find("-", std::distance(copy.begin(), pos));
    if(index != std::string::npos)
    {
        copy[index] = 0x00;
    }
    bool rv = B64Decode(copy.c_str(),decoded,decodedLen);
    return rv;
}
bool CAC_API B64Encode(const unsigned char * plain, unsigned long plainLen, char ** encoded)
{
    CBase64Buffer b64;
    // better to spend the memory than the time getting the exact size now
    unsigned long encodedLen = plainLen * 2;
    char * outBuf = new char[encodedLen];
    if(!outBuf) return false;
    // memset to 0 so strlen() works
    memset(outBuf,0x00,encodedLen);
    if(!b64.encode(plain,plainLen,outBuf,&encodedLen)) {
        delete[] outBuf;
        return false;
    }
    // caller frees
    *encoded = outBuf;
    return true;
}