bpf: Fix abs(INT_MIN) undefined behavior in interpreter sdiv/smod
Subsystems (4)
v5 cover bpf: Fix abs(INT_MIN) undefined behavior in interpreter sdiv/smod
The BPF interpreter's signed 32-bit division and modulo handlers use abs() on s32 operands, which is undefined for S32_MIN. This causes the interpreter to compute wrong results, creating a mismatch with the verifier's range tracking.
For example, INT_MIN / 2 returns 0x40000000 instead of the correct 0xC0000000. The verifier tracks the correct range, so a crafted BPF program can exploit the mismatch for out-of-bounds map value access (confirmed by KASAN).
Patch 1 introduces abs_s32() which handles S32_MIN correctly and replaces all 8 abs((s32)...) call sites. s32 is the only affected case -- the s64 handlers do not use abs().
Patch 2 adds selftests covering sdiv32 and smod32 with INT_MIN dividend to prevent regression.
Changes since v4:
- Renamed __safe_abs32() to abs_s32() and dropped inline keyword per Alexei Starovoitov's feedback
Changes since v3:
- Fixed stray blank line deletion in the file header
- Improved comment per Yonghong Song's suggestion
- Added JIT vs interpreter context to selftest commit message
Changes since v2:
- Simplified to use -(u32)x per Mykyta Yatsenko's suggestion
Changes since v1:
- Moved helper above kerneldoc comment block to fix build warnings
Jenny Guanni Qu (2):
bpf: Fix undefined behavior in interpreter sdiv/smod for INT_MIN selftests/bpf: Add tests for sdiv32/smod32 with INT_MIN dividend
kernel/bpf/core.c | 22 ++++--- .../selftests/bpf/progs/verifier_sdiv.c | 58 +++++++++++++++++++ 2 files changed, 72 insertions(+), 8 deletions(-)
Signature · 1 line
2.34.1
PATCH v5 1/2 bpf: Fix undefined behavior in interpreter sdiv/smod for INT_MIN
The BPF interpreter's signed 32-bit division and modulo handlers use the kernel abs() macro on s32 operands. The abs() macro documentation (include/linux/math.h) explicitly states the result is undefined when the input is the type minimum. When DST contains S32_MIN (0x80000000), abs((s32)DST) triggers undefined behavior and returns S32_MIN unchanged on arm64/x86. This value is then sign-extended to u64 as 0xFFFFFFFF80000000, causing do_div() to compute the wrong result.
The verifier's abstract interpretation (scalar32_min_max_sdiv) computes the mathematically correct result for range tracking, creating a verifier/interpreter mismatch that can be exploited for out-of-bounds map value access.
Introduce abs_s32() which handles S32_MIN correctly by casting to u32 before negating, avoiding signed overflow entirely. Replace all 8 abs((s32)...) call sites in the interpreter's sdiv32/smod32 handlers.
s32 is the only affected case -- the s64 division/modulo handlers do not use abs().
--- kernel/bpf/core.c | 22 ++++++++++++++-------- 1 file changed, 14 insertions(+), 8 deletions(-)
kernel/bpf/core.c +14 -8
@@ -1736,6 +1736,12 @@ bool bpf_opcode_in_insntable(u8 code) }#ifndef CONFIG_BPF_JIT_ALWAYS_ON +/* Absolute value of s32 without undefined behavior for S32_MIN */ +static u32 abs_s32 (s32 x) +{ +return x >=0 ? (u32 )x : -(u32 )x; +} +/** * ___bpf_prog_run - run eBPF program on a given context * @regs: is the array of MAX_BPF_EXT_REG eBPF pseudo-registers
@@ -1900,8 +1906,8 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn)DST =do_div (AX , (u32 )SRC );break ;case 1 : -AX =abs ((s32 )DST ); -AX =do_div (AX ,abs ((s32 )SRC )); +AX =abs_s32 ((s32 )DST ); +AX =do_div (AX ,abs_s32 ((s32 )SRC ));if ((s32 )DST <0 )DST = (u32)-AX ;else
@@ -1928,8 +1934,8 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn)DST =do_div (AX , (u32 )IMM );break ;case 1 : -AX =abs ((s32 )DST ); -AX =do_div (AX ,abs ((s32 )IMM )); +AX =abs_s32 ((s32 )DST ); +AX =do_div (AX ,abs_s32 ((s32 )IMM ));if ((s32 )DST <0 )DST = (u32)-AX ;else
@@ -1955,8 +1961,8 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn)DST = (u32 )AX ;break ;case 1 : -AX =abs ((s32 )DST ); -do_div (AX ,abs ((s32 )SRC )); +AX =abs_s32 ((s32 )DST ); +do_div (AX ,abs_s32 ((s32 )SRC ));if (((s32 )DST <0 ) == ((s32 )SRC <0 ))DST = (u32 )AX ;else
@@ -1982,8 +1988,8 @@ static u64 ___bpf_prog_run(u64 *regs, const struct bpf_insn *insn)DST = (u32 )AX ;break ;case 1 : -AX =abs ((s32 )DST ); -do_div (AX ,abs ((s32 )IMM )); +AX =abs_s32 ((s32 )DST ); +do_div (AX ,abs_s32 ((s32 )IMM ));if (((s32 )DST <0 ) == ((s32 )IMM <0 ))DST = (u32 )AX ;else
Signature · 1 line
2.34.1
PATCH v5 2/2 selftests/bpf: Add tests for sdiv32/smod32 with INT_MIN dividend
In reply to Jenny Guanni QuAdd tests to verify that signed 32-bit division and modulo operations produce correct results when the dividend is INT_MIN (0x80000000).
The bug fixed in the previous commit only affects the BPF interpreter path. When JIT is enabled (the default on most architectures), the native CPU division instruction produces the correct result and these tests pass regardless. With bpf_jit_enable=0, the interpreter is used and without the previous fix, INT_MIN / 2 incorrectly returns 0x40000000 instead of 0xC0000000 due to abs(S32_MIN) undefined behavior, causing these tests to fail.
Test cases:
- SDIV32 INT_MIN / 2 = -1073741824 (imm and reg divisor)
- SMOD32 INT_MIN % 2 = 0 (positive and negative divisor)
--- .../selftests/bpf/progs/verifier_sdiv.c | 58 +++++++++++++++++++ 1 file changed, 58 insertions(+)
tools/testing/selftests/bpf/progs/verifier_sdiv.c +58 -0
@@ -1209,6 +1209,64 @@ __naked void smod32_ri_divisor_neg_1(void) : __clobber_all); } +SEC("socket") +__description("SDIV32, INT_MIN divided by 2, imm") +__success __success_unpriv __retval(-1073741824) +__naked void sdiv32_int_min_div_2_imm (void ) +{ + asmvolatile (" \ +w0 = %[int_min]; \ +w0 s/= 2; \ +exit; \ +" : + : __imm_const(int_min, INT_MIN) + : __clobber_all); +} + +SEC("socket") +__description("SDIV32, INT_MIN divided by 2, reg") +__success __success_unpriv __retval(-1073741824) +__naked void sdiv32_int_min_div_2_reg (void ) +{ + asmvolatile (" \ +w0 = %[int_min]; \ +w1 = 2; \ +w0 s/= w1; \ +exit; \ +" : + : __imm_const(int_min, INT_MIN) + : __clobber_all); +} + +SEC("socket") +__description("SMOD32, INT_MIN modulo 2, imm") +__success __success_unpriv __retval(0) +__naked void smod32_int_min_mod_2_imm(void) +{ + asmvolatile (" \ +w0 = %[int_min]; \ +w0 s%%= 2; \ +exit; \ +" : + : __imm_const(int_min, INT_MIN) + : __clobber_all); +} + +SEC("socket") +__description("SMOD32, INT_MIN modulo -2, imm") +__success __success_unpriv __retval(0) +__naked void smod32_int_min_mod_neg2_imm(void) +{ + asmvolatile (" \ +w0 = %[int_min]; \ +w0 s%%= -2; \ +exit; \ +" : + : __imm_const(int_min, INT_MIN) + : __clobber_all); +} + +#else SEC ("socket" )
Signature · 1 line
2.34.1
This series was applied to bpf/bpf.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf.git (master)
by Alexei Starovoitov <[email protected]>:
Quoted 11 lines · On Wed, 11 Mar 2026 01:11:14 +0000 you wrote:
The BPF interpreter's signed 32-bit division and modulo handlers use
abs()on s32 operands, which is undefined forS32_MIN. This causes the interpreter to compute wrong results, creating a mismatch with the verifier's range tracking.For example,
INT_MIN/ 2 returns0x40000000instead of the correct0xC0000000. The verifier tracks the correct range, so a crafted BPF program can exploit the mismatch for out-of-bounds map value access (confirmed by KASAN).[...]
Here is the summary with links:
- [v5,1/2] bpf: Fix undefined behavior in interpreter sdiv/smod for INT_MIN
https://git.kernel.org/bpf/bpf/c/c77b30bd1dcb - [v5,2/2] selftests/bpf: Add tests for sdiv32/smod32 with INT_MIN dividend https://git.kernel.org/bpf/bpf/c/4ac95c65efea
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html