1
2//*********************************************************************
3//* Base64 - a simple base64 encoder and decoder.
4//*
5//*     Copyright (c) 1999, Bob Withers - bwit@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 "webrtc/base/base64.h"
18
19#include <string.h>
20
21#include "webrtc/base/common.h"
22
23using std::vector;
24
25namespace rtc {
26
27static const char kPad = '=';
28static const unsigned char pd = 0xFD;  // Padding
29static const unsigned char sp = 0xFE;  // Whitespace
30static const unsigned char il = 0xFF;  // Illegal base64 character
31
32const 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
41const 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
71bool 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
78bool 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
90bool 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
98void 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
138size_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
192bool 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
198bool 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
204template<typename T>
205bool 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 rtc
261