SecBase64.c
1 /* ///////////////////////////////////////////////////////////////////////////// 2 * File: b64.c 3 * 4 * Purpose: Implementation file for the b64 library 5 * 6 * Created: 18th October 2004 7 * Updated: 2nd August 2006 8 * 9 * Home: http://synesis.com.au/software/ 10 * 11 * Copyright (c) 2004-2006, Matthew Wilson and Synesis Software 12 * All rights reserved. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions are met: 16 * 17 * - Redistributions of source code must retain the above copyright notice, this 18 * list of conditions and the following disclaimer. 19 * - Redistributions in binary form must reproduce the above copyright notice, 20 * this list of conditions and the following disclaimer in the documentation 21 * and/or other materials provided with the distribution. 22 * - Neither the name(s) of Matthew Wilson and Synesis Software nor the names of 23 * any contributors may be used to endorse or promote products derived from 24 * this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 27 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 28 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 29 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 30 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 * 38 * ////////////////////////////////////////////////////////////////////////// */ 39 40 41 /** \file b64.c Implementation file for the b64 library 42 */ 43 44 #include "SecBase64.h" 45 46 #include <security_utilities/simulatecrash_assert.h> 47 #include <string.h> 48 #include <stdbool.h> 49 50 /* ///////////////////////////////////////////////////////////////////////////// 51 * Constants and definitions 52 */ 53 54 #ifndef B64_DOCUMENTATION_SKIP_SECTION 55 # define NUM_PLAIN_DATA_BYTES (3) 56 # define NUM_ENCODED_DATA_BYTES (4) 57 #endif /* !B64_DOCUMENTATION_SKIP_SECTION */ 58 59 /* ///////////////////////////////////////////////////////////////////////////// 60 * Warnings 61 */ 62 63 #if defined(_MSC_VER) && \ 64 _MSC_VER < 1000 65 # pragma warning(disable : 4705) 66 #endif /* _MSC_VER < 1000 */ 67 68 /* ///////////////////////////////////////////////////////////////////////////// 69 * Data 70 */ 71 72 static const char b64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 73 74 static const signed char b64_indexes[] = 75 { 76 /* 0 - 31 / 0x00 - 0x1f */ 77 -1, -1, -1, -1, -1, -1, -1, -1 78 , -1, -1, -1, -1, -1, -1, -1, -1 79 , -1, -1, -1, -1, -1, -1, -1, -1 80 , -1, -1, -1, -1, -1, -1, -1, -1 81 /* 32 - 63 / 0x20 - 0x3f */ 82 , -1, -1, -1, -1, -1, -1, -1, -1 83 , -1, -1, -1, 62, -1, -1, -1, 63 /* ... , '+', ... '/' */ 84 , 52, 53, 54, 55, 56, 57, 58, 59 /* '0' - '7' */ 85 , 60, 61, -1, -1, -1, -1, -1, -1 /* '8', '9', ... */ 86 /* 64 - 95 / 0x40 - 0x5f */ 87 , -1, 0, 1, 2, 3, 4, 5, 6 /* ..., 'A' - 'G' */ 88 , 7, 8, 9, 10, 11, 12, 13, 14 /* 'H' - 'O' */ 89 , 15, 16, 17, 18, 19, 20, 21, 22 /* 'P' - 'W' */ 90 , 23, 24, 25, -1, -1, -1, -1, -1 /* 'X', 'Y', 'Z', ... */ 91 /* 96 - 127 / 0x60 - 0x7f */ 92 , -1, 26, 27, 28, 29, 30, 31, 32 /* ..., 'a' - 'g' */ 93 , 33, 34, 35, 36, 37, 38, 39, 40 /* 'h' - 'o' */ 94 , 41, 42, 43, 44, 45, 46, 47, 48 /* 'p' - 'w' */ 95 , 49, 50, 51, -1, -1, -1, -1, -1 /* 'x', 'y', 'z', ... */ 96 97 , -1, -1, -1, -1, -1, -1, -1, -1 98 , -1, -1, -1, -1, -1, -1, -1, -1 99 , -1, -1, -1, -1, -1, -1, -1, -1 100 , -1, -1, -1, -1, -1, -1, -1, -1 101 102 , -1, -1, -1, -1, -1, -1, -1, -1 103 , -1, -1, -1, -1, -1, -1, -1, -1 104 , -1, -1, -1, -1, -1, -1, -1, -1 105 , -1, -1, -1, -1, -1, -1, -1, -1 106 107 , -1, -1, -1, -1, -1, -1, -1, -1 108 , -1, -1, -1, -1, -1, -1, -1, -1 109 , -1, -1, -1, -1, -1, -1, -1, -1 110 , -1, -1, -1, -1, -1, -1, -1, -1 111 112 , -1, -1, -1, -1, -1, -1, -1, -1 113 , -1, -1, -1, -1, -1, -1, -1, -1 114 , -1, -1, -1, -1, -1, -1, -1, -1 115 , -1, -1, -1, -1, -1, -1, -1, -1 116 }; 117 118 /* ///////////////////////////////////////////////////////////////////////////// 119 * Helper functions 120 */ 121 122 /** This function reads in 3 bytes at a time, and translates them into 4 123 * characters. 124 */ 125 static size_t SecBase64Encode_( unsigned char const *src 126 , size_t srcSize 127 , char *const dest 128 , size_t destLen 129 , unsigned lineLen 130 , SecBase64Result *rc) 131 { 132 size_t total = ((srcSize + (NUM_PLAIN_DATA_BYTES - 1)) / NUM_PLAIN_DATA_BYTES) * NUM_ENCODED_DATA_BYTES; 133 134 assert(NULL != rc); 135 *rc = kSecB64_R_OK; 136 137 if(lineLen > 0) 138 { 139 size_t numLines = (total + (lineLen - 1)) / lineLen; 140 141 total += 2 * (numLines - 1); 142 } 143 144 if(NULL == dest) 145 { 146 return total; 147 } 148 else if(destLen < total) 149 { 150 *rc = kSecB64_R_INSUFFICIENT_BUFFER; 151 152 return 0; 153 } 154 else 155 { 156 char *p = dest; 157 char *end = dest + destLen; 158 size_t len = 0; 159 160 for(; NUM_PLAIN_DATA_BYTES <= srcSize; srcSize -= NUM_PLAIN_DATA_BYTES) 161 { 162 char characters[NUM_ENCODED_DATA_BYTES]; 163 164 /* 165 * 166 * | 0 | 1 | 2 | 167 * 168 * | | | | 169 * | | | | | | | 170 * | | | | | | | | | | | | | 171 * | | | | | | | | | | | | | | | | | | | | | | | | | 172 * 173 * | 0 | 1 | 2 | 3 | 174 * 175 */ 176 177 /* characters[0] is the 6 left-most bits of src[0] */ 178 characters[0] = (char)((src[0] & 0xfc) >> 2); 179 /* characters[0] is the right-most 2 bits of src[0] and the left-most 4 bits of src[1] */ 180 characters[1] = (char)(((src[0] & 0x03) << 4) + ((src[1] & 0xf0) >> 4)); 181 /* characters[0] is the right-most 4 bits of src[1] and the 2 left-most bits of src[2] */ 182 characters[2] = (char)(((src[1] & 0x0f) << 2) + ((src[2] & 0xc0) >> 6)); 183 /* characters[3] is the right-most 6 bits of src[2] */ 184 characters[3] = (char)(src[2] & 0x3f); 185 186 #ifndef __WATCOMC__ 187 assert(characters[0] >= 0 && characters[0] < 64); 188 assert(characters[1] >= 0 && characters[1] < 64); 189 assert(characters[2] >= 0 && characters[2] < 64); 190 assert(characters[3] >= 0 && characters[3] < 64); 191 #endif /* __WATCOMC__ */ 192 193 src += NUM_PLAIN_DATA_BYTES; 194 *p++ = b64_chars[(unsigned char)characters[0]]; 195 assert(NULL != strchr(b64_chars, *(p-1))); 196 ++len; 197 assert(len != lineLen); 198 199 *p++ = b64_chars[(unsigned char)characters[1]]; 200 assert(NULL != strchr(b64_chars, *(p-1))); 201 ++len; 202 assert(len != lineLen); 203 204 *p++ = b64_chars[(unsigned char)characters[2]]; 205 assert(NULL != strchr(b64_chars, *(p-1))); 206 ++len; 207 assert(len != lineLen); 208 209 *p++ = b64_chars[(unsigned char)characters[3]]; 210 assert(NULL != strchr(b64_chars, *(p-1))); 211 212 if( ++len == lineLen && 213 p != end) 214 { 215 *p++ = '\r'; 216 *p++ = '\n'; 217 len = 0; 218 } 219 } 220 221 if(0 != srcSize) 222 { 223 /* Deal with the overspill, by boosting it up to three bytes (using 0s) 224 * and then appending '=' for any missing characters. 225 * 226 * This is done into a temporary buffer, so we can call ourselves and 227 * have the output continue to be written direct to the destination. 228 */ 229 230 unsigned char dummy[NUM_PLAIN_DATA_BYTES]; 231 size_t i; 232 233 for(i = 0; i < srcSize; ++i) 234 { 235 dummy[i] = *src++; 236 } 237 238 for(; i < NUM_PLAIN_DATA_BYTES; ++i) 239 { 240 dummy[i] = '\0'; 241 } 242 243 SecBase64Encode_(&dummy[0], NUM_PLAIN_DATA_BYTES, p, NUM_ENCODED_DATA_BYTES * (1 + 2), 0, rc); 244 245 for(p += 1 + srcSize; srcSize++ < NUM_PLAIN_DATA_BYTES; ) 246 { 247 *p++ = '='; 248 } 249 } 250 251 return total; 252 } 253 } 254 255 /** This function reads in a character string in 4-character chunks, and writes 256 * out the converted form in 3-byte chunks to the destination. 257 */ 258 static size_t SecBase64Decode_( char const *src 259 , size_t srcLen 260 , unsigned char *dest 261 , size_t destSize 262 , unsigned flags 263 , char const **badChar 264 , SecBase64Result *rc) 265 { 266 const size_t wholeChunks = (srcLen / NUM_ENCODED_DATA_BYTES); 267 const size_t remainderBytes = (srcLen % NUM_ENCODED_DATA_BYTES); 268 size_t maxTotal = (wholeChunks + (0 != remainderBytes)) * NUM_PLAIN_DATA_BYTES; 269 unsigned char *dest_ = dest; 270 271 ((void)remainderBytes); 272 273 assert(NULL != badChar); 274 assert(NULL != rc); 275 276 *badChar = NULL; 277 *rc = kSecB64_R_OK; 278 279 if(NULL == dest) 280 { 281 return maxTotal; 282 } 283 else if(destSize < maxTotal) 284 { 285 *rc = kSecB64_R_INSUFFICIENT_BUFFER; 286 287 return 0; 288 } 289 else 290 { 291 /* Now we iterate through the src, collecting together four characters 292 * at a time from the Base-64 alphabet, until the end-point is reached. 293 * 294 * 295 */ 296 297 char const *begin = src; 298 char const *const end = begin + srcLen; 299 size_t currIndex = 0; 300 size_t numPads = 0; 301 signed char indexes[NUM_ENCODED_DATA_BYTES]; /* 4 */ 302 303 for(; begin != end; ++begin) 304 { 305 const char ch = *begin; 306 307 if('=' == ch) 308 { 309 assert(currIndex < NUM_ENCODED_DATA_BYTES); 310 311 indexes[currIndex++] = '\0'; 312 313 ++numPads; 314 } 315 else 316 { 317 signed char ix = b64_indexes[(unsigned char)ch]; 318 319 if(-1 == ix) 320 { 321 switch(ch) 322 { 323 case ' ': 324 case '\t': 325 case '\b': 326 case '\v': 327 if(kSecB64_F_STOP_ON_UNEXPECTED_WS & flags) 328 { 329 *rc = kSecB64_R_DATA_ERROR; 330 *badChar = begin; 331 return 0; 332 } 333 else 334 { 335 /* Fall through */ 336 } 337 case '\r': 338 case '\n': 339 continue; 340 default: 341 if(kSecB64_F_STOP_ON_UNKNOWN_CHAR & flags) 342 { 343 *rc = kSecB64_R_DATA_ERROR; 344 *badChar = begin; 345 return 0; 346 } 347 else 348 { 349 continue; 350 } 351 } 352 } 353 else 354 { 355 numPads = 0; 356 357 assert(currIndex < NUM_ENCODED_DATA_BYTES); 358 359 indexes[currIndex++] = ix; 360 } 361 } 362 363 if(NUM_ENCODED_DATA_BYTES == currIndex) 364 { 365 unsigned char bytes[NUM_PLAIN_DATA_BYTES]; /* 3 */ 366 367 bytes[0] = (unsigned char)((indexes[0] << 2) + ((indexes[1] & 0x30) >> 4)); 368 369 currIndex = 0; 370 371 *dest++ = bytes[0]; 372 if(2 != numPads) 373 { 374 bytes[1] = (unsigned char)(((indexes[1] & 0xf) << 4) + ((indexes[2] & 0x3c) >> 2)); 375 376 *dest++ = bytes[1]; 377 378 if(1 != numPads) 379 { 380 bytes[2] = (unsigned char)(((indexes[2] & 0x3) << 6) + indexes[3]); 381 382 *dest++ = bytes[2]; 383 } 384 } 385 if(0 != numPads) 386 { 387 break; 388 } 389 } 390 } 391 392 return (size_t)(dest - dest_); 393 } 394 } 395 396 /* ///////////////////////////////////////////////////////////////////////////// 397 * API functions 398 */ 399 400 size_t SecBase64Encode(void const *src, size_t srcSize, char *dest, size_t destLen) 401 { 402 /* Use Null Object (Variable) here for rc, so do not need to check 403 * elsewhere. 404 */ 405 SecBase64Result rc_; 406 407 return SecBase64Encode_((unsigned char const*)src, srcSize, dest, destLen, 0, &rc_); 408 } 409 410 size_t SecBase64Encode2( void const *src 411 , size_t srcSize 412 , char *dest 413 , size_t destLen 414 , unsigned flags 415 , int lineLen /* = -1 */ 416 , SecBase64Result *rc /* = NULL */) 417 { 418 /* Use Null Object (Variable) here for rc, so do not need to check 419 * elsewhere 420 */ 421 SecBase64Result rc_; 422 if(NULL == rc) 423 { 424 rc = &rc_; 425 } 426 427 switch(kSecB64_F_LINE_LEN_MASK & flags) 428 { 429 case kSecB64_F_LINE_LEN_USE_PARAM: 430 if(lineLen >= 0) 431 { 432 break; 433 } 434 /* Fall through to 64 */ 435 case kSecB64_F_LINE_LEN_64: 436 lineLen = 64; 437 break; 438 case kSecB64_F_LINE_LEN_76: 439 lineLen = 76; 440 break; 441 default: 442 assert(false); // "Bad line length flag specified to SecBase64Encode2()" 443 case kSecB64_F_LINE_LEN_INFINITE: 444 lineLen = 0; 445 break; 446 } 447 448 assert(0 == (lineLen % 4)); 449 450 return SecBase64Encode_((unsigned char const*)src, srcSize, dest, destLen, (unsigned)lineLen, rc); 451 } 452 453 size_t SecBase64Decode(char const *src, size_t srcLen, void *dest, size_t destSize) 454 { 455 /* Use Null Object (Variable) here for rc and badChar, so do not need to 456 * check elsewhere. 457 */ 458 char const *badChar_; 459 SecBase64Result rc_; 460 461 return SecBase64Decode_(src, srcLen, (unsigned char*)dest, destSize, kSecB64_F_STOP_ON_NOTHING, &badChar_, &rc_); 462 } 463 464 size_t SecBase64Decode2( char const *src 465 , size_t srcLen 466 , void *dest 467 , size_t destSize 468 , unsigned flags 469 , char const **badChar /* = NULL */ 470 , SecBase64Result *rc /* = NULL */) 471 { 472 char const *badChar_; 473 SecBase64Result rc_; 474 475 /* Use Null Object (Variable) here for rc and badChar, so do not need to 476 * check elsewhere. 477 */ 478 if(NULL == badChar) 479 { 480 badChar = &badChar_; 481 } 482 if(NULL == rc) 483 { 484 rc = &rc_; 485 } 486 487 return SecBase64Decode_(src, srcLen, (unsigned char*)dest, destSize, flags, badChar, rc); 488 } 489 490 /* ////////////////////////////////////////////////////////////////////////// */