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 "rtc_base/third_party/base64/base64.h"
18
19 #include <string.h>
20
21 #include "absl/strings/string_view.h"
22 #include "rtc_base/checks.h"
23
24 using std::vector;
25
26 namespace rtc {
27
28 static const char kPad = '=';
29 static const unsigned char pd = 0xFD; // Padding
30 static const unsigned char sp = 0xFE; // Whitespace
31 static const unsigned char il = 0xFF; // Illegal base64 character
32
33 const char Base64::Base64Table[] =
34 // 0000000000111111111122222222223333333333444444444455555555556666
35 // 0123456789012345678901234567890123456789012345678901234567890123
36 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
37
38 // Decode Table gives the index of any valid base64 character in the
39 // Base64 table
40 // 65 == A, 97 == a, 48 == 0, 43 == +, 47 == /
41
42 const unsigned char Base64::DecodeTable[] = {
43 // 0 1 2 3 4 5 6 7 8 9
44 il, il, il, il, il, il, il, il, il, sp, // 0 - 9
45 sp, sp, sp, sp, il, il, il, il, il, il, // 10 - 19
46 il, il, il, il, il, il, il, il, il, il, // 20 - 29
47 il, il, sp, il, il, il, il, il, il, il, // 30 - 39
48 il, il, il, 62, il, il, il, 63, 52, 53, // 40 - 49
49 54, 55, 56, 57, 58, 59, 60, 61, il, il, // 50 - 59
50 il, pd, il, il, il, 0, 1, 2, 3, 4, // 60 - 69
51 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 70 - 79
52 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, // 80 - 89
53 25, il, il, il, il, il, il, 26, 27, 28, // 90 - 99
54 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // 100 - 109
55 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, // 110 - 119
56 49, 50, 51, il, il, il, il, il, il, il, // 120 - 129
57 il, il, il, il, il, il, il, il, il, il, // 130 - 139
58 il, il, il, il, il, il, il, il, il, il, // 140 - 149
59 il, il, il, il, il, il, il, il, il, il, // 150 - 159
60 il, il, il, il, il, il, il, il, il, il, // 160 - 169
61 il, il, il, il, il, il, il, il, il, il, // 170 - 179
62 il, il, il, il, il, il, il, il, il, il, // 180 - 189
63 il, il, il, il, il, il, il, il, il, il, // 190 - 199
64 il, il, il, il, il, il, il, il, il, il, // 200 - 209
65 il, il, il, il, il, il, il, il, il, il, // 210 - 219
66 il, il, il, il, il, il, il, il, il, il, // 220 - 229
67 il, il, il, il, il, il, il, il, il, il, // 230 - 239
68 il, il, il, il, il, il, il, il, il, il, // 240 - 249
69 il, il, il, il, il, il // 250 - 255
70 };
71
IsBase64Char(char ch)72 bool Base64::IsBase64Char(char ch) {
73 return (('A' <= ch) && (ch <= 'Z')) || (('a' <= ch) && (ch <= 'z')) ||
74 (('0' <= ch) && (ch <= '9')) || (ch == '+') || (ch == '/');
75 }
76
GetNextBase64Char(char ch,char * next_ch)77 bool Base64::GetNextBase64Char(char ch, char* next_ch) {
78 if (next_ch == nullptr) {
79 return false;
80 }
81 const char* p = strchr(Base64Table, ch);
82 if (!p)
83 return false;
84 ++p;
85 *next_ch = (*p) ? *p : Base64Table[0];
86 return true;
87 }
88
IsBase64Encoded(absl::string_view str)89 bool Base64::IsBase64Encoded(absl::string_view str) {
90 for (size_t i = 0; i < str.size(); ++i) {
91 if (!IsBase64Char(str.at(i)))
92 return false;
93 }
94 return true;
95 }
96
EncodeFromArray(const void * data,size_t len,std::string * result)97 void Base64::EncodeFromArray(const void* data,
98 size_t len,
99 std::string* result) {
100 RTC_DCHECK(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,
139 bool illegal_pads,
140 const char* data,
141 size_t len,
142 size_t* dpos,
143 unsigned char qbuf[4],
144 bool* padded) {
145 size_t byte_len = 0, pad_len = 0, pad_start = 0;
146 for (; (byte_len < 4) && (*dpos < len); ++*dpos) {
147 qbuf[byte_len] = DecodeTable[static_cast<unsigned char>(data[*dpos])];
148 if ((il == qbuf[byte_len]) || (illegal_pads && (pd == qbuf[byte_len]))) {
149 if (parse_flags != DO_PARSE_ANY)
150 break;
151 // Ignore illegal characters
152 } else if (sp == qbuf[byte_len]) {
153 if (parse_flags == DO_PARSE_STRICT)
154 break;
155 // Ignore spaces
156 } else if (pd == qbuf[byte_len]) {
157 if (byte_len < 2) {
158 if (parse_flags != DO_PARSE_ANY)
159 break;
160 // Ignore unexpected padding
161 } else if (byte_len + pad_len >= 4) {
162 if (parse_flags != DO_PARSE_ANY)
163 break;
164 // Ignore extra pads
165 } else {
166 if (1 == ++pad_len) {
167 pad_start = *dpos;
168 }
169 }
170 } else {
171 if (pad_len > 0) {
172 if (parse_flags != DO_PARSE_ANY)
173 break;
174 // Ignore pads which are followed by data
175 pad_len = 0;
176 }
177 ++byte_len;
178 }
179 }
180 for (size_t i = byte_len; i < 4; ++i) {
181 qbuf[i] = 0;
182 }
183 if (4 == byte_len + pad_len) {
184 *padded = true;
185 } else {
186 *padded = false;
187 if (pad_len) {
188 // Roll back illegal padding
189 *dpos = pad_start;
190 }
191 }
192 return byte_len;
193 }
194
DecodeFromArray(const char * data,size_t len,DecodeFlags flags,std::string * result,size_t * data_used)195 bool Base64::DecodeFromArray(const char* data,
196 size_t len,
197 DecodeFlags flags,
198 std::string* result,
199 size_t* data_used) {
200 return DecodeFromArrayTemplate<std::string>(data, len, flags, result,
201 data_used);
202 }
203
DecodeFromArray(const char * data,size_t len,DecodeFlags flags,vector<char> * result,size_t * data_used)204 bool Base64::DecodeFromArray(const char* data,
205 size_t len,
206 DecodeFlags flags,
207 vector<char>* result,
208 size_t* data_used) {
209 return DecodeFromArrayTemplate<vector<char>>(data, len, flags, result,
210 data_used);
211 }
212
DecodeFromArray(const char * data,size_t len,DecodeFlags flags,vector<uint8_t> * result,size_t * data_used)213 bool Base64::DecodeFromArray(const char* data,
214 size_t len,
215 DecodeFlags flags,
216 vector<uint8_t>* result,
217 size_t* data_used) {
218 return DecodeFromArrayTemplate<vector<uint8_t>>(data, len, flags, result,
219 data_used);
220 }
221
222 template <typename T>
DecodeFromArrayTemplate(const char * data,size_t len,DecodeFlags flags,T * result,size_t * data_used)223 bool Base64::DecodeFromArrayTemplate(const char* data,
224 size_t len,
225 DecodeFlags flags,
226 T* result,
227 size_t* data_used) {
228 RTC_DCHECK(result);
229 RTC_DCHECK_LE(flags, (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
230
231 const DecodeFlags parse_flags = flags & DO_PARSE_MASK;
232 const DecodeFlags pad_flags = flags & DO_PAD_MASK;
233 const DecodeFlags term_flags = flags & DO_TERM_MASK;
234 RTC_DCHECK_NE(0, parse_flags);
235 RTC_DCHECK_NE(0, pad_flags);
236 RTC_DCHECK_NE(0, term_flags);
237
238 result->clear();
239 result->reserve(len);
240
241 size_t dpos = 0;
242 bool success = true, padded;
243 unsigned char c, qbuf[4];
244 while (dpos < len) {
245 size_t qlen = GetNextQuantum(parse_flags, (DO_PAD_NO == pad_flags), data,
246 len, &dpos, qbuf, &padded);
247 c = (qbuf[0] << 2) | ((qbuf[1] >> 4) & 0x3);
248 if (qlen >= 2) {
249 result->push_back(c);
250 c = ((qbuf[1] << 4) & 0xf0) | ((qbuf[2] >> 2) & 0xf);
251 if (qlen >= 3) {
252 result->push_back(c);
253 c = ((qbuf[2] << 6) & 0xc0) | qbuf[3];
254 if (qlen >= 4) {
255 result->push_back(c);
256 c = 0;
257 }
258 }
259 }
260 if (qlen < 4) {
261 if ((DO_TERM_ANY != term_flags) && (0 != c)) {
262 success = false; // unused bits
263 }
264 if ((DO_PAD_YES == pad_flags) && !padded) {
265 success = false; // expected padding
266 }
267 break;
268 }
269 }
270 if ((DO_TERM_BUFFER == term_flags) && (dpos != len)) {
271 success = false; // unused chars
272 }
273 if (data_used) {
274 *data_used = dpos;
275 }
276 return success;
277 }
278
279 } // namespace rtc
280