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