/work/mbedtls-3.6.6/library/base64.c

Source
/*
 *  RFC 1521 base64 encoding/decoding
 *
 *  Copyright The Mbed TLS Contributors
 *  SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
 */

#include "common.h"

#if defined(MBEDTLS_BASE64_C)

#include "mbedtls/base64.h"
#include "base64_internal.h"
#include "constant_time_internal.h"
#include "mbedtls/error.h"

#include <limits.h>
#include <stdint.h>

#if defined(MBEDTLS_SELF_TEST)
#include <string.h>
#include "mbedtls/platform.h"
#endif /* MBEDTLS_SELF_TEST */

MBEDTLS_STATIC_TESTABLE
unsigned char mbedtls_ct_base64_enc_char(unsigned char value)
{
    unsigned char digit = 0;
    /* For each range of values, if value is in that range, mask digit with
     * the corresponding value. Since value can only be in a single range,
     * only at most one masking will change digit. */
    digit |= mbedtls_ct_uchar_in_range_if(0, 25, value, 'A' + value);
    digit |= mbedtls_ct_uchar_in_range_if(26, 51, value, 'a' + value - 26);
    digit |= mbedtls_ct_uchar_in_range_if(52, 61, value, '0' + value - 52);
    digit |= mbedtls_ct_uchar_in_range_if(62, 62, value, '+');
    digit |= mbedtls_ct_uchar_in_range_if(63, 63, value, '/');
    return digit;
}

MBEDTLS_STATIC_TESTABLE
signed char mbedtls_ct_base64_dec_value(unsigned char c)
{
    unsigned char val = 0;
    /* For each range of digits, if c is in that range, mask val with
     * the corresponding value. Since c can only be in a single range,
     * only at most one masking will change val. Set val to one plus
     * the desired value so that it stays 0 if c is in none of the ranges. */
    val |= mbedtls_ct_uchar_in_range_if('A', 'Z', c, c - 'A' +  0 + 1);
    val |= mbedtls_ct_uchar_in_range_if('a', 'z', c, c - 'a' + 26 + 1);
    val |= mbedtls_ct_uchar_in_range_if('0', '9', c, c - '0' + 52 + 1);
    val |= mbedtls_ct_uchar_in_range_if('+', '+', c, c - '+' + 62 + 1);
    val |= mbedtls_ct_uchar_in_range_if('/', '/', c, c - '/' + 63 + 1);
    /* At this point, val is 0 if c is an invalid digit and v+1 if c is
     * a digit with the value v. */
    return val - 1;
}

/*
 * Encode a buffer into base64 format
 */
int mbedtls_base64_encode(unsigned char *dst, size_t dlen, size_t *olen,
                          const unsigned char *src, size_t slen)
{
    size_t i, n;
    int C1, C2, C3;
    unsigned char *p;

    if (slen == 0) {
        *olen = 0;
        return 0;
    }

    n = slen / 3 + (slen % 3 != 0);

    if (n > (SIZE_MAX - 1) / 4) {
        *olen = SIZE_MAX;
        return MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL;
    }

    n *= 4;

    if ((dlen < n + 1) || (NULL == dst)) {
        *olen = n + 1;
        return MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL;
    }

    n = (slen / 3) * 3;

    for (i = 0, p = dst; i < n; i += 3) {
        C1 = *src++;
        C2 = *src++;
        C3 = *src++;

        *p++ = mbedtls_ct_base64_enc_char((C1 >> 2) & 0x3F);
        *p++ = mbedtls_ct_base64_enc_char((((C1 &  3) << 4) + (C2 >> 4))
                                          & 0x3F);
        *p++ = mbedtls_ct_base64_enc_char((((C2 & 15) << 2) + (C3 >> 6))
                                          & 0x3F);
        *p++ = mbedtls_ct_base64_enc_char(C3 & 0x3F);
    }

    if (i < slen) {
        C1 = *src++;
        C2 = ((i + 1) < slen) ? *src++ : 0;

        *p++ = mbedtls_ct_base64_enc_char((C1 >> 2) & 0x3F);
        *p++ = mbedtls_ct_base64_enc_char((((C1 & 3) << 4) + (C2 >> 4))
                                          & 0x3F);

        if ((i + 1) < slen) {
            *p++ = mbedtls_ct_base64_enc_char(((C2 & 15) << 2) & 0x3F);
        } else {
            *p++ = '=';
        }

        *p++ = '=';
    }

    *olen = (size_t) (p - dst);
    *p = 0;

    return 0;
}

