/ray/src/lib/crypto/base64.cc

Go to the documentation of this file.

/*
 * base64.cc
 *
 * Implementation of base64 encoding/decoding algorithm. 
 *
 * Copyright (c) 2001--2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [
 *
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 */

#include "base64.h"


/* Maps the values in range 0...63 to base64 chars. */
static const unsigned char *_base64_encode=(unsigned char *)
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789+/";

/* Maps the first 128 ASCII chars to their base64 code (in range 0...63) 
 * Special meaning: 
 * 0xff -> illegal
 * 0xfe -> ignored (space, CR, LF, tab, backslash, \f, \v, \b, DEL)
 * 0xfd -> end of message (`=') */
static const unsigned char *_base64_decode=(const unsigned char *)
    "\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xfe\xfe\xfe\xfe\xfe\xff\xff"
    "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
    "\xfe\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3e\xff\xff\xff\x3f"
    "\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\xff\xff\xff\xfd\xff\xff"
    "\xff\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e"
    "\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\xff\xfe\xff\xff\xff"
    "\xff\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28"
    "\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\xff\xff\xff\xff\xfe";


static ssize_t Base64Encode(
    const char *_in,size_t inlen,
    char *_out,size_t outlen,
    uint32 *state/*=NULL*/,int lwidth/*=0*/)
{
    unsigned char *in=(unsigned char *)_in;
    unsigned char *out=(unsigned char *)_out;
    unsigned char *inend=in+inlen;
    unsigned char *outend=out+outlen;
    uint32 acc;
    int ai,ci;
    if(state)
    {
        acc=(*state)&0xffffU;
        ai=((*state)>>16)&0x3U;
        ci=((*state)>>18);
    }
    else
    {  acc=0U;  ai=0;  ci=0;  }
    
    for(;in<inend;in++)
    {
        acc<<=8;
        acc|=(uint32)(*in);
        ++ai;
        if(ai==3)
        {
            if(out+4>outend)
            {  return(-4);  }
            //for(int i=18; i>=0; i-=6)
            //{  *(out++)=_base64_encode[(acc>>i) & 0x3fU];  }
            *(out++)=_base64_encode[(acc>>18) & 0x3fU];
            *(out++)=_base64_encode[(acc>>12) & 0x3fU];
            *(out++)=_base64_encode[(acc>> 6) & 0x3fU];
            *(out++)=_base64_encode[ acc      & 0x3fU];
            ai=0;
            acc=0U;
            if(lwidth)  if((++ci)==lwidth)
            {
                if(out>=outend)  return(-4);
                *((char*)(out++))='\n';
                ci=0;
            }
        }
    }
    
    if(state && inlen)
    {
        /* save carry in state (ai=0,1,2) */
        *state = 
            (((uint32)ci)<<18) | 
            (((uint32)ai)<<16) | 
            acc;
    }
    else
    {
        if(state)  *state=0;
        
        /* store rest of input in output */
        if(outend-out<(ai+2))   /* +2 for expand & termination char */
        {  return(-4);  }
        
        /* ai==3 never possible here. */
        switch(ai)
        {
            case 1:
                *(out++)=_base64_encode[(acc>>2) & 0x3fU];
                *(out++)=_base64_encode[(acc<<4) & 0x3fU];
                break;
            case 2:
                *(out++)=_base64_encode[(acc>>10) & 0x3fU];
                *(out++)=_base64_encode[(acc>> 4) & 0x3fU];
                *(out++)=_base64_encode[(acc<< 2) & 0x3fU];
                break;
        }
        
        /* and append termination char */
        *((char*)(out++))='=';
    }
    
    return(out-(unsigned char*)_out);
}


