C:/fscan/HTTPCore/Authentication/base64.cpp

Go to the documentation of this file.
00001 /*
00002  Base64.c:  Base64 Encoder/Decoder Implementation.
00003  Implementacion de Base64 *libre* de bugs
00004 
00005 */
00006 #include "base64.h"
00007 
00008 unsigned int Base64EncodeGetLength( unsigned long size )
00009 {
00010 /*
00011     Function: Base64EncodeGetLength
00012     Parametros: Size
00013     Dado un numero 'size' de bytes, devuelve la longitud de la cadena una vez que
00014     se convierta a base64. (4 bytes por cada 3 de entrada)
00015 */
00016     DWORD BASE64_INPUT = 3;
00017     DWORD BASE64_OUTPUT = 4;
00018     return (((size + BASE64_INPUT - 1) / BASE64_INPUT) * BASE64_OUTPUT);
00019 }
00020 
00021 unsigned int Base64DecodeGetLength( unsigned long size )
00022 {
00023 /*
00024     Function: Base64DecodeGetLength
00025     Parametros: Size
00026     Dado un numero 'size' de bytes, devuelve la longitud de la cadena una vez que
00027     se convierta de base64 a Ascii. (3 bytes por cada 4 de entrada)
00028     NOTA: El tamaño real puede diferir en un byte por ejemplo una cadena de 8 bytes
00029     pasara a tener 12 en base64 y el resultado de esta funcion seria 9. El tamaño
00030     real se puede obtener tras la llamada a Base64Decode.
00031 */
00032     DWORD BASE64_INPUT = 4;
00033     DWORD BASE64_OUTPUT = 3;
00034     return (((size + BASE64_INPUT - 1) / BASE64_INPUT) * BASE64_OUTPUT);
00035 }
00036 
00037 /******************************************************************************/
00038  
00039  
00040  static const char base64digits[] =
00041     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
00042  
00043  #define BAD     -1
00044  static const char base64val[] = {
00045      BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD,
00046      BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD,
00047      BAD,BAD,BAD,BAD, BAD,BAD,BAD,BAD, BAD,BAD,BAD, 62, BAD,BAD,BAD, 63,
00048       52, 53, 54, 55,  56, 57, 58, 59,  60, 61,BAD,BAD, BAD,BAD,BAD,BAD,
00049      BAD,  0,  1,  2,   3,  4,  5,  6,   7,  8,  9, 10,  11, 12, 13, 14,
00050       15, 16, 17, 18,  19, 20, 21, 22,  23, 24, 25,BAD, BAD,BAD,BAD,BAD,
00051      BAD, 26, 27, 28,  29, 30, 31, 32,  33, 34, 35, 36,  37, 38, 39, 40,
00052       41, 42, 43, 44,  45, 46, 47, 48,  49, 50, 51,BAD, BAD,BAD,BAD,BAD
00053  };
00054  #define DECODE64(c)  (isascii(c) ? base64val[c] : BAD)
00055 
00056 
00057 // void to64frombits(unsigned char *out, const unsigned char *in, int inlen)
00058 int Base64Encode( unsigned char* out, const unsigned char* in, int inlen )
00059  {
00060 /*
00061     Function: Base64Encode
00062     Parametros: buffer de salida (out), cadena en ascii (in) y longitud de la cadena
00063     (intlen)
00064     Return: Se devolverá el numero de bytes de la nueva cadena.
00065 
00066     *NOTA* No se utilizara ningun '\0' para especificar el fin de la cadena por lo
00067     que se debera tener cuidado de no cometer desbordamientos de buffer manejando
00068     los datos de salida (ej: strlen(), strcpy(), ..)
00069 */
00070  int resultado=Base64EncodeGetLength(inlen);
00071          for (; inlen >= 3; inlen -= 3)
00072          {
00073                  *out++ = base64digits[in[0] >> 2];
00074                  *out++ = base64digits[((in[0] << 4) & 0x30) | (in[1] >> 4)];
00075                  *out++ = base64digits[((in[1] << 2) & 0x3c) | (in[2] >> 6)];
00076                  *out++ = base64digits[in[2] & 0x3f];
00077                  in += 3;
00078          }
00079  
00080          if (inlen > 0)
00081          {
00082                  unsigned char fragment;
00083  
00084                  *out++ = base64digits[in[0] >> 2];
00085                  fragment = (in[0] << 4) & 0x30;
00086  
00087                  if (inlen > 1)
00088                          fragment |= in[1] >> 4;
00089  
00090                  *out++ = base64digits[fragment];
00091                  *out++ = (inlen < 2) ? '=' : base64digits[(in[1] << 2) & 0x3c];
00092                  *out++ = '=';
00093          }
00094         /* *out = '\0'; //Solo en el caso de que se envie un byte mas para
00095         almacenar ese caracter
00096         */
00097          return(resultado);
00098 }
00099 /*****************************************************************************/ 
00100 int Base64Decode( char* out, const char* in, unsigned long size )
00101  {
00102  /*
00103     Function: Base64Decode
00104     Parametros: buffer de salida (out), cadena en Base64 (in) y longitud de la
00105         cadena Base64 (size).
00106     Return: Se devolverá el numero de bytes de la nueva cadena que puede diferir
00107     (siendo menor) que el devuelto por Base64DecodeGetLength().
00108 
00109     *NOTA* No se utilizara ningun '\0' para especificar el fin de la cadena por lo
00110     que se debera tener cuidado de no cometer desbordamientos de buffer manejando
00111     los datos de salida (ej: strlen(), strcpy(), ..)
00112 
00113     *NOTA2* El parámetro size no es utilizado por la funcion. Ha sido añadido por
00114     compatibilidad con otras implementaciones de Base64
00115 */
00116          int len = 0;
00117          register unsigned char digit1, digit2, digit3, digit4;
00118  
00119          if (in[0] == '+' && in[1] == ' ')
00120                  in += 2;
00121          if (*in == '\r')
00122                  return(0);
00123  
00124          do {
00125                  digit1 = in[0];
00126                  if (DECODE64(digit1) == BAD)
00127                          return(-1);
00128                  digit2 = in[1];
00129                  if (DECODE64(digit2) == BAD)
00130                          return(-1);
00131                  digit3 = in[2];
00132                  if (digit3 != '=' && DECODE64(digit3) == BAD)
00133                          return(-1);
00134                  digit4 = in[3];
00135                  if (digit4 != '=' && DECODE64(digit4) == BAD)
00136                          return(-1);
00137                  in += 4;
00138                  *out++ = (DECODE64(digit1) << 2) | (DECODE64(digit2) >> 4);
00139                  ++len;
00140                  if (digit3 != '=')
00141                  {
00142                          *out++ = ((DECODE64(digit2) << 4) & 0xf0) | (DECODE64(digit3) >> 2);
00143                          ++len;
00144                          if (digit4 != '=')
00145                          {
00146                                  *out++ = ((DECODE64(digit3) << 6) & 0xc0) | DECODE64(digit4);
00147                                  ++len;
00148                          }
00149                  }
00150          } while (*in && *in != '\r' && digit4 != '=');
00151  
00152          return (len);
00153  }
00154 /******************************************************************************/

Generated on Sun Jan 18 00:32:03 2009 for Fast HTTP Vulnerability Scanner by  doxygen 1.5.4