/*
 * Decode a base64-formatted buffer
 */
int mbedtls_base64_decode(unsigned char *dst, size_t dlen, size_t *olen,
                          const unsigned char *src, size_t slen)
{
    size_t i; /* index in source */
    size_t n; /* number of digits or trailing = in source */
    uint32_t x; /* value accumulator */
    unsigned accumulated_digits = 0;
    unsigned equals = 0;
    int spaces_present = 0;
    unsigned char *p;

    /* First pass: check for validity and get output length */
    for (i = n = 0; i < slen; i++) {
        /* Skip spaces before checking for EOL */
        spaces_present = 0;
        while (i < slen && src[i] == ' ') {
            ++i;
            spaces_present = 1;
        }

        /* Spaces at end of buffer are OK */
        if (i == slen) {
            break;
        }

        if ((slen - i) >= 2 &&
            src[i] == '\r' && src[i + 1] == '\n') {
            continue;
        }

        if (src[i] == '\n') {
            continue;
        }

        /* Space inside a line is an error */
        if (spaces_present) {
            return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
        }

        if (src[i] > 127) {
            return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
        }

        if (src[i] == '=') {
            if (++equals > 2) {
                return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
            }
        } else {
            if (equals != 0) {
                return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
            }
            if (mbedtls_ct_base64_dec_value(src[i]) < 0) {
                return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
            }
        }
        n++;
    }

    /* In valid base64, the number of digits (n-equals) is always of the form
     * 4*k, 4*k+2 or *4k+3. Also, the number n of digits plus the number of
     * equal signs at the end is always a multiple of 4. */
    if ((n - equals) % 4 == 1) {
        return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
    }
    if (n % 4 != 0) {
        return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
    }

    /* We've determined that the input is valid, and that it contains
     * exactly k blocks of digits-or-equals, with n = 4 * k,
     * and equals only present at the end of the last block if at all.
     * Now we can calculate the length of the output.
     *
     * Each block of 4 digits in the input map to 3 bytes of output.
     * For the last block:
     * - abcd (where abcd are digits) is a full 3-byte block;
     * - abc= means 1 byte less than a full 3-byte block of output;
     * - ab== means 2 bytes less than a full 3-byte block of output;
     * - a==== and ==== is rejected above.
     */
    *olen = (n / 4) * 3 - equals;

    /* If the output buffer is too small, signal this and stop here.
     * Also, as documented, stop here if `dst` is null, independently of
     * `dlen`.
     *
     * There is an edge case when the output is empty: in this case,
     * `dlen == 0` with `dst == NULL` is valid (on some platforms,
     * `malloc(0)` returns `NULL`). Since the call is valid, we return
     * 0 in this case.
     */
    if ((*olen != 0 && dst == NULL) || dlen < *olen) {
        return MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL;
    }

    for (x = 0, p = dst; i > 0; i--, src++) {
        if (*src == '\r' || *src == '\n' || *src == ' ') {
            continue;
        }
        if (*src == '=') {
            /* We already know from the first loop that equal signs are
             * only at the end. */
            break;
        }
        x = x << 6;
        x |= mbedtls_ct_base64_dec_value(*src);

        if (++accumulated_digits == 4) {
            accumulated_digits = 0;
            *p++ = MBEDTLS_BYTE_2(x);
            *p++ = MBEDTLS_BYTE_1(x);
            *p++ = MBEDTLS_BYTE_0(x);
        }
    }
    if (accumulated_digits == 3) {
        *p++ = MBEDTLS_BYTE_2(x << 6);
        *p++ = MBEDTLS_BYTE_1(x << 6);
    } else if (accumulated_digits == 2) {
        *p++ = MBEDTLS_BYTE_2(x << 12);
    }

    if (*olen != (size_t) (p - dst)) {
        return MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
    }

    return 0;
}

