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 "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 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 rtc 261
