mirror of
https://github.com/torvalds/linux.git
synced 2026-11-20 13:03:48 +00:00
After a recent change in clang to warn on signed char conversions within
array initializers [1], there are several instances of this warning from
base64_rev_maps in lib/base64.c, which can break the build with W=e or
CONFIG_WERROR=y:
lib/base64.c:58:18: error: implicit conversion from 'int' to 's8' (aka 'signed char') changes value from 131 to -125 [-Werror,-Wconstant-conversion]
58 | [BASE64_IMAP] = BASE64_REV_INIT('+', ',')
| ^~~~~~~~~~~~~~~~~~~~~~~~~
lib/base64.c:52:2: note: expanded from macro 'BASE64_REV_INIT'
48 | #define BASE64_REV_INIT(ch_62, ch_63) { \
| ~
49 | [0 ... 0x1f] = -1, \
50 | INIT_32(0x20, ch_62, ch_63), \
51 | INIT_32(0x40, ch_62, ch_63), \
52 | INIT_32(0x60, ch_62, ch_63), \
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
...
lib/base64.c:34:42: note: expanded from macro 'INIT_1'
34 | : (v) >= '0' && (v) <= '9' ? (v) - '0' + 52 \
| ~~~~~~~~~~^~~~
lib/base64.c:58:18: error: implicit conversion from 'int' to 's8' (aka 'signed char') changes value from 130 to -126 [-Werror,-Wconstant-conversion]
58 | [BASE64_IMAP] = BASE64_REV_INIT('+', ',')
| ^~~~~~~~~~~~~~~~~~~~~~~~~
lib/base64.c:52:2: note: expanded from macro 'BASE64_REV_INIT'
48 | #define BASE64_REV_INIT(ch_62, ch_63) { \
| ~
49 | [0 ... 0x1f] = -1, \
50 | INIT_32(0x20, ch_62, ch_63), \
51 | INIT_32(0x40, ch_62, ch_63), \
52 | INIT_32(0x60, ch_62, ch_63), \
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~
...
lib/base64.c:34:42: note: expanded from macro 'INIT_1'
34 | : (v) >= '0' && (v) <= '9' ? (v) - '0' + 52 \
| ~~~~~~~~~~^~~~
...
These are false positives, as the branch where the wraparound could happen
is unreachable with the values that clang reports. This is not considered
a bug by some clang folks [2][3], so silence the warnings using the __diag
macros the kernel has to workaround compiler warnings when necessary.
Link: https://lore.kernel.org/20261008-base64-silence-clang-24-constant-conversion-v1-1-0858b60b23c8@kernel.org
Link: https://github.com/llvm/llvm-project/commit/a5ef934a8d295dc03be3960f2b3744ec2e53238e [1]
Link: https://github.com/llvm/llvm-project/issues/223923#issuecomment-6056856245 [2]
Link: https://github.com/llvm/llvm-project/pull/226775#pullrequestreview-5454407389 [3]
Fixes: c4eb7ad32e ("lib/base64: optimize base64_decode() with reverse lookup tables")
Signed-off-by: Nathan Chancellor <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Closes: https://github.com/ClangBuiltLinux/linux/issues/2181
Acked-by: Kuan-Wei Chiu <[email protected]>
Cc: Nick Desaulniers <[email protected]>
Cc: Bill Wendling <[email protected]>
Cc: Justin Stitt <[email protected]>
Cc: Guan-Chun Wu <[email protected]>
Cc: <[email protected]>
189 lines
5.4 KiB
C
189 lines
5.4 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* base64.c - Base64 with support for multiple variants
|
|
*
|
|
* Copyright (c) 2020 Hannes Reinecke, SUSE
|
|
*
|
|
* Based on the base64url routines from fs/crypto/fname.c
|
|
* (which are using the URL-safe Base64 encoding),
|
|
* modified to support multiple Base64 variants.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/types.h>
|
|
#include <linux/export.h>
|
|
#include <linux/string.h>
|
|
#include <linux/base64.h>
|
|
|
|
static const char base64_tables[][65] = {
|
|
[BASE64_STD] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
|
|
[BASE64_URLSAFE] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
|
|
[BASE64_IMAP] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,",
|
|
};
|
|
|
|
/*
|
|
* Initialize the base64 reverse mapping for a single character
|
|
* This macro maps a character to its corresponding base64 value,
|
|
* returning -1 if the character is invalid.
|
|
* char 'A'-'Z' maps to 0-25, 'a'-'z' maps to 26-51, '0'-'9' maps to 52-61,
|
|
* ch_62 maps to 62, ch_63 maps to 63, and other characters return -1
|
|
*/
|
|
#define INIT_1(v, ch_62, ch_63) \
|
|
[v] = (v) >= 'A' && (v) <= 'Z' ? (v) - 'A' \
|
|
: (v) >= 'a' && (v) <= 'z' ? (v) - 'a' + 26 \
|
|
: (v) >= '0' && (v) <= '9' ? (v) - '0' + 52 \
|
|
: (v) == (ch_62) ? 62 : (v) == (ch_63) ? 63 : -1
|
|
|
|
/*
|
|
* Recursive macros to generate multiple Base64 reverse mapping table entries.
|
|
* Each macro generates a sequence of entries in the lookup table:
|
|
* INIT_2 generates 2 entries, INIT_4 generates 4, INIT_8 generates 8, and so on up to INIT_32.
|
|
*/
|
|
#define INIT_2(v, ...) INIT_1(v, __VA_ARGS__), INIT_1((v) + 1, __VA_ARGS__)
|
|
#define INIT_4(v, ...) INIT_2(v, __VA_ARGS__), INIT_2((v) + 2, __VA_ARGS__)
|
|
#define INIT_8(v, ...) INIT_4(v, __VA_ARGS__), INIT_4((v) + 4, __VA_ARGS__)
|
|
#define INIT_16(v, ...) INIT_8(v, __VA_ARGS__), INIT_8((v) + 8, __VA_ARGS__)
|
|
#define INIT_32(v, ...) INIT_16(v, __VA_ARGS__), INIT_16((v) + 16, __VA_ARGS__)
|
|
|
|
#define BASE64_REV_INIT(ch_62, ch_63) { \
|
|
[0 ... 0x1f] = -1, \
|
|
INIT_32(0x20, ch_62, ch_63), \
|
|
INIT_32(0x40, ch_62, ch_63), \
|
|
INIT_32(0x60, ch_62, ch_63), \
|
|
[0x80 ... 0xff] = -1 }
|
|
|
|
__diag_push();
|
|
__diag_ignore(clang, all, "-Wconstant-conversion", "https://github.com/llvm/llvm-project/issues/223923");
|
|
static const s8 base64_rev_maps[][256] = {
|
|
[BASE64_STD] = BASE64_REV_INIT('+', '/'),
|
|
[BASE64_URLSAFE] = BASE64_REV_INIT('-', '_'),
|
|
[BASE64_IMAP] = BASE64_REV_INIT('+', ',')
|
|
};
|
|
__diag_pop();
|
|
|
|
#undef BASE64_REV_INIT
|
|
#undef INIT_32
|
|
#undef INIT_16
|
|
#undef INIT_8
|
|
#undef INIT_4
|
|
#undef INIT_2
|
|
#undef INIT_1
|
|
/**
|
|
* base64_encode() - Base64-encode some binary data
|
|
* @src: the binary data to encode
|
|
* @srclen: the length of @src in bytes
|
|
* @dst: (output) the Base64-encoded string. Not NUL-terminated.
|
|
* @padding: whether to append '=' padding characters
|
|
* @variant: which base64 variant to use
|
|
*
|
|
* Encodes data using the selected Base64 variant.
|
|
*
|
|
* Return: the length of the resulting Base64-encoded string in bytes.
|
|
*/
|
|
int base64_encode(const u8 *src, int srclen, char *dst, bool padding, enum base64_variant variant)
|
|
{
|
|
u32 ac = 0;
|
|
char *cp = dst;
|
|
const char *base64_table = base64_tables[variant];
|
|
|
|
while (srclen >= 3) {
|
|
ac = src[0] << 16 | src[1] << 8 | src[2];
|
|
*cp++ = base64_table[ac >> 18];
|
|
*cp++ = base64_table[(ac >> 12) & 0x3f];
|
|
*cp++ = base64_table[(ac >> 6) & 0x3f];
|
|
*cp++ = base64_table[ac & 0x3f];
|
|
|
|
src += 3;
|
|
srclen -= 3;
|
|
}
|
|
|
|
switch (srclen) {
|
|
case 2:
|
|
ac = src[0] << 16 | src[1] << 8;
|
|
*cp++ = base64_table[ac >> 18];
|
|
*cp++ = base64_table[(ac >> 12) & 0x3f];
|
|
*cp++ = base64_table[(ac >> 6) & 0x3f];
|
|
if (padding)
|
|
*cp++ = '=';
|
|
break;
|
|
case 1:
|
|
ac = src[0] << 16;
|
|
*cp++ = base64_table[ac >> 18];
|
|
*cp++ = base64_table[(ac >> 12) & 0x3f];
|
|
if (padding) {
|
|
*cp++ = '=';
|
|
*cp++ = '=';
|
|
}
|
|
break;
|
|
}
|
|
return cp - dst;
|
|
}
|
|
EXPORT_SYMBOL_GPL(base64_encode);
|
|
|
|
/**
|
|
* base64_decode() - Base64-decode a string
|
|
* @src: the string to decode. Doesn't need to be NUL-terminated.
|
|
* @srclen: the length of @src in bytes
|
|
* @dst: (output) the decoded binary data
|
|
* @padding: whether the input is expected to include '=' padding characters
|
|
* @variant: which base64 variant to use
|
|
*
|
|
* Decodes a string using the selected Base64 variant.
|
|
*
|
|
* Return: the length of the resulting decoded binary data in bytes,
|
|
* or -1 if the string isn't a valid Base64 string.
|
|
*/
|
|
int base64_decode(const char *src, int srclen, u8 *dst, bool padding, enum base64_variant variant)
|
|
{
|
|
u8 *bp = dst;
|
|
s8 input[4];
|
|
s32 val;
|
|
const u8 *s = (const u8 *)src;
|
|
const s8 *base64_rev_tables = base64_rev_maps[variant];
|
|
|
|
while (srclen >= 4) {
|
|
input[0] = base64_rev_tables[s[0]];
|
|
input[1] = base64_rev_tables[s[1]];
|
|
input[2] = base64_rev_tables[s[2]];
|
|
input[3] = base64_rev_tables[s[3]];
|
|
|
|
val = input[0] << 18 | input[1] << 12 | input[2] << 6 | input[3];
|
|
|
|
if (unlikely(val < 0)) {
|
|
if (!padding || srclen != 4 || s[3] != '=')
|
|
return -1;
|
|
padding = 0;
|
|
srclen = s[2] == '=' ? 2 : 3;
|
|
break;
|
|
}
|
|
|
|
*bp++ = val >> 16;
|
|
*bp++ = val >> 8;
|
|
*bp++ = val;
|
|
|
|
s += 4;
|
|
srclen -= 4;
|
|
}
|
|
|
|
if (likely(!srclen))
|
|
return bp - dst;
|
|
if (padding || srclen == 1)
|
|
return -1;
|
|
|
|
val = (base64_rev_tables[s[0]] << 12) | (base64_rev_tables[s[1]] << 6);
|
|
|
|
if (srclen == 2) {
|
|
if (val & 0x800003ff)
|
|
return -1;
|
|
*bp++ = val >> 10;
|
|
} else {
|
|
val |= base64_rev_tables[s[2]];
|
|
if (val & 0x80000003)
|
|
return -1;
|
|
*bp++ = val >> 10;
|
|
*bp++ = val >> 2;
|
|
}
|
|
return bp - dst;
|
|
}
|
|
EXPORT_SYMBOL_GPL(base64_decode);
|