• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
23 using std::vector;
24 
25 namespace rtc {
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 
IsBase64Char(char ch)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 
GetNextBase64Char(char ch,char * next_ch)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 
IsBase64Encoded(const std::string & str)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 
EncodeFromArray(const void * data,size_t len,std::string * result)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 
GetNextQuantum(DecodeFlags parse_flags,bool illegal_pads,const char * data,size_t len,size_t * dpos,unsigned char qbuf[4],bool * padded)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 
DecodeFromArray(const char * data,size_t len,DecodeFlags flags,std::string * result,size_t * data_used)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 
DecodeFromArray(const char * data,size_t len,DecodeFlags flags,vector<char> * result,size_t * data_used)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>
DecodeFromArrayTemplate(const char * data,size_t len,DecodeFlags flags,T * result,size_t * data_used)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 rtc
261