#if defined(MBEDTLS_SELF_TEST)

static const unsigned char base64_test_dec[64] =
{
    0x24, 0x48, 0x6E, 0x56, 0x87, 0x62, 0x5A, 0xBD,
    0xBF, 0x17, 0xD9, 0xA2, 0xC4, 0x17, 0x1A, 0x01,
    0x94, 0xED, 0x8F, 0x1E, 0x11, 0xB3, 0xD7, 0x09,
    0x0C, 0xB6, 0xE9, 0x10, 0x6F, 0x22, 0xEE, 0x13,
    0xCA, 0xB3, 0x07, 0x05, 0x76, 0xC9, 0xFA, 0x31,
    0x6C, 0x08, 0x34, 0xFF, 0x8D, 0xC2, 0x6C, 0x38,
    0x00, 0x43, 0xE9, 0x54, 0x97, 0xAF, 0x50, 0x4B,
    0xD1, 0x41, 0xBA, 0x95, 0x31, 0x5A, 0x0B, 0x97
};

static const unsigned char base64_test_enc[] =
    "JEhuVodiWr2/F9mixBcaAZTtjx4Rs9cJDLbpEG8i7hPK"
    "swcFdsn6MWwINP+Nwmw4AEPpVJevUEvRQbqVMVoLlw==";

/*
 * Checkup routine
 */
int mbedtls_base64_self_test(int verbose)
{
    size_t len;
    const unsigned char *src;
    unsigned char buffer[128];

    if (verbose != 0) {
        mbedtls_printf("  Base64 encoding test: ");
    }

    src = base64_test_dec;

    if (mbedtls_base64_encode(buffer, sizeof(buffer), &len, src, 64) != 0 ||
        memcmp(base64_test_enc, buffer, 88) != 0) {
        if (verbose != 0) {
            mbedtls_printf("failed\n");
        }

        return 1;
    }

    if (verbose != 0) {
        mbedtls_printf("passed\n  Base64 decoding test: ");
    }

    src = base64_test_enc;

    if (mbedtls_base64_decode(buffer, sizeof(buffer), &len, src, 88) != 0 ||
        memcmp(base64_test_dec, buffer, 64) != 0) {
        if (verbose != 0) {
            mbedtls_printf("failed\n");
        }

        return 1;
    }

    if (verbose != 0) {
        mbedtls_printf("passed\n\n");
    }

    return 0;
}

#endif /* MBEDTLS_SELF_TEST */

#endif /* MBEDTLS_BASE64_C */

Coverage Report

Created: 2026-10-17 06:10

