Logo Search packages:      
Sourcecode: aide version File versions  Download package

base64.c

/*
**
** Copyright (C) 1994 Swedish University Network (SUNET)
** Modified by Rami Lehti (C) 1999
** $Header: /cvsroot/aide/aide/src/base64.c,v 1.6 2006/10/27 20:42:20 rvdb Exp $
**
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITTNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
** 
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
**
**
**                                        Martin.Wendel@udac.uu.se
**                                        Torbjorn.Wictorin@udac.uu.se
**
**                                        UDAC  
**                                        P.O. Box 174
**                                        S-751 04 Uppsala
**                                        Sweden
**
*/

#include "aide.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "base64.h"
#include "report.h"
/*for locale support*/
#include "locale-aide.h"
/*for locale support*/

char tob64[] = 
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";



int fromb64[] = {
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, SKIP, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  

SKIP, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, 0x3e, FAIL, FAIL, FAIL, 0x3f,
0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,  
0x3c, 0x3d, FAIL, FAIL, FAIL, SKIP, FAIL, FAIL,

FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,  
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,  
0x17, 0x18, 0x19, FAIL, FAIL, FAIL, FAIL, FAIL,

FAIL, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,  
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,  
0x31, 0x32, 0x33, FAIL, FAIL, FAIL, FAIL, FAIL,

FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,  
FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL
};

/* Returns NULL on error */
/* FIXME Possible buffer overflow on outputs larger than B64_BUF */
char* encode_base64(byte* src,size_t ssize)
{
  char* outbuf;
  char* retbuf;
  int pos;
  int i, l, left;
  unsigned long triple;
  byte *inb;
  
  error(210, "encode base64");
  /* Exit on empty input */
  if (!ssize||src==NULL){
    error(210,"\n");
    return NULL;
  }
  outbuf = (char *)malloc(sizeof(char)*B64_BUF);
  
  /* Initialize working pointers */
  inb = src;
  i = 0;
  triple = 0;
  pos = 0;
  left = ssize;
  error(210, ", data length: %d\n", left);
  /*
   * Process entire inbuf.
   */
  while (left != 0)
    {
      i++;
      left--;
      
      triple = (triple <<8) | *inb;
      if (i == 3 || left == 0)
      {
        switch (i) 
          {
          case 1:
            triple = triple<<4;
            break;
          case 2:
            triple = triple<<2;
            break;
          default:
            break;
          }
        for (l = i; l >= 0; l--){
          /* register */ 
          int rr; 
          rr = 0x3f & (triple>>(6*l)); 
          assert (rr < 64); 
          outbuf[pos]=tob64[rr];
          pos++;
            }
        if (left == 0)
          switch(i)
            {
            case 2:
            outbuf[pos]='=';
            pos++;
            break;
            case 1:
            outbuf[pos]='=';
            pos++;
            outbuf[pos]='=';
            pos++;
            break;
            default:
            break;
            }
        triple = 0;
        i = 0;
        }
      inb++;
  }
  
  /* outbuf is not completely used so we use retbuf */
  retbuf=(char*)malloc(sizeof(char)*(pos+1));
  memcpy(retbuf,outbuf,pos);
  retbuf[pos]='\0';
  free(outbuf);

  return retbuf;
}

/* FIXME Possible buffer overflow on outputs larger than B64_BUF */
byte* decode_base64(char* src,size_t ssize, size_t *ret_len)
{
  byte* outbuf;
  byte* retbuf;
  char* inb;
  int i;
  int l;
  int left;
  int pos;
  unsigned long triple;

  error(210, "decode base64\n");
  /* Exit on empty input */
  if (!ssize||src==NULL)
    return NULL;


  /* Initialize working pointers */
  inb = src;
  outbuf = (byte *)malloc(sizeof(byte)*B64_BUF);

  l = 0;
  triple = 0;
  pos=0;
  left = ssize;
  /*
   * Process entire inbuf.
   */
  while (left != 0)
    {
      left--;
      i = fromb64[(unsigned char)*inb];
      switch(i)
      {
      case FAIL:
        error(3, "decode_base64: Illegal character: %c\n", *inb);
        error(230, "decode_base64: Illegal line:\n%s\n", src);
        return NULL;
        break;
      case SKIP:
        break;
      default:
        triple = triple<<6 | (0x3f & i);
        l++;
        break;
      }
      if (l == 4 || left == 0)
      {
        switch(l)
          {
          case 2:
            triple = triple>>4;
            break;
          case 3:
            triple = triple>>2;
            break;
          default:
            break;
          }
        for (l  -= 2; l >= 0; l--)
          {
            outbuf[pos]=( 0xff & (triple>>(l*8)));
            pos++;
          }
        triple = 0;
        l = 0;
      }
      inb++;
    }
  
  retbuf=(byte*)malloc(sizeof(byte)*(pos+1));
  memcpy(retbuf,outbuf,pos);
  retbuf[pos]='\0';
  
  free(outbuf);

  if (ret_len) *ret_len = pos;
  
  return retbuf;
}

size_t length_base64(char* src,size_t ssize)
{
  char* inb;
  int i;
  int l;
  int left;
  size_t pos;
  unsigned long triple;

  error(210, "decode base64\n");
  /* Exit on empty input */
  if (!ssize||src==NULL)
    return 0;



  /* Initialize working pointers */
  inb = src;

  l = 0;
  triple = 0;
  pos=0;
  left = ssize;
  /*
   * Process entire inbuf.
   */
  while (left != 0)
    {
      left--;
      i = fromb64[(unsigned char)*inb];
      switch(i)
      {
      case FAIL:
        error(3, "length_base64: Illegal character: %c\n", *inb);
        error(230, "length_base64: Illegal line:\n%s\n", src);
        return 0; 
        break;
      case SKIP:
        break;
      default:
        triple = triple<<6 | (0x3f & i);
        l++;
        break;
      }
      if (l == 4 || left == 0)
      {
        switch(l)
          {
          case 2:
            triple = triple>>4;
            break;
          case 3:
            triple = triple>>2;
            break;
          default:
            break;
          }
        for (l  -= 2; l >= 0; l--)
          {
            pos++;
          }
        triple = 0;
        l = 0;
      }
      inb++;
    }
  
  return pos;
}


Generated by  Doxygen 1.6.0   Back to index