Base64Buffer.cpp

Go to the documentation of this file.

// Filename: Base64.cpp
// Author: Matt Cooper (mcooper@orionsec.com)
// Last Modified 26 August 2005 Geoff Beier

#include <string>
#include <cstring>
#include "Base64Buffer.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;

using namespace std;

unsigned char CBase64Buffer::m_base64chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
unsigned int CBase64Buffer::m_bitMask[] = { 0, 1, 3, 7, 15, 31, 63, 127, 255 };
int CBase64Buffer::m_decodeTable[ 256 ];
static int tableBuilt = 0;
CBase64Buffer::CBase64Buffer()
{
    m_addLineBreaks = 0;
    m_prependChars = 0;
    m_addCR = true;

    if(!tableBuilt)
    {
        unsigned int i;
        for( i=0; i < 256; i++ ) 
            m_decodeTable[i] = -2; // Illegal digit
        for( i=0; i < 64; i++ )
        {
            m_decodeTable[ m_base64chars[ i ] ] = i;
            m_decodeTable[ m_base64chars[ i ] | 0x80 ] = i; // Ignore 8th bit
        }

        tableBuilt = 1;
    }
}
CBase64Buffer::~CBase64Buffer()
{
    if(m_prependChars)
    {   delete []m_prependChars;    }
}
bool CBase64Buffer::encode(const unsigned char *in, 
                    const unsigned long inLen, 
                    char *out               /*Must be >= 1.5X+1 the length of in; more if adding line breaks*/, 
                    unsigned long *outLen   /*IN / OUT*/ )
{
    bool rv = false;
    
    try
    {
        do
        {
            if(!out)
            {   break;  }

            if(!outLen)
            {   break;  }

            if(!in)
            {   break;  }

            if(!inLen)
            {   break;  }

            {
                double din = inLen, dout = *outLen;
                double encCount = ((din * 1.5)+1); // +1 for null
                if( (dout < encCount) || 
                    (m_addLineBreaks && (dout < (encCount + ((encCount/76) * 2)))))
                {   break;  }
            }

            unsigned long tmp, bitsLeft = 0, tmpBits = 0, bitCount = 6, digit = 0, charCount = 0;
            char *o = out, *pre;
            const unsigned char *end = in + inLen;


            while( ( in < end ) && ( bitsLeft < bitCount ) ) 
            {
                tmp = *in;
                in++;

                tmpBits <<= 8;
                tmpBits |= (tmp & 0xff);
                bitsLeft += 8;
            }

            if( bitsLeft < bitCount )
            {
                tmp = tmpBits << ( bitCount - bitsLeft );
                digit = tmp & m_bitMask[bitCount];
                bitCount = bitsLeft;
                bitsLeft = 0;
            }
            else
            {
                tmp = tmpBits >> ( bitsLeft - bitCount );
                digit = tmp & m_bitMask[bitCount];
                bitsLeft -= bitCount;
            }
            

            if(m_addLineBreaks && m_prependChars)
            {
                pre = m_prependChars;
                while(*pre){ *o++ = *pre; pre++; }
            }
            

            while( bitCount > 0 )
            {
                *o++ = m_base64chars[ (int)digit ];

                charCount++;

                if(m_addLineBreaks && !(charCount % m_addLineBreaks))
                {
                    if(m_addCR){ *o++ = '\r'; }
                    *o++ = '\n';

                    if(m_prependChars)
                    {
                        pre = m_prependChars;
                        while(*pre){ *o++ = *pre; pre++; }
                    }
                }


                while( ( in < end ) && ( bitsLeft < bitCount ) ) 
                {
                    tmp = *in;
                    in++;

                    tmpBits <<= 8;
                    tmpBits |= (tmp & 0xff);
                    bitsLeft += 8;
                }

                if( bitsLeft < bitCount ) 
                {
                    tmp = tmpBits << ( bitCount - bitsLeft );
                    digit = tmp & m_bitMask[bitCount];
                    bitCount = bitsLeft;
                    bitsLeft = 0;
                } 
                else 
                {
                    tmp = tmpBits >> ( bitsLeft - bitCount );
                    digit = tmp & m_bitMask[bitCount];
                    bitsLeft -= bitCount;
                }
                
            }

            // Pad with '='
            while( charCount && (charCount % 4 != 0) )
            {
                *o++ = '=';
                charCount++;
            }

            *o++ = 0;

            unsigned long tmpLen = 0;
            try 
            {
                tmpLen = numeric_cast<unsigned long>(o - out);
            }
            catch(bad_numeric_cast &) 
            {
                throw CPKIFException(TOOLKIT_PATH, COMMON_INVALID_INPUT, "Distance is an impossibly long number.");
            }
            *outLen = tmpLen - 1; // extra 1 for the null

            rv = true;
        }
        while(0);

    }
    catch(...){};

    return rv;
}

// The size of the output buffer must not be less than 3/4 the size of the input buffer.
bool CBase64Buffer::decode( const char *in, const unsigned long inLen, unsigned char *out, unsigned long *outLen /*IN / OUT*/ )
{
    bool rv = false;
    
    try
    {
        do
        {

            if(!out)
            {   break;  }

            if(!outLen)
            {   break;  }

            if(!in)
            {   break;  }

            if(!inLen)
            {   break;  }

            unsigned long c, lp, tmpBits = 0, bitsLeft = 0;
            unsigned char *outp = out;
            int digit;
            
            for( lp = 0; lp < inLen; lp++ )
            {
                c = *in++;
                digit = m_decodeTable[ c & 0x7F ];
                if( digit >= 0 ) 
                {
                    tmpBits = (tmpBits << 6) | (digit & 0x3F);
                    bitsLeft += 6;
                    while( bitsLeft > 7 ) 
                    {
                        *outp++ = (unsigned char)((tmpBits >> (bitsLeft - 8)) & 0xFF);

                        bitsLeft -= 8;
                    }
                }
            }

            unsigned long tmpLen = 0;
            try 
            {
                tmpLen = numeric_cast<unsigned long>(outp - out);
            }
            catch(bad_numeric_cast &) 
            {
                throw CPKIFException(TOOLKIT_PATH, COMMON_INVALID_INPUT, "Distance is an impossibly long number.");
            }
            *outLen = tmpLen;
            *outp++ = '\0';

            rv = true;
        }
        while(0);

    }
    catch(...){};

    return rv;
}
void CBase64Buffer::addLineBreaks(int addLineBreaks, bool addCarriageReturn)
{
    m_addLineBreaks = addLineBreaks;
    if(m_addLineBreaks)
    {
        unsigned long mod = m_addLineBreaks % 4;
        if(mod)
        {   
            if(m_addLineBreaks > 4)
            {   m_addLineBreaks -= mod; }
            else
            {   m_addLineBreaks = 4;    }
        }
    }

    m_addCR = addCarriageReturn;
}
bool CBase64Buffer::prependChars(const char *sz)
{
    bool rv = false;
    
    try
    {
        do
        {
            if(m_prependChars)
            {   delete []m_prependChars;  m_prependChars = 0; }

            if(!sz || !*sz){ rv=true; break; }

            m_prependChars = new char[strlen(sz)+1];
            strcpy(m_prependChars,sz);

            if(!m_prependChars){ break; }

            if(strlen(m_prependChars) > 3)
            {   m_prependChars[3] = 0;  }

            rv = true;
        }
        while(0);
    }
    catch(...){};

    return rv;
}