Home | History | Annotate | Download | only in base
      1 
      2 //*********************************************************************
      3 //* Base64 - a simple base64 encoder and decoder.
      4 //*
      5 //*     Copyright (c) 1999, Bob Withers - bwit (at) pobox.com
      6 //*
      7 //* This code may be freely used for any purpose, either personal
      8 //* or commercial, provided the authors copyright notice remains
      9 //* intact.
     10 //*
     11 //* Enhancements by Stanley Yamane:
     12 //*     o reverse lookup table for the decode function
     13 //*     o reserve string buffer space in advance
     14 //*
     15 //*********************************************************************
     16 
     17 #include "talk/base/base64.h"
     18 
     19 #include <string.h>
     20 
     21 #include "talk/base/common.h"
     22 
     23 using std::vector;
     24 
     25 namespace talk_base {
     26 
     27 static const char kPad = '=';
     28 static const unsigned char pd = 0xFD;  // Padding
     29 static const unsigned char sp = 0xFE;  // Whitespace
     30 static const unsigned char il = 0xFF;  // Illegal base64 character
     31 
     32 const char Base64::Base64Table[] =
     33 // 0000000000111111111122222222223333333333444444444455555555556666
     34 // 0123456789012345678901234567890123456789012345678901234567890123
     35   "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
     36 
     37 // Decode Table gives the index of any valid base64 character in the
     38 // Base64 table
     39 // 65 == A, 97 == a, 48 == 0, 43 == +, 47 == /
     40 
     41 const unsigned char Base64::DecodeTable[] = {
     42 // 0  1  2  3  4  5  6  7  8  9
     43   il,il,il,il,il,il,il,il,il,sp,  //   0 -   9
     44   sp,sp,sp,sp,il,il,il,il,il,il,  //  10 -  19
     45   il,il,il,il,il,il,il,il,il,il,  //  20 -  29
     46   il,il,sp,il,il,il,il,il,il,il,  //  30 -  39
     47   il,il,il,62,il,il,il,63,52,53,  //  40 -  49
     48   54,55,56,57,58,59,60,61,il,il,  //  50 -  59
     49   il,pd,il,il,il, 0, 1, 2, 3, 4,  //  60 -  69
     50    5, 6, 7, 8, 9,10,11,12,13,14,  //  70 -  79
     51   15,16,17,18,19,20,21,22,23,24,  //  80 -  89
     52   25,il,il,il,il,il,il,26,27,28,  //  90 -  99
     53   29,30,31,32,33,34,35,36,37,38,  // 100 - 109
     54   39,40,41,42,43,44,45,46,47,48,  // 110 - 119
     55   49,50,51,il,il,il,il,il,il,il,  // 120 - 129
     56   il,il,il,il,il,il,il,il,il,il,  // 130 - 139
     57   il,il,il,il,il,il,il,il,il,il,  // 140 - 149
     58   il,il,il,il,il,il,il,il,il,il,  // 150 - 159
     59   il,il,il,il,il,il,il,il,il,il,  // 160 - 169
     60   il,il,il,il,il,il,il,il,il,il,  // 170 - 179
     61   il,il,il,il,il,il,il,il,il,il,  // 180 - 189
     62   il,il,il,il,il,il,il,il,il,il,  // 190 - 199
     63   il,il,il,il,il,il,il,il,il,il,  // 200 - 209
     64   il,il,il,il,il,il,il,il,il,il,  // 210 - 219
     65   il,il,il,il,il,il,il,il,il,il,  // 220 - 229
     66   il,il,il,il,il,il,il,il,il,il,  // 230 - 239
     67   il,il,il,il,il,il,il,il,il,il,  // 240 - 249
     68   il,il,il,il,il,il               // 250 - 255
     69 };
     70 
     71 bool Base64::IsBase64Char(char ch) {
     72   return (('A' <= ch) && (ch <= 'Z')) ||
     73          (('a' <= ch) && (ch <= 'z')) ||
     74          (('0' <= ch) && (ch <= '9')) ||
     75          (ch == '+') || (ch == '/');
     76 }
     77 
     78 bool Base64::GetNextBase64Char(char ch, char* next_ch) {
     79   if (next_ch == NULL) {
     80     return false;
     81   }
     82   const char* p = strchr(Base64Table, ch);
     83   if (!p)
     84     return false;
     85   ++p;
     86   *next_ch = (*p) ? *p : Base64Table[0];
     87   return true;
     88 }
     89 
     90 bool Base64::IsBase64Encoded(const std::string& str) {
     91   for (size_t i = 0; i < str.size(); ++i) {
     92     if (!IsBase64Char(str.at(i)))
     93       return false;
     94   }
     95   return true;
     96 }
     97 
     98 void Base64::EncodeFromArray(const void* data, size_t len,
     99                              std::string* result) {
    100   ASSERT(NULL != result);
    101   result->clear();
    102   result->resize(((len + 2) / 3) * 4);
    103   const unsigned char* byte_data = static_cast<const unsigned char*>(data);
    104 
    105   unsigned char c;
    106   size_t i = 0;
    107   size_t dest_ix = 0;
    108   while (i < len) {
    109     c = (byte_data[i] >> 2) & 0x3f;
    110     (*result)[dest_ix++] = Base64Table[c];
    111 
    112     c = (byte_data[i] << 4) & 0x3f;
    113     if (++i < len) {
    114       c |= (byte_data[i] >> 4) & 0x0f;
    115     }
    116     (*result)[dest_ix++] = Base64Table[c];
    117 
    118     if (i < len) {
    119       c = (byte_data[i] << 2) & 0x3f;
    120       if (++i < len) {
    121         c |= (byte_data[i] >> 6) & 0x03;
    122       }
    123       (*result)[dest_ix++] = Base64Table[c];
    124     } else {
    125       (*result)[dest_ix++] = kPad;
    126     }
    127 
    128     if (i < len) {
    129       c = byte_data[i] & 0x3f;
    130       (*result)[dest_ix++] = Base64Table[c];
    131       ++i;
    132     } else {
    133       (*result)[dest_ix++] = kPad;
    134     }
    135   }
    136 }
    137 
    138 size_t Base64::GetNextQuantum(DecodeFlags parse_flags, bool illegal_pads,
    139                               const char* data, size_t len, size_t* dpos,
    140                               unsigned char qbuf[4], bool* padded)
    141 {
    142   size_t byte_len = 0, pad_len = 0, pad_start = 0;
    143   for (; (byte_len < 4) && (*dpos < len); ++*dpos) {
    144     qbuf[byte_len] = DecodeTable[static_cast<unsigned char>(data[*dpos])];
    145     if ((il == qbuf[byte_len]) || (illegal_pads && (pd == qbuf[byte_len]))) {
    146       if (parse_flags != DO_PARSE_ANY)
    147         break;
    148       // Ignore illegal characters
    149     } else if (sp == qbuf[byte_len]) {
    150       if (parse_flags == DO_PARSE_STRICT)
    151         break;
    152       // Ignore spaces
    153     } else if (pd == qbuf[byte_len]) {
    154       if (byte_len < 2) {
    155         if (parse_flags != DO_PARSE_ANY)
    156           break;
    157         // Ignore unexpected padding
    158       } else if (byte_len + pad_len >= 4) {
    159         if (parse_flags != DO_PARSE_ANY)
    160           break;
    161         // Ignore extra pads
    162       } else {
    163         if (1 == ++pad_len) {
    164           pad_start = *dpos;
    165         }
    166       }
    167     } else {
    168       if (pad_len > 0) {
    169         if (parse_flags != DO_PARSE_ANY)
    170           break;
    171         // Ignore pads which are followed by data
    172         pad_len = 0;
    173       }
    174       ++byte_len;
    175     }
    176   }
    177   for (size_t i = byte_len; i < 4; ++i) {
    178     qbuf[i] = 0;
    179   }
    180   if (4 == byte_len + pad_len) {
    181     *padded = true;
    182   } else {
    183     *padded = false;
    184     if (pad_len) {
    185       // Roll back illegal padding
    186       *dpos = pad_start;
    187     }
    188   }
    189   return byte_len;
    190 }
    191 
    192 bool Base64::DecodeFromArray(const char* data, size_t len, DecodeFlags flags,
    193                              std::string* result, size_t* data_used) {
    194   return DecodeFromArrayTemplate<std::string>(
    195       data, len, flags, result, data_used);
    196 }
    197 
    198 bool Base64::DecodeFromArray(const char* data, size_t len, DecodeFlags flags,
    199                              vector<char>* result, size_t* data_used) {
    200   return DecodeFromArrayTemplate<vector<char> >(data, len, flags, result,
    201                                                 data_used);
    202 }
    203 
    204 template<typename T>
    205 bool Base64::DecodeFromArrayTemplate(const char* data, size_t len,
    206                                      DecodeFlags flags, T* result,
    207                                      size_t* data_used)
    208 {
    209   ASSERT(NULL != result);
    210   ASSERT(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
    211 
    212   const DecodeFlags parse_flags = flags & DO_PARSE_MASK;
    213   const DecodeFlags pad_flags   = flags & DO_PAD_MASK;
    214   const DecodeFlags term_flags  = flags & DO_TERM_MASK;
    215   ASSERT(0 != parse_flags);
    216   ASSERT(0 != pad_flags);
    217   ASSERT(0 != term_flags);
    218 
    219   result->clear();
    220   result->reserve(len);
    221 
    222   size_t dpos = 0;
    223   bool success = true, padded;
    224   unsigned char c, qbuf[4];
    225   while (dpos < len) {
    226     size_t qlen = GetNextQuantum(parse_flags, (DO_PAD_NO == pad_flags),
    227                                  data, len, &dpos, qbuf, &padded);
    228     c = (qbuf[0] << 2) | ((qbuf[1] >> 4) & 0x3);
    229     if (qlen >= 2) {
    230       result->push_back(c);
    231       c = ((qbuf[1] << 4) & 0xf0) | ((qbuf[2] >> 2) & 0xf);
    232       if (qlen >= 3) {
    233         result->push_back(c);
    234         c = ((qbuf[2] << 6) & 0xc0) | qbuf[3];
    235         if (qlen >= 4) {
    236           result->push_back(c);
    237           c = 0;
    238         }
    239       }
    240     }
    241     if (qlen < 4) {
    242       if ((DO_TERM_ANY != term_flags) && (0 != c)) {
    243         success = false;  // unused bits
    244       }
    245       if ((DO_PAD_YES == pad_flags) && !padded) {
    246         success = false;  // expected padding
    247       }
    248       break;
    249     }
    250   }
    251   if ((DO_TERM_BUFFER == term_flags) && (dpos != len)) {
    252     success = false;  // unused chars
    253   }
    254   if (data_used) {
    255     *data_used = dpos;
    256   }
    257   return success;
    258 }
    259 
    260 } // namespace talk_base
    261