bpf: Add LDX/STX/ST sanitize in jited BPF progs
Subsystems (6)
cover bpf: Add LDX/STX/ST sanitize in jited BPF progs
The verifier sometimes makes mistakes[1][2] that may be exploited to achieve arbitrary read/write. Currently, syzbot is continuously testing bpf, and can find memory issues in bpf syscalls, but it can hardly find mischecking/bugs in the verifier. We need runtime checks like KASAN in BPF programs for this. This patch series implements address sanitize in jited BPF progs for testing purpose, so that tools like syzbot can find interesting bugs in the verifier automatically by, if possible, generating and executing BPF programs that bypass the verifier but have memory issues, then triggering this sanitizing.
The idea is to dispatch read/write addr of a BPF program to the kernel functions that are instrumented by KASAN, to achieve indirect checking. Indirect checking is adopted because this is much simple, instrument direct checking like compilers makes the jit much more complex. The main step is: back up R0&R1 and store addr in R1, and then insert the checking function before load/store insns, during bpf_misc_fixup(), and finally in the jit stage, backup R1~R5 to make sure the checking funcs won't corrupt regs states. An extra Kconfig option is used to enable this, so normal use case won't be impacted at all.
Also, not all ldx/stx/st are instrumented. Insns rewrote by other fixup or conversion passes that use BPF_REG_AX are skipped, because that conflicts with us; insns whose access addr is specified by R10 are also skipped because they are trivial to verify.
Patch1 sanitizes st/stx insns, and Patch2 sanitizes ldx insns, Patch3 adds selftests for instrumentation in each possible case, and all new/existing selftests for the verifier can pass. Also, a BPF prog that also exploits CVE-2022-23222 to achieve OOB read is provided[3], this can be perfertly captured with this patch series.
I haven't found a better way to back up the regs before executing the checking functions, and have to store them on the stack. Comments and advice are surely welcome.
[1] http://bit.do/CVE-2021-3490
[2] http://bit.do/CVE-2022-23222
[3] OOB-read: https://pastebin.com/raw/Ee1Cw492
Hao Sun (3):
bpf: Sanitize STX/ST in jited BPF progs with KASAN
bpf: Sanitize LDX in jited BPF progs with KASAN selftests/bpf: Add tests for LDX/STX/ST sanitize
arch/x86/net/bpf_jit_comp.c | 34 ++ include/linux/bpf.h | 14 + kernel/bpf/Kconfig | 14 + kernel/bpf/verifier.c | 190 +++++++++++ .../selftests/bpf/verifier/sanitize_st_ldx.c | 323 ++++++++++++++++++ 5 files changed, 575 insertions(+) create mode 100644 tools/testing/selftests/bpf/verifier/sanitize_st_ldx.c
base-commit: 8a2162a9227dda936a21fe72014a9931a3853a7b
Signature · 1 line
2.38.1
PATCH 1/3 bpf: Sanitize STX/ST in jited BPF progs with KASAN
Make the verifier sanitize STX/ST insns in jited BPF programs by dispatching addr to kernel functions that are instrumented by KASAN.
Only STX/ST insns that aren't in patches added by other passes using REG_AX or dst_reg isn't R10 are sanitized. The former confilicts with us, the latter are trivial for the verifier to check, skip them to reduce the footprint.
The instrumentation is conducted in two places: fixup and jit. During fixup, R0 and R1 are backed up or exchanged with dst_reg, and the address to check is stored into R1, and the corresponding bpf_asan_storeN() is inserted. In jit, R1~R5 are pushed on stack before calling the sanitize function. The sanitize functions are instrumented with KASAN and they simply write to the target addr for certain bytes, KASAN conducts the actual checking. An extra Kconfig is used to enable this.
--- arch/x86/net/bpf_jit_comp.c | 32 +++++++++++ include/linux/bpf.h | 9 ++++ kernel/bpf/Kconfig | 14 +++++ kernel/bpf/verifier.c | 102 ++++++++++++++++++++++++++++++++++++ 4 files changed, 157 insertions(+)
arch/x86/net/bpf_jit_comp.c +32 -0
@@ -338,7 +338,39 @@ static int emit_patch(u8 **pprog, void *func, void *ip, u8 opcode)static int emit_call (u8 **pprog,void *func,void *ip) { +#ifdef CONFIG_BPF_PROG_KASAN +s64 offset; +u8 *prog = *pprog; +bool is_sanitize = + func == bpf_asan_store8 || func == bpf_asan_store16 || + func == bpf_asan_store32 || func == bpf_asan_store64; + +if (!is_sanitize) +return emit_patch (pprog, func, ip,0xE8 ); + +/* Six extra bytes from push insns */ + offset = func - (ip +X86_PATCH_SIZE +6 ); +BUG_ON (!is_simm32 (offset)); + +/* R1 has the addr to check, backup R1~R5 here, we don't +* have free regs during the fixup. +*/ +EMIT1 (0x57 );/* push rdi */ +EMIT1 (0x56 );/* push rsi */ +EMIT1 (0x52 );/* push rdx */ +EMIT1 (0x51 );/* push rcx */ +EMIT2 (0x41 ,0x50 );/* push r8 */ +EMIT1_off32 (0xE8 , offset); +EMIT2 (0x41 ,0x58 );/* pop r8 */ +EMIT1 (0x59 );/* pop rcx */ +EMIT1 (0x5a );/* pop rdx */ +EMIT1 (0x5e );/* pop rsi */ +EMIT1 (0x5f );/* pop rdi */ + *pprog = prog; +return 0 ; +#else return emit_patch (pprog, func, ip,0xE8 ); +#endif }static int emit_jump (u8 **pprog,void *func,void *ip)
include/linux/bpf.h +9 -0
@@ -2835,4 +2835,13 @@ static inline bool type_is_alloc(u32 type) return type & MEM_ALLOC; } +#ifdef CONFIG_BPF_PROG_KASAN + +u64 bpf_asan_store8 (u8 *addr); +u64 bpf_asan_store16 (u16 *addr); +u64 bpf_asan_store32 (u32 *addr); +u64 bpf_asan_store64 (u64 *addr); + +#endif /* CONFIG_BPF_PROG_KASAN */ +#endif /* _LINUX_BPF_H */
kernel/bpf/Kconfig +14 -0
@@ -99,4 +99,18 @@ config BPF_LSM If you are unsure how to answer this question, answer N. +config BPF_PROG_KASAN + bool "Enable BPF Program Address Sanitize" + depends on BPF_JIT + depends on KASAN + depends on X86_64 + help + Enables instrumentation on LDX/STX/ST insn to capture memory + access errors in BPF programs missed by the verifier. + + The actual check is conducted by KASAN, this feature presents + certain overhead, and should be used mainly by testing purpose. + + If you are unsure how to answer this question, answer N. + endmenu # "BPF subsystem"
kernel/bpf/verifier.c +102 -0
120 lines not on this page · raw message
Signature · 1 line
2.38.1
PATCH 2/3 bpf: Sanitize LDX in jited BPF progs with KASAN
In reply to Hao SunMake the verifier sanitize LDX insns in jited BPF programs, a little more complicated than STX/ST. The dst_reg and AX are free here, different insns that backup R0&R1 are inserted before calling the checking functions based on their relationships with dst_reg and src_reg, the checking funcs are then inserted, and finally regs are restored.
--- arch/x86/net/bpf_jit_comp.c | 4 +- include/linux/bpf.h | 5 +++ kernel/bpf/verifier.c | 88 +++++++++++++++++++++++++++++++++++++ 3 files changed, 96 insertions(+), 1 deletion(-)
arch/x86/net/bpf_jit_comp.c +3 -1
@@ -343,7 +343,9 @@ static int emit_call(u8 **pprog, void *func, void *ip)u8 *prog = *pprog;bool is_sanitize = func == bpf_asan_store8 || func == bpf_asan_store16 || - func == bpf_asan_store32 || func == bpf_asan_store64; + func == bpf_asan_store32 || func == bpf_asan_store64 || + func == bpf_asan_load8 || func == bpf_asan_load16 || + func == bpf_asan_load32 || func == bpf_asan_load64;if (!is_sanitize)return emit_patch (pprog, func, ip,0xE8 );
include/linux/bpf.h +5 -0
@@ -2842,6 +2842,11 @@ u64 bpf_asan_store16(u16 *addr);u64 bpf_asan_store32 (u32 *addr);u64 bpf_asan_store64 (u64 *addr); +u64 bpf_asan_load8 (u8 *addr); +u64 bpf_asan_load16 (u16 *addr); +u64 bpf_asan_load32 (u32 *addr); +u64 bpf_asan_load64 (u64 *addr); +#endif /* CONFIG_BPF_PROG_KASAN */ #endif /* _LINUX_BPF_H */
kernel/bpf/verifier.c +88 -0
100 lines not on this page · raw message
Signature · 1 line
2.38.1
PATCH 3/3 selftests/bpf: Add tests for LDX/STX/ST sanitize
In reply to Hao SunAdd tests for LDX/STX/ST instrumentation in each possible case. Four cases for STX/ST, include dst_reg equals to R0, R1, R10, other regs, respectively, ten cases for LDX. All new/existing selftests can pass.
A slab-out-of-bounds read report is also availble, which is achieved by exploiting CVE-2022-23222 and can be reproduced in Linux v5.10: https://pastebin.com/raw/Ee1Cw492.
--- .../selftests/bpf/verifier/sanitize_st_ldx.c | 323 ++++++++++++++++++ 1 file changed, 323 insertions(+) create mode 100644 tools/testing/selftests/bpf/verifier/sanitize_st_ldx.c
tools/testing/selftests/bpf/verifier/sanitize_st_ldx.c new file +323 -0
@@ -0,0 +1,323 @@ +#ifdef CONFIG_BPF_PROG_KASAN +{ + "sanitize stx: dst is R1", + .insns = { + BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_1, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 1), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, MAX_BPF_REG), + BPF_ST_MEM(BPF_DW, BPF_REG_1, -8, 1), + }, +}, +{ + "sanitize stx: dst is R0", + .insns = { + BPF_MOV64_REG(BPF_REG_0, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_0, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_ST_MEM(BPF_DW, BPF_REG_0, -8, 1), + }, +}, +{ + "sanitize stx: dst is R10", + .insns = { + BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_10, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 1), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .unexpected_insns = { + BPF_EMIT_CALL(INSN_IMM_MASK), + }, +}, +{ + "sanitize stx: dst is other regs", + .insns = { + BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_2, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 1), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_2), + BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), + BPF_MOV64_REG(BPF_REG_2, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_ST_MEM(BPF_DW, BPF_REG_2, -8, 1), + }, +}, +{ + "sanitize ldx: src is R1, dst is R0", + .insns = { + BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_1, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 1), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8), + }, +}, +{ + "sanitize ldx: src is R1, dst is R1", + .insns = { + BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_1, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_1, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_1, -8), + }, +}, +{ + "sanitize ldx: src is R1, dst is other regs", + .insns = { + BPF_MOV64_REG(BPF_REG_1, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_1, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_1, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_2, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_1, -8), + }, +}, +{ + "sanitize ldx: src is R0, dst is R1", + .insns = { + BPF_MOV64_REG(BPF_REG_0, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_0, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_0, -8), + }, +}, +{ + "sanitize ldx: src is R0, dst is R0", + .insns = { + BPF_MOV64_REG(BPF_REG_0, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_0, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 1), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, -8), + }, +}, +{ + "sanitize ldx: src is R0, dst is other regs", + .insns = { + BPF_MOV64_REG(BPF_REG_0, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_0, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_0, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_2, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_0, -8), + }, +}, +{ + "sanitize ldx: src is other regs, dst is R0", + .insns = { + BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_2, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 1, 1), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_2), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_2, -8), + }, +}, +{ + "sanitize ldx: src is other regs, dst is R1", + .insns = { + BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_2, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_2, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_1), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(BPF_REG_1, BPF_REG_2), + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_1, BPF_REG_2, -8), + }, +}, +{ + "sanitize ldx: src is other regs, dst is self", + .insns = { + BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_2, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_2, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_2), + BPF_MOV64_REG(BPF_REG_2, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_2), + BPF_MOV64_REG(BPF_REG_2, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_2, BPF_REG_2, -8), + }, +}, +{ + "sanitize ldx: src is other regs, dst is other regs", + .insns = { + BPF_MOV64_REG(BPF_REG_2, BPF_REG_10), + BPF_ST_MEM(BPF_DW, BPF_REG_2, -8, 1), + BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_2, -8), + BPF_JMP_IMM(BPF_JEQ, BPF_REG_3, 1, 2), + BPF_MOV64_IMM(BPF_REG_0, 2), + BPF_EXIT_INSN(), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_3), + BPF_EXIT_INSN(), + }, + .result = ACCEPT, + .retval = 1, + .expected_insns = { + BPF_MOV64_REG(MAX_BPF_REG, BPF_REG_1), + BPF_MOV64_REG(BPF_REG_1, BPF_REG_2), + BPF_MOV64_REG(BPF_REG_3, BPF_REG_0), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8), + BPF_EMIT_CALL(INSN_IMM_MASK), + BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8), + BPF_MOV64_REG(BPF_REG_0, BPF_REG_3), + BPF_MOV64_REG(BPF_REG_1, MAX_BPF_REG), + BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_2, -8), + }, +}, +#endif /* CONFIG_BPF_PROG_KASAN */
Signature · 1 line
2.38.1
Daniel Borkmann
maintainerQuoted 10 lines · Hao Sun
The verifier sometimes makes mistakes[1][2] that may be exploited to achieve arbitrary read/write. Currently, syzbot is continuously testing bpf, and can find memory issues in bpf syscalls, but it can hardly find mischecking/bugs in the verifier. We need runtime checks like KASAN in BPF programs for this. This patch series implements address sanitize in jited BPF progs for testing purpose, so that tools like syzbot can find interesting bugs in the verifier automatically by, if possible, generating and executing BPF programs that bypass the verifier but have memory issues, then triggering this sanitizing.
Quoted 9 lines
The idea is to dispatch read/write addr of a BPF program to the kernel functions that are instrumented by KASAN, to achieve indirect checking. Indirect checking is adopted because this is much simple, instrument direct checking like compilers makes the jit much more complex. The main step is: back up R0&R1 and store addr in R1, and then insert the checking function before load/store insns, during
bpf_misc_fixup(), and finally in the jit stage, backup R1~R5 to make sure the checking funcs won't corrupt regs states. An extraKconfigoption is used to enable this, so normal use case won't be impacted at all.
Thanks for looking into this! It's a bit unfortunate that this will need changes in every BPF JIT. Have you thought about a generic solution which would not require changes in JITs? Given this is for debugging and finding mischecking/bugs in the verifier, can't we reuse interpreter for this and only implement it there? I would be curious if we could achieve the same result from [3] with such approach.
Quoted 30 lines
Also, not all ldx/stx/st are instrumented. Insns rewrote by other fixup or conversion passes that use
BPF_REG_AXare skipped, because that conflicts with us; insns whose access addr is specified by R10 are also skipped because they are trivial to verify.Patch1 sanitizes st/stx insns, and Patch2 sanitizes ldx insns, Patch3 adds selftests for instrumentation in each possible case, and all new/existing selftests for the verifier can pass. Also, a BPF prog that also exploits CVE-2022-23222 to achieve OOB read is provided[3], this can be perfertly captured with this patch series.
I haven't found a better way to back up the regs before executing the checking functions, and have to store them on the stack. Comments and advice are surely welcome.
[1] http://bit.do/CVE-2021-3490
[2] http://bit.do/CVE-2022-23222
[3] OOB-read: https://pastebin.com/raw/Ee1Cw492Hao Sun (3):
bpf: Sanitize STX/ST in jited BPF progs with KASAN
bpf: Sanitize LDX in jited BPF progs with KASAN selftests/bpf: Add tests for LDX/STX/ST sanitizearch/x86/net/bpf_jit_comp.c | 34 ++ include/linux/bpf.h | 14 + kernel/bpf/Kconfig | 14 + kernel/bpf/verifier.c | 190 +++++++++++ .../selftests/bpf/verifier/sanitize_st_ldx.c | 323 ++++++++++++++++++ 5 files changed, 575 insertions(+)
Quoted 5 lines
create mode 100644
tools/testing/selftests/bpf/verifier/sanitize_st_ldx.cbase-commit:
8a2162a9227dda936a21fe72014a9931a3853a7b
Thanks,
Daniel
Quoted 22 lines · Daniel Borkmann <[email protected]> 于2022年11月24日周四 07:41写道:
Quoted 10 lines · Hao Sun
The verifier sometimes makes mistakes[1][2] that may be exploited to achieve arbitrary read/write. Currently, syzbot is continuously testing bpf, and can find memory issues in bpf syscalls, but it can hardly find mischecking/bugs in the verifier. We need runtime checks like KASAN in BPF programs for this. This patch series implements address sanitize in jited BPF progs for testing purpose, so that tools like syzbot can find interesting bugs in the verifier automatically by, if possible, generating and executing BPF programs that bypass the verifier but have memory issues, then triggering this sanitizing.
Quoted 9 lines
The idea is to dispatch read/write addr of a BPF program to the kernel functions that are instrumented by KASAN, to achieve indirect checking. Indirect checking is adopted because this is much simple, instrument direct checking like compilers makes the jit much more complex. The main step is: back up R0&R1 and store addr in R1, and then insert the checking function before load/store insns, during
bpf_misc_fixup(), and finally in the jit stage, backup R1~R5 to make sure the checking funcs won't corrupt regs states. An extraKconfigoption is used to enable this, so normal use case won't be impacted at all.
Quoted 7 lines
Thanks for looking into this! It's a bit unfortunate that this will need changes in every BPF JIT. Have you thought about a generic solution which would not require changes in JITs? Given this is for debugging and finding mischecking/bugs in the verifier, can't we reuse interpreter for this and only implement it there? I would be curious if we could achieve the same result from [3] with such approach.
Hi Daniel,
Thanks for taking a look. The reason I choose to do this in jited progs is because JIT is used in most real cases, so does testing/fuzzing, e.g., syzbot test BPF with JIT_ALWAYS_ON=y. Also, a BPF program generated by fuzzers or other tools is likely need to be run hundred times with random inputs to trigger potential issues in it and be captured by sanitize, so JIT makes this much faster.
We don't need changes in every BPF JIT I believe, supporting X86_64 and Arm64 would be enough, and the only thing need to be done there is to backup regs on stack before calling checking functions. Also, I'm wondering if anyone knows how to better make sure the checking function won't corrupt scratch regs' states, e.g., a flag to force compiler to push scratch regs before using them, during gen code for those funcs. If this is feasible, the changes to JIT can be completely removed, and fixup in the verifier would be enough.
Regards
Hao
Quoted 38 lines
Quoted 30 lines
Also, not all ldx/stx/st are instrumented. Insns rewrote by other fixup or conversion passes that use
BPF_REG_AXare skipped, because that conflicts with us; insns whose access addr is specified by R10 are also skipped because they are trivial to verify.Patch1 sanitizes st/stx insns, and Patch2 sanitizes ldx insns, Patch3 adds selftests for instrumentation in each possible case, and all new/existing selftests for the verifier can pass. Also, a BPF prog that also exploits CVE-2022-23222 to achieve OOB read is provided[3], this can be perfertly captured with this patch series.
I haven't found a better way to back up the regs before executing the checking functions, and have to store them on the stack. Comments and advice are surely welcome.
[1] http://bit.do/CVE-2021-3490
[2] http://bit.do/CVE-2022-23222
[3] OOB-read: https://pastebin.com/raw/Ee1Cw492Hao Sun (3):
bpf: Sanitize STX/ST in jited BPF progs with KASAN
bpf: Sanitize LDX in jited BPF progs with KASAN selftests/bpf: Add tests for LDX/STX/ST sanitizearch/x86/net/bpf_jit_comp.c | 34 ++ include/linux/bpf.h | 14 + kernel/bpf/Kconfig | 14 + kernel/bpf/verifier.c | 190 +++++++++++ .../selftests/bpf/verifier/sanitize_st_ldx.c | 323 ++++++++++++++++++ 5 files changed, 575 insertions(+)Quoted 5 lines
create mode 100644
tools/testing/selftests/bpf/verifier/sanitize_st_ldx.cbase-commit:
8a2162a9227dda936a21fe72014a9931a3853a7bThanks,
Daniel
Quoted 41 lines · Hao Sun <[email protected]> 于2022年11月24日周四 11:05写道:
Quoted 22 lines · Daniel Borkmann <[email protected]> 于2022年11月24日周四 07:41写道:
Quoted 10 lines · Hao Sun
The verifier sometimes makes mistakes[1][2] that may be exploited to achieve arbitrary read/write. Currently, syzbot is continuously testing bpf, and can find memory issues in bpf syscalls, but it can hardly find mischecking/bugs in the verifier. We need runtime checks like KASAN in BPF programs for this. This patch series implements address sanitize in jited BPF progs for testing purpose, so that tools like syzbot can find interesting bugs in the verifier automatically by, if possible, generating and executing BPF programs that bypass the verifier but have memory issues, then triggering this sanitizing.
Quoted 9 lines
The idea is to dispatch read/write addr of a BPF program to the kernel functions that are instrumented by KASAN, to achieve indirect checking. Indirect checking is adopted because this is much simple, instrument direct checking like compilers makes the jit much more complex. The main step is: back up R0&R1 and store addr in R1, and then insert the checking function before load/store insns, during
bpf_misc_fixup(), and finally in the jit stage, backup R1~R5 to make sure the checking funcs won't corrupt regs states. An extraKconfigoption is used to enable this, so normal use case won't be impacted at all.Quoted 7 lines
Thanks for looking into this! It's a bit unfortunate that this will need changes in every BPF JIT. Have you thought about a generic solution which would not require changes in JITs? Given this is for debugging and finding mischecking/bugs in the verifier, can't we reuse interpreter for this and only implement it there? I would be curious if we could achieve the same result from [3] with such approach.
Hi Daniel,
Thanks for taking a look. The reason I choose to do this in jited progs is because JIT is used in most real cases, so does testing/fuzzing, e.g., syzbot test BPF with JIT_ALWAYS_ON=y. Also, a BPF program generated by fuzzers or other tools is likely need to be run hundred times with random inputs to trigger potential issues in it and be captured by sanitize, so JIT makes this much faster.
Quoted 9 lines
We don't need changes in every BPF JIT I believe, supporting
X86_64and Arm64 would be enough, and the only thing need to be done there is to backup regs on stack before calling checking functions. Also, I'm wondering if anyone knows how to better make sure the checking function won't corrupt scratch regs' states, e.g., a flag to force compiler to push scratch regs before using them, during gen code for those funcs. If this is feasible, the changes to JIT can be completely removed, and fixup in the verifier would be enough.
I think we can extend BPF prog's stack size in this mode, then backup all the scratch regs to those free space. This way, everything just happens in BPF insn level, we don't need to change JIT at all.
I will send patch v2 for this.
Quoted 41 lines
Regards
HaoQuoted 38 lines
Quoted 30 lines
Also, not all ldx/stx/st are instrumented. Insns rewrote by other fixup or conversion passes that use
BPF_REG_AXare skipped, because that conflicts with us; insns whose access addr is specified by R10 are also skipped because they are trivial to verify.Patch1 sanitizes st/stx insns, and Patch2 sanitizes ldx insns, Patch3 adds selftests for instrumentation in each possible case, and all new/existing selftests for the verifier can pass. Also, a BPF prog that also exploits CVE-2022-23222 to achieve OOB read is provided[3], this can be perfertly captured with this patch series.
I haven't found a better way to back up the regs before executing the checking functions, and have to store them on the stack. Comments and advice are surely welcome.
[1] http://bit.do/CVE-2021-3490
[2] http://bit.do/CVE-2022-23222
[3] OOB-read: https://pastebin.com/raw/Ee1Cw492Hao Sun (3):
bpf: Sanitize STX/ST in jited BPF progs with KASAN
bpf: Sanitize LDX in jited BPF progs with KASAN selftests/bpf: Add tests for LDX/STX/ST sanitizearch/x86/net/bpf_jit_comp.c | 34 ++ include/linux/bpf.h | 14 + kernel/bpf/Kconfig | 14 + kernel/bpf/verifier.c | 190 +++++++++++ .../selftests/bpf/verifier/sanitize_st_ldx.c | 323 ++++++++++++++++++ 5 files changed, 575 insertions(+)Quoted 5 lines
create mode 100644
tools/testing/selftests/bpf/verifier/sanitize_st_ldx.cbase-commit:
8a2162a9227dda936a21fe72014a9931a3853a7bThanks,
Daniel