static ssize_t Base64Decode(
    const char *_in,size_t inlen,
    char *_out,size_t outlen,
    uint32 *state /*=NULL*/)
{
    unsigned char *ib=(unsigned char*)_in;
    unsigned char *ib_end=ib+inlen;
    unsigned char *ob=(unsigned char*)_out;
    unsigned char *ob_end=ob+outlen;
    
    uint32 dec=0xfdU;   /* simulate end char in case inlen=0 */
    uint32 acc = state ? ((*state)&0xffffffU) : 0U;
    int    ai  = state ? ((*state)>>24) : 0;
    
    for(; ib<ib_end; ib++)
    {
        if((*ib)>=128U)  return(-2);
        dec=_base64_decode[(int)(*ib)];
        if(dec<64)
        {
            acc=(acc<<6)|dec;
            ++ai;
            if(ai==4)  /* got 4 chars */
            {
                if(ob+2>=ob_end)  return(-4);
                *(ob++)=(unsigned char)((acc>>16) & 0xffU);
                *(ob++)=(unsigned char)((acc>> 8) & 0xffU);
                *(ob++)=(unsigned char)( acc      & 0xffU);
                acc=0U;  ai=0;
            }
        }
        else switch(dec)
        {
            case 0xffU:  return(-2);
            /*case 0xfeU:  goto forcont;*/
            case 0xfdU:  goto breakfor;
        }
        /*forcont:;*/
    }
    breakfor:;
    /* ai==4 not possible here. ai<4 here. */
    
    if(state && dec!=0xfdU)  /* state and no end char */
    {
        /* Save carry in state. */
        *state = (((uint32)ai)<<24) | acc;
    }
    else
    {
        if(state)  *state=0U;
        /* Save the last bytes in the output buffer. */
        if(ob+ai-2>=ob_end)
        {  return(-4);  }
        switch(ai)
        {
            case 3:  /* got 3 chars */
                *(ob++)=(unsigned char)((acc>>10) & 0xffU);
                *(ob++)=(unsigned char)((acc>> 2) & 0xffU);
                break;
            case 2:  /* got 2 chars */
                *(ob++)=(unsigned char)((acc>> 4) & 0xffU);
                break;
            case 1: return(-3);
        }
    }
    return((char*)ob-_out);
}


ssize_t Base64Encoder::encode(const char *in,size_t inlen,
    char *out,size_t outlen)
{
    return(::Base64Encode(in,inlen,out,outlen,&state,lwidth));
}

ssize_t Base64Encoder::EncodeBuf(const char *in,size_t inlen,
    char *out,size_t outlen,int lwidth)
{
    return(::Base64Encode(in,inlen,out,outlen,NULL,lwidth));
}


ssize_t Base64Decoder::decode(const char *in,size_t inlen,
    char *out,size_t outlen)
{
    return(::Base64Decode(in,inlen,out,outlen,&state));
}

ssize_t Base64Decoder::DecodeBuf(const char *in,size_t inlen,
    char *out,size_t outlen)
{
    return(::Base64Decode(in,inlen,out,outlen,NULL));
}


#if 0   /* compile little test proggy */

#define TEST_ENCODE 1

#include <stdio.h>  /* test program */
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <stdlib.h>
#include <time.h>

#define OBLEN 256000

int main(int argc,char **arg)
{
    char ob[OBLEN];
    ssize_t rv;
    
#if TEST_ENCODE
    /*rv=Base64Encode(arg[1],strlen(arg[1]),ob,OBLEN,NULL,8);
    fprintf(stderr,"Return=%d\n",rv);
    if(rv>0)
    {  write(1,ob,rv);  printf("<<\n");  fflush(stdout);  }
    */
#else
    /*rv=Base64Decode(arg[1],strlen(arg[1]),ob,OBLEN,NULL);
    fprintf(stderr,"Return=%d\n",rv);
    if(rv>0)
    {  write(1,ob,rv);  printf("<<\n");  fflush(stdout);  }
    */
#endif
    
    srandom(time(NULL)*getpid());
    
    {
        uint32 state=0;
        char *ibuf=arg[1];
        char *ibufend=ibuf+strlen(ibuf);
        char *obuf=ob;
        for(;;)
        {
            int inlen=(random()%33)+1;  // ...or try 32
            if(ibuf+inlen>ibufend)
            {  inlen=ibufend-ibuf;  }
#if TEST_ENCODE
            rv=Base64Encode(ibuf,inlen,obuf,ob+OBLEN-obuf,&state,8);
            if(rv<0)
            {  fprintf(stderr,"Enc(%d)=%d\n",inlen,rv);  }
#else
            rv=Base64Decode(ibuf,inlen,obuf,ob+OBLEN-obuf,&state);
            if(rv<0)
            {  fprintf(stderr,"Dec(%d)=%d\n",inlen,rv);  }
#endif
            if(rv<0)  break;
            ibuf+=inlen;
            obuf+=rv;
            if(!inlen)  break;
        }
        
        write(1,ob,obuf-ob);  printf("<<\n");  fflush(stdout);
    }
    
    return(0);
}

#endif

---