Line	Count	Source
1		/*
2		* RFC 1521 base64 encoding/decoding
3		*
4		* Copyright The Mbed TLS Contributors
5		* SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
6		*/
7
8		#include "common.h"
9
10		#if defined(MBEDTLS_BASE64_C)
11
12		#include "mbedtls/base64.h"
13		#include "base64_internal.h"
14		#include "constant_time_internal.h"
15		#include "mbedtls/error.h"
16
17		#include <limits.h>
18		#include <stdint.h>
19
20		#if defined(MBEDTLS_SELF_TEST)
21		#include <string.h>
22		#include "mbedtls/platform.h"
23		#endif /* MBEDTLS_SELF_TEST */
24
25		MBEDTLS_STATIC_TESTABLE
26		unsigned char mbedtls_ct_base64_enc_char(unsigned char value)
27	0	{
28	0	unsigned char digit = 0;
29		/* For each range of values, if value is in that range, mask digit with
30		* the corresponding value. Since value can only be in a single range,
31		* only at most one masking will change digit. */
32	0	digit \|= mbedtls_ct_uchar_in_range_if(0, 25, value, 'A' + value);
33	0	digit \|= mbedtls_ct_uchar_in_range_if(26, 51, value, 'a' + value - 26);
34	0	digit \|= mbedtls_ct_uchar_in_range_if(52, 61, value, '0' + value - 52);
35	0	digit \|= mbedtls_ct_uchar_in_range_if(62, 62, value, '+');
36	0	digit \|= mbedtls_ct_uchar_in_range_if(63, 63, value, '/');
37	0	return digit;
38	0	}
39
40		MBEDTLS_STATIC_TESTABLE
41		signed char mbedtls_ct_base64_dec_value(unsigned char c)
42	0	{
43	0	unsigned char val = 0;
44		/* For each range of digits, if c is in that range, mask val with
45		* the corresponding value. Since c can only be in a single range,
46		* only at most one masking will change val. Set val to one plus
47		* the desired value so that it stays 0 if c is in none of the ranges. */
48	0	val \|= mbedtls_ct_uchar_in_range_if('A', 'Z', c, c - 'A' + 0 + 1);
49	0	val \|= mbedtls_ct_uchar_in_range_if('a', 'z', c, c - 'a' + 26 + 1);
50	0	val \|= mbedtls_ct_uchar_in_range_if('0', '9', c, c - '0' + 52 + 1);
51	0	val \|= mbedtls_ct_uchar_in_range_if('+', '+', c, c - '+' + 62 + 1);
52	0	val \|= mbedtls_ct_uchar_in_range_if('/', '/', c, c - '/' + 63 + 1);
53		/* At this point, val is 0 if c is an invalid digit and v+1 if c is
54		* a digit with the value v. */
55	0	return val - 1;
56	0	}
57
58		/*
59		* Encode a buffer into base64 format
60		*/
61		int mbedtls_base64_encode(unsigned char dst, size_t dlen, size_t olen,
62		const unsigned char *src, size_t slen)
63	0	{
64	0	size_t i, n;
65	0	int C1, C2, C3;
66	0	unsigned char *p;
67
68	0	if (slen == 0) {
69	0	*olen = 0;
70	0	return 0;
71	0	}
72
73	0	n = slen / 3 + (slen % 3 != 0);
74
75	0	if (n > (SIZE_MAX - 1) / 4) {
76	0	*olen = SIZE_MAX;
77	0	return MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL;
78	0	}
79
80	0	n *= 4;
81
82	0	if ((dlen < n + 1) \|\| (NULL == dst)) {
83	0	*olen = n + 1;
84	0	return MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL;
85	0	}
86
87	0	n = (slen / 3) * 3;
88
89	0	for (i = 0, p = dst; i < n; i += 3) {
90	0	C1 = *src++;
91	0	C2 = *src++;
92	0	C3 = *src++;
93
94	0	*p++ = mbedtls_ct_base64_enc_char((C1 >> 2) & 0x3F);
95	0	*p++ = mbedtls_ct_base64_enc_char((((C1 & 3) << 4) + (C2 >> 4))
96	0	& 0x3F);
97	0	*p++ = mbedtls_ct_base64_enc_char((((C2 & 15) << 2) + (C3 >> 6))
98	0	& 0x3F);
99	0	*p++ = mbedtls_ct_base64_enc_char(C3 & 0x3F);
100	0	}
101
102	0	if (i < slen) {
103	0	C1 = *src++;
104	0	C2 = ((i + 1) < slen) ? *src++ : 0;
105
106	0	*p++ = mbedtls_ct_base64_enc_char((C1 >> 2) & 0x3F);
107	0	*p++ = mbedtls_ct_base64_enc_char((((C1 & 3) << 4) + (C2 >> 4))
108	0	& 0x3F);
109
110	0	if ((i + 1) < slen) {
111	0	*p++ = mbedtls_ct_base64_enc_char(((C2 & 15) << 2) & 0x3F);
112	0	} else {
113	0	*p++ = '=';
114	0	}
115
116	0	*p++ = '=';
117	0	}
118
119	0	*olen = (size_t) (p - dst);
120	0	*p = 0;
121
122	0	return 0;
123	0	}
124
125		/*
126		* Decode a base64-formatted buffer
127		*/
128		int mbedtls_base64_decode(unsigned char dst, size_t dlen, size_t olen,
129		const unsigned char *src, size_t slen)
130	0	{
131	0	size_t i; /* index in source */
132	0	size_t n; /* number of digits or trailing = in source */
133	0	uint32_t x; /* value accumulator */
134	0	unsigned accumulated_digits = 0;
135	0	unsigned equals = 0;
136	0	int spaces_present = 0;
137	0	unsigned char *p;
138
139		/* First pass: check for validity and get output length */
140	0	for (i = n = 0; i < slen; i++) {
141		/* Skip spaces before checking for EOL */
142	0	spaces_present = 0;
143	0	while (i < slen && src[i] == ' ') {
144	0	++i;
145	0	spaces_present = 1;
146	0	}
147
148		/* Spaces at end of buffer are OK */
149	0	if (i == slen) {
150	0	break;
151	0	}
152
153	0	if ((slen - i) >= 2 &&
154	0	src[i] == '\r' && src[i + 1] == '\n') {
155	0	continue;
156	0	}
157
158	0	if (src[i] == '\n') {
159	0	continue;
160	0	}
161
162		/* Space inside a line is an error */
163	0	if (spaces_present) {
164	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
165	0	}
166
167	0	if (src[i] > 127) {
168	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
169	0	}
170
171	0	if (src[i] == '=') {
172	0	if (++equals > 2) {
173	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
174	0	}
175	0	} else {
176	0	if (equals != 0) {
177	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
178	0	}
179	0	if (mbedtls_ct_base64_dec_value(src[i]) < 0) {
180	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
181	0	}
182	0	}
183	0	n++;
184	0	}
185
186		/* In valid base64, the number of digits (n-equals) is always of the form
187		* 4k, 4k+2 or *4k+3. Also, the number n of digits plus the number of
188		* equal signs at the end is always a multiple of 4. */
189	0	if ((n - equals) % 4 == 1) {
190	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
191	0	}
192	0	if (n % 4 != 0) {
193	0	return MBEDTLS_ERR_BASE64_INVALID_CHARACTER;
194	0	}
195
196		/* We've determined that the input is valid, and that it contains
197		* exactly k blocks of digits-or-equals, with n = 4 * k,
198		* and equals only present at the end of the last block if at all.
199		* Now we can calculate the length of the output.
200		*
201		* Each block of 4 digits in the input map to 3 bytes of output.
202		* For the last block:
203		* - abcd (where abcd are digits) is a full 3-byte block;
204		* - abc= means 1 byte less than a full 3-byte block of output;
205		* - ab== means 2 bytes less than a full 3-byte block of output;
206		* - a==== and ==== is rejected above.
207		*/
208	0	olen = (n / 4) 3 - equals;
209
210		/* If the output buffer is too small, signal this and stop here.
211		* Also, as documented, stop here if `dst` is null, independently of
212		* `dlen`.
213		*
214		* There is an edge case when the output is empty: in this case,
215		* `dlen == 0` with `dst == NULL` is valid (on some platforms,
216		* `malloc(0)` returns `NULL`). Since the call is valid, we return
217		* 0 in this case.
218		*/
219	0	if ((olen != 0 && dst == NULL) \|\| dlen < olen) {
220	0	return MBEDTLS_ERR_BASE64_BUFFER_TOO_SMALL;
221	0	}
222
223	0	for (x = 0, p = dst; i > 0; i--, src++) {
224	0	if (src == '\r' \|\| src == '\n' \|\| *src == ' ') {
225	0	continue;
226	0	}
227	0	if (*src == '=') {
228		/* We already know from the first loop that equal signs are
229		* only at the end. */
230	0	break;
231	0	}
232	0	x = x << 6;
233	0	x \|= mbedtls_ct_base64_dec_value(*src);
234
235	0	if (++accumulated_digits == 4) {
236	0	accumulated_digits = 0;
237	0	*p++ = MBEDTLS_BYTE_2(x);
238	0	*p++ = MBEDTLS_BYTE_1(x);
239	0	*p++ = MBEDTLS_BYTE_0(x);
240	0	}
241	0	}
242	0	if (accumulated_digits == 3) {
243	0	*p++ = MBEDTLS_BYTE_2(x << 6);
244	0	*p++ = MBEDTLS_BYTE_1(x << 6);
245	0	} else if (accumulated_digits == 2) {
246	0	*p++ = MBEDTLS_BYTE_2(x << 12);
247	0	}
248
249	0	if (*olen != (size_t) (p - dst)) {
250	0	return MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
251	0	}
252
253	0	return 0;
254	0	}
255
256		#if defined(MBEDTLS_SELF_TEST)
257
258		static const unsigned char base64_test_dec[64] =
259		{
260		0x24, 0x48, 0x6E, 0x56, 0x87, 0x62, 0x5A, 0xBD,
261		0xBF, 0x17, 0xD9, 0xA2, 0xC4, 0x17, 0x1A, 0x01,
262		0x94, 0xED, 0x8F, 0x1E, 0x11, 0xB3, 0xD7, 0x09,
263		0x0C, 0xB6, 0xE9, 0x10, 0x6F, 0x22, 0xEE, 0x13,
264		0xCA, 0xB3, 0x07, 0x05, 0x76, 0xC9, 0xFA, 0x31,
265		0x6C, 0x08, 0x34, 0xFF, 0x8D, 0xC2, 0x6C, 0x38,
266		0x00, 0x43, 0xE9, 0x54, 0x97, 0xAF, 0x50, 0x4B,
267		0xD1, 0x41, 0xBA, 0x95, 0x31, 0x5A, 0x0B, 0x97
268		};
269
270		static const unsigned char base64_test_enc[] =
271		"JEhuVodiWr2/F9mixBcaAZTtjx4Rs9cJDLbpEG8i7hPK"
272		"swcFdsn6MWwINP+Nwmw4AEPpVJevUEvRQbqVMVoLlw==";
273
274		/*
275		* Checkup routine
276		*/
277		int mbedtls_base64_self_test(int verbose)
278	0	{
279	0	size_t len;
280	0	const unsigned char *src;
281	0	unsigned char buffer[128];
282
283	0	if (verbose != 0) {
284	0	mbedtls_printf(" Base64 encoding test: ");
285	0	}
286
287	0	src = base64_test_dec;
288
289	0	if (mbedtls_base64_encode(buffer, sizeof(buffer), &len, src, 64) != 0 \|\|
290	0	memcmp(base64_test_enc, buffer, 88) != 0) {
291	0	if (verbose != 0) {
292	0	mbedtls_printf("failed\n");
293	0	}
294
295	0	return 1;
296	0	}
297
298	0	if (verbose != 0) {
299	0	mbedtls_printf("passed\n Base64 decoding test: ");
300	0	}
301
302	0	src = base64_test_enc;
303
304	0	if (mbedtls_base64_decode(buffer, sizeof(buffer), &len, src, 88) != 0 \|\|
305	0	memcmp(base64_test_dec, buffer, 64) != 0) {
306	0	if (verbose != 0) {
307	0	mbedtls_printf("failed\n");
308	0	}
309
310	0	return 1;
311	0	}
312
313	0	if (verbose != 0) {
314	0	mbedtls_printf("passed\n\n");
315	0	}
316
317	0	return 0;
318	0	}
319
320		#endif /* MBEDTLS_SELF_TEST */
321
322		#endif /* MBEDTLS_BASE64_C */