common/mbedtls/base64.c

   1 /*
   2  *  RFC 1521 base64 encoding/decoding
   3  *
   4  *  Copyright The Mbed TLS Contributors
   5  *  SPDX-License-Identifier: Apache-2.0
   6  *
   7  *  Licensed under the Apache License, Version 2.0 (the "License"); you may
   8  *  not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *  http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *  Unless required by applicable law or agreed to in writing, software
  14  *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15  *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *  See the License for the specific language governing permissions and
  17  *  limitations under the License.
  18  */
  19
  20 #include "common.h"
  21
  22 #if defined(MBEDTLS_BASE64_C)
  23
  24 #include "mbedtls/base64.h"
  25
  26 #include <stdint.h>
  27
  28 #if defined(MBEDTLS_SELF_TEST)
  29 #include <string.h>
  30 #if defined(MBEDTLS_PLATFORM_C)
  31 #include "mbedtls/platform.h"
  32 #else
  33 #include <stdio.h>
  34 #define mbedtls_printf printf
  35 #endif /* MBEDTLS_PLATFORM_C */
  36 #endif /* MBEDTLS_SELF_TEST */
  37
  38 static const unsigned char base64_enc_map[64] = {
  39     'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
  40     'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
  41     'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd',
  42     'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
  43     'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
  44     'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7',
  45     '8', '9', '+', '/'
  46 };
  47
  48 static const unsigned char base64_dec_map[128] = {
  49     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  50     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  51     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  52     127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
  53     127, 127, 127,  62, 127, 127, 127,  63,  52,  53,
  54     54,  55,  56,  57,  58,  59,  60,  61, 127, 127,
  55     127,  64, 127, 127, 127,   0,   1,   2,   3,   4,
  56     5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
  57     15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
  58     25, 127, 127, 127, 127, 127, 127,  26,  27,  28,
  59     29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
  60     39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
  61     49,  50,  51, 127, 127, 127, 127, 127
  62 };
  63
  64 #define BASE64_SIZE_T_MAX   ( (size_t) -1 ) /* SIZE_T_MAX is not standard */
  65
  66 /*
  67  * Constant flow conditional assignment to unsigned char
  68  */
  69 static void mbedtls_base64_cond_assign_uchar(unsigned char *dest, const unsigned char *const src,
  70                                              unsigned char condition) {
  71     /* MSVC has a warning about unary minus on unsigned integer types,
  72      * but this is well-defined and precisely what we want to do here. */
  73 #if defined(_MSC_VER)
  74 #pragma warning( push )
  75 #pragma warning( disable : 4146 )
  76 #endif
  77
  78     /* Generate bitmask from condition, mask will either be 0xFF or 0 */
  79     unsigned char mask = (condition | -condition);
  80     mask >>= 7;
  81     mask = -mask;
  82
  83 #if defined(_MSC_VER)
  84 #pragma warning( pop )
  85 #endif
  86
  87     *dest = ((*src) & mask) | ((*dest) & ~mask);
  88 }
  89
  90 /*
  91  * Constant flow conditional assignment to uint_32
  92  */
  93 static void mbedtls_base64_cond_assign_uint32(uint32_t *dest, const uint32_t src,
  94                                               uint32_t condition) {
  95     /* MSVC has a warning about unary minus on unsigned integer types,
  96      * but this is well-defined and precisely what we want to do here. */
  97 #if defined(_MSC_VER)
  98 #pragma warning( push )
  99 #pragma warning( disable : 4146 )
 100 #endif
 101
 102     /* Generate bitmask from condition, mask will either be 0xFFFFFFFF or 0 */
 103     uint32_t mask = (condition | -condition);
 104     mask >>= 31;
 105     mask = -mask;
 106
 107 #if defined(_MSC_VER)
 108 #pragma warning( pop )
 109 #endif
 110
 111     *dest = (src & mask) | ((*dest) & ~mask);
 112 }
 113
 114 /*
 115  * Constant flow check for equality
 116  */
 117 static unsigned char mbedtls_base64_eq(size_t in_a, size_t in_b) {
 118     size_t difference = in_a ^ in_b;
 119
 120     /* MSVC has a warning about unary minus on unsigned integer types,
 121      * but this is well-defined and precisely what we want to do here. */
 122 #if defined(_MSC_VER)
 123 #pragma warning( push )
 124 #pragma warning( disable : 4146 )
 125 #endif
 126
 127     difference |= -difference;
 128
 129 #if defined(_MSC_VER)
 130 #pragma warning( pop )
 131 #endif
 132
 133     /* cope with the varying size of size_t per platform */
 134     difference >>= (sizeof(difference) * 8 - 1);
 135
 136     return (unsigned char)(1 ^ difference);
 137 }
 138
 139 /*
 140  * Constant flow lookup into table.
 141  */
 142 static unsigned char mbedtls_base64_table_lookup(const unsigned char *const table,
 143                                                  const size_t table_size, const size_t table_index) {
 144     size_t i;
 145     unsigned char result = 0;
 146
 147     for (i = 0; i < table_size; ++i) {
 148         mbedtls_base64_cond_assign_uchar(&result, &table[i], mbedtls_base64_eq(i, table_index));
 149     }
 150
 151     return result;
 152 }
 153
 154 /*
 155  * Encode a buffer into base64 format
 156  */
 157 int mbedtls_base64_encode(unsigned char *dst, size_t dlen, size_t *olen,
 158                           const unsigned char *src, size_t slen) {
 159     size_t i, n;
 160     int C1, C2, C3;
 161     unsigned char *p;
 162
 163     if (slen == 0) {
 164         *olen = 0;
 165         return (0);
 166     }
 167
 168     n = slen / 3 + (slen % 3 != 0);
 169
 170     if (n > (BASE64_SIZE_T_MAX - 1) / 4) {
 171         *olen = BASE64_SIZE_T_MAX;
 172         return (MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
 173     }
 174
 175     n *= 4;
 176
 177     if ((dlen < n + 1) || (NULL == dst)) {
 178         *olen = n + 1;
 179         return (MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
 180     }
 181
 182     n = (slen / 3) * 3;
 183
 184     for (i = 0, p = dst; i < n; i += 3) {
 185         C1 = *src++;
 186         C2 = *src++;
 187         C3 = *src++;
 188
 189         *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 190                                            ((C1 >> 2) & 0x3F));
 191
 192         *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 193                                            ((((C1 &  3) << 4) + (C2 >> 4)) & 0x3F));
 194
 195         *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 196                                            ((((C2 & 15) << 2) + (C3 >> 6)) & 0x3F));
 197
 198         *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 199                                            (C3 & 0x3F));
 200     }
 201
 202     if (i < slen) {
 203         C1 = *src++;
 204         C2 = ((i + 1) < slen) ? *src++ : 0;
 205
 206         *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 207                                            ((C1 >> 2) & 0x3F));
 208
 209         *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 210                                            ((((C1 & 3) << 4) + (C2 >> 4)) & 0x3F));
 211
 212         if ((i + 1) < slen)
 213             *p++ = mbedtls_base64_table_lookup(base64_enc_map, sizeof(base64_enc_map),
 214                                                (((C2 & 15) << 2) & 0x3F));
 215         else *p++ = '=';
 216
 217         *p++ = '=';
 218     }
 219
 220     *olen = p - dst;
 221     *p = 0;
 222
 223     return (0);
 224 }
 225
 226 /*
 227  * Decode a base64-formatted buffer
 228  */
 229 int mbedtls_base64_decode(unsigned char *dst, size_t dlen, size_t *olen,
 230                           const unsigned char *src, size_t slen) {
 231     size_t i, n;
 232     uint32_t j, x;
 233     unsigned char *p;
 234     unsigned char dec_map_lookup;
 235
 236     /* First pass: check for validity and get output length */
 237     for (i = n = j = 0; i < slen; i++) {
 238         /* Skip spaces before checking for EOL */
 239         x = 0;
 240         while (i < slen && src[i] == ' ') {
 241             ++i;
 242             ++x;
 243         }
 244
 245         /* Spaces at end of buffer are OK */
 246         if (i == slen)
 247             break;
 248
 249         if ((slen - i) >= 2 &&
 250                 src[i] == '\r' && src[i + 1] == '\n')
 251             continue;
 252
 253         if (src[i] == '\n')
 254             continue;
 255
 256         /* Space inside a line is an error */
 257         if (x != 0)
 258             return (MBEDTLS_ERR_BASE64_INVALID_CHARACTER);
 259
 260         if (src[i] == '=' && ++j > 2)
 261             return (MBEDTLS_ERR_BASE64_INVALID_CHARACTER);
 262
 263         dec_map_lookup = mbedtls_base64_table_lookup(base64_dec_map, sizeof(base64_dec_map), src[i]);
 264
 265         if (src[i] > 127 || dec_map_lookup == 127)
 266             return (MBEDTLS_ERR_BASE64_INVALID_CHARACTER);
 267
 268         if (dec_map_lookup < 64 && j != 0)
 269             return (MBEDTLS_ERR_BASE64_INVALID_CHARACTER);
 270
 271         n++;
 272     }
 273
 274     if (n == 0) {
 275         *olen = 0;
 276         return (0);
 277     }
 278
 279     /* The following expression is to calculate the following formula without
 280      * risk of integer overflow in n:
 281      *     n = ( ( n * 6 ) + 7 ) >> 3;
 282      */
 283     n = (6 * (n >> 3)) + ((6 * (n & 0x7) + 7) >> 3);
 284     n -= j;
 285
 286     if (dst == NULL || dlen < n) {
 287         *olen = n;
 288         return (MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL);
 289     }
 290
 291     for (j = 3, n = x = 0, p = dst; i > 0; i--, src++) {
 292         if (*src == '\r' || *src == '\n' || *src == ' ')
 293             continue;
 294
 295         dec_map_lookup = mbedtls_base64_table_lookup(base64_dec_map, sizeof(base64_dec_map), *src);
 296
 297         mbedtls_base64_cond_assign_uint32(&j, j - 1, mbedtls_base64_eq(dec_map_lookup, 64));
 298         x  = (x << 6) | (dec_map_lookup & 0x3F);
 299
 300         if (++n == 4) {
 301             n = 0;
 302             if (j > 0) *p++ = (unsigned char)(x >> 16);
 303             if (j > 1) *p++ = (unsigned char)(x >>  8);
 304             if (j > 2) *p++ = (unsigned char)(x);
 305         }
 306     }
 307
 308     *olen = p - dst;
 309
 310     return (0);
 311 }
 312
 313 #if defined(MBEDTLS_SELF_TEST)
 314
 315 static const unsigned char base64_test_dec[64] = {
 316     0x24, 0x48, 0x6E, 0x56, 0x87, 0x62, 0x5A, 0xBD,
 317     0xBF, 0x17, 0xD9, 0xA2, 0xC4, 0x17, 0x1A, 0x01,
 318     0x94, 0xED, 0x8F, 0x1E, 0x11, 0xB3, 0xD7, 0x09,
 319     0x0C, 0xB6, 0xE9, 0x10, 0x6F, 0x22, 0xEE, 0x13,
 320     0xCA, 0xB3, 0x07, 0x05, 0x76, 0xC9, 0xFA, 0x31,
 321     0x6C, 0x08, 0x34, 0xFF, 0x8D, 0xC2, 0x6C, 0x38,
 322     0x00, 0x43, 0xE9, 0x54, 0x97, 0xAF, 0x50, 0x4B,
 323     0xD1, 0x41, 0xBA, 0x95, 0x31, 0x5A, 0x0B, 0x97
 324 };
 325
 326 static const unsigned char base64_test_enc[] =
 327     "JEhuVodiWr2/F9mixBcaAZTtjx4Rs9cJDLbpEG8i7hPK"
 328     "swcFdsn6MWwINP+Nwmw4AEPpVJevUEvRQbqVMVoLlw==";
 329
 330 /*
 331  * Checkup routine
 332  */
 333 int mbedtls_base64_self_test(int verbose) {
 334     size_t len;
 335     const unsigned char *src;
 336     unsigned char buffer[128];
 337
 338     if (verbose != 0)
 339         mbedtls_printf("  Base64 encoding test: ");
 340
 341     src = base64_test_dec;
 342
 343     if (mbedtls_base64_encode(buffer, sizeof(buffer), &len, src, 64) != 0 ||
 344             memcmp(base64_test_enc, buffer, 88) != 0) {
 345         if (verbose != 0)
 346             mbedtls_printf("failed\n");
 347
 348         return (1);
 349     }
 350
 351     if (verbose != 0)
 352         mbedtls_printf("passed\n  Base64 decoding test: ");
 353
 354     src = base64_test_enc;
 355
 356     if (mbedtls_base64_decode(buffer, sizeof(buffer), &len, src, 88) != 0 ||
 357             memcmp(base64_test_dec, buffer, 64) != 0) {
 358         if (verbose != 0)
 359             mbedtls_printf("failed\n");
 360
 361         return (1);
 362     }
 363
 364     if (verbose != 0)
 365         mbedtls_printf("passed\n\n");
 366
 367     return (0);
 368 }
 369
 370 #endif /* MBEDTLS_SELF_TEST */
 371
 372 #endif /* MBEDTLS_BASE64_C */