bpf: prevent userspace memory access
v6 cover bpf: prevent userspace memory access
V5: https://lore.kernel.org/bpf/[email protected]/
Changes in V6:
- Disable the verifier's instrumentation in x86-64 and update the JIT to take care of vsyscall page in addition to userspace addresses.
- Update bpf_testmod to test for vsyscall addresses.
V4: https://lore.kernel.org/bpf/[email protected]/
Changes in V5:
- Use TASK_SIZE_MAX + PAGE_SIZE, VSYSCALL_ADDR as userspace boundary in x86-64 JIT.
- Added Acked-by: Ilya Leoshkevich <[email protected]>
V3: https://lore.kernel.org/bpf/[email protected]/
Changes in V4:
- Disable this feature on architectures that don't define CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE.
- By doing the above, we don't need anything explicitly for s390x.
V2: https://lore.kernel.org/bpf/[email protected]/
Changes in V3:
- Return 0 from bpf_arch_uaddress_limit() in disabled case because it returns u64.
- Modify the check in verifier to no do instrumentation when uaddress_limit is 0.
V1: https://lore.kernel.org/bpf/[email protected]/
Changes in V2:
- Disable this feature on s390x.
With BPF_PROBE_MEM, BPF allows de-referencing an untrusted pointer. To thwart invalid memory accesses, the JITs add an exception table entry for all such accesses. But in case the src_reg + offset is a userspace address, the BPF program might read that memory if the user has mapped it.
x86-64 JIT already instruments the BPF_PROBE_MEM based loads with checks to skip loads from userspace addresses, but is doesn't check for vsyscall page because it falls in the kernel address space but is considered a userspace page. The second patch in this series fixes the x86-64 JIT to also skip loads from the vsyscall page. The last patch updates the bpf_testmod so this address can be checked as part of the selftests.
Other architectures don't have the complexity of the vsyscall address and just need to skip loads from the userspace. To make this more scalable and robust, the verifier is updated in the first patch to instrument BPF_PROBE_MEM to skip loads from the userspace addresses.
Puranjay Mohan (3):
bpf: verifier: prevent userspace memory access bpf, x86: Fix PROBE_MEM runtime load check selftests/bpf: Test PROBE_MEM of VSYSCALL_ADDR on x86-64
arch/x86/net/bpf_jit_comp.c | 63 +++++++++---------- include/linux/filter.h | 1 + kernel/bpf/core.c | 9 +++ kernel/bpf/verifier.c | 30 +++++++++ .../selftests/bpf/bpf_testmod/bpf_testmod.c | 3 + 5 files changed, 74 insertions(+), 32 deletions(-)
Signature · 1 line
2.40.1
PATCH v6 1/3 bpf: verifier: prevent userspace memory access
From: Puranjay Mohan <[email protected]>
With BPF_PROBE_MEM, BPF allows de-referencing an untrusted pointer. To thwart invalid memory accesses, the JITs add an exception table entry for all such accesses. But in case the src_reg + offset is a userspace address, the BPF program might read that memory if the user has mapped it.
Make the verifier add guard instructions around such memory accesses and skip the load if the address falls into the userspace region.
The JITs need to implement bpf_arch_uaddress_limit() to define where the userspace addresses end for that architecture or TASK_SIZE is taken as default.
The implementation is as follows:
REG_AX = SRC_REG
if(offset)
REG_AX += offset; REG_AX >>= 32; if (REG_AX <= (uaddress_limit >> 32)) DST_REG = 0; else DST_REG = *(size *)(SRC_REG + offset);
Comparing just the upper 32 bits of the load address with the upper 32 bits of uaddress_limit implies that the values are being aligned down to a 4GB boundary before comparison.
The above means that all loads with address <= uaddress_limit + 4GB are skipped. This is acceptable because there is a large hole (much larger than 4GB) between userspace and kernel space memory, therefore a correctly functioning BPF program should not access this 4GB memory above the userspace.
Let's analyze what this patch does to the following fentry program dereferencing an untrusted pointer:
SEC("fentry/tcp_v4_connect")
int BPF_PROG(fentry_tcp_v4_connect, struct sock *sk)
{
*(volatile long *)sk;
return 0;
} BPF Program before | BPF Program after
------------------ | ----------------- 0: (79) r1 = *(u64 *)(r1 +0) 0: (79) r1 = *(u64 *)(r1 +0)
-----------------------------------------------------------------------
1: (79) r1 = *(u64 *)(r1 +0) --\ 1: (bf) r11 = r1
----------------------------\ \ 2: (77) r11 >>= 32
2: (b7) r0 = 0 \ \ 3: (b5) if r11 <= 0x8000 goto pc+2
3: (95) exit \ \-> 4: (79) r1 = *(u64 *)(r1 +0)
\ 5: (05) goto pc+1
\ 6: (b7) r1 = 0
\--------------------------------------
7: (b7) r0 = 0
8: (95) exitAs you can see from above, in the best case (off=0), 5 extra instructions are emitted.
Now, we analyze the same program after it has gone through the JITs of ARM64 and RISC-V architectures. We follow the single load instruction that has the untrusted pointer and see what instrumentation has been added around it.
x86-64 JIT
==========
JIT's Instrumentation
(upstream)
---------------------0: nopl 0x0(%rax,%rax,1) 5: xchg %ax,%ax 7: push %rbp 8: mov %rsp,%rbp b: mov 0x0(%rdi),%rdi --------------------------------- f: movabs $0x800000000000,%r11 19: cmp %r11,%rdi 1c: jb 0x000000000000002a 1e: mov %rdi,%r11 21: add $0x0,%r11 28: jae 0x000000000000002e 2a: xor %edi,%edi 2c: jmp 0x0000000000000032 2e: mov 0x0(%rdi),%rdi --------------------------------- 32: xor %eax,%eax 34: leave 35: ret
The x86-64 JIT already emits some instructions to protect against user memory access. This patch doesn't make any changes for the x86-64 JIT.
ARM64 JIT
=========
No Intrumentation Verifier's Instrumentation
(upstream) (This patch)
----------------- --------------------------
0: add x9, x30, #0x0 0: add x9, x30, #0x0
4: nop 4: nop
8: paciasp 8: paciasp
c: stp x29, x30, [sp, #-16]! c: stp x29, x30, [sp, #-16]!
10: mov x29, sp 10: mov x29, sp
14: stp x19, x20, [sp, #-16]! 14: stp x19, x20, [sp, #-16]!
18: stp x21, x22, [sp, #-16]! 18: stp x21, x22, [sp, #-16]!
1c: stp x25, x26, [sp, #-16]! 1c: stp x25, x26, [sp, #-16]!
20: stp x27, x28, [sp, #-16]! 20: stp x27, x28, [sp, #-16]!
24: mov x25, sp 24: mov x25, sp
28: mov x26, #0x0 28: mov x26, #0x0
2c: sub x27, x25, #0x0 2c: sub x27, x25, #0x0
30: sub sp, sp, #0x0 30: sub sp, sp, #0x0
34: ldr x0, [x0] 34: ldr x0, [x0]
--------------------------------------------------------------------------------
38: ldr x0, [x0] ----------\ 38: add x9, x0, #0x0
-----------------------------------\\ 3c: lsr x9, x9, #32
3c: mov x7, #0x0 \\ 40: cmp x9, #0x10, lsl #12
40: mov sp, sp \\ 44: b.ls 0x0000000000000050
44: ldp x27, x28, [sp], #16 \\--> 48: ldr x0, [x0]
48: ldp x25, x26, [sp], #16 \ 4c: b 0x0000000000000054
4c: ldp x21, x22, [sp], #16 \ 50: mov x0, #0x0
50: ldp x19, x20, [sp], #16 \---------------------------------------
54: ldp x29, x30, [sp], #16 54: mov x7, #0x0
58: add x0, x7, #0x0 58: mov sp, sp
5c: autiasp 5c: ldp x27, x28, [sp], #16
60: ret 60: ldp x25, x26, [sp], #16
64: nop 64: ldp x21, x22, [sp], #16
68: ldr x10, 0x0000000000000070 68: ldp x19, x20, [sp], #16
6c: br x10 6c: ldp x29, x30, [sp], #16
70: add x0, x7, #0x0
74: autiasp
78: ret
7c: nop
80: ldr x10, 0x0000000000000088
84: br x10There are 6 extra instructions added in ARM64 in the best case. This will become 7 in the worst case (off != 0).
RISC-V JIT (RISCV_ISA_C Disabled)
==========
No Intrumentation Verifier's Instrumentation
(upstream) (This patch)
----------------- --------------------------
0: nop 0: nop
4: nop 4: nop
8: li a6, 33 8: li a6, 33
c: addi sp, sp, -16 c: addi sp, sp, -16
10: sd s0, 8(sp) 10: sd s0, 8(sp)
14: addi s0, sp, 16 14: addi s0, sp, 16
18: ld a0, 0(a0) 18: ld a0, 0(a0)
---------------------------------------------------------------
1c: ld a0, 0(a0) --\ 1c: mv t0, a0
--------------------------\ \ 20: srli t0, t0, 32
20: li a5, 0 \ \ 24: lui t1, 4096
24: ld s0, 8(sp) \ \ 28: sext.w t1, t1
28: addi sp, sp, 16 \ \ 2c: bgeu t1, t0, 12
2c: sext.w a0, a5 \ \--> 30: ld a0, 0(a0)
30: ret \ 34: j 8
\ 38: li a0, 0
\------------------------------
3c: li a5, 0
40: ld s0, 8(sp)
44: addi sp, sp, 16
48: sext.w a0, a5
4c: retThere are 7 extra instructions added in RISC-V.
--- arch/x86/net/bpf_jit_comp.c | 6 ++++++ include/linux/filter.h | 1 + kernel/bpf/core.c | 9 +++++++++ kernel/bpf/verifier.c | 30 ++++++++++++++++++++++++++++++ 4 files changed, 46 insertions(+)
arch/x86/net/bpf_jit_comp.c +6 -0
@@ -3473,3 +3473,9 @@ bool bpf_jit_supports_ptr_xchg(void) {return true; } + +/* x86-64 JIT emits its own code to filter user addresses so return 0 here */ +u64 bpf_arch_uaddress_limit (void ) +{ +return 0 ; +}
include/linux/filter.h +1 -0
@@ -963,6 +963,7 @@ bool bpf_jit_supports_far_kfunc_call(void);bool bpf_jit_supports_exceptions (void );bool bpf_jit_supports_ptr_xchg (void );bool bpf_jit_supports_arena (void ); +u64 bpf_arch_uaddress_limit (void );void arch_bpf_stack_walk (bool (*consume_fn)(void *cookie,u64 ip,u64 sp,u64 bp),void *cookie);bool bpf_helper_changes_pkt_data (void *func);
kernel/bpf/core.c +9 -0
@@ -2942,6 +2942,15 @@ bool __weak bpf_jit_supports_arena(void)return false; } +u64 __weak bpf_arch_uaddress_limit (void ) +{ +#if defined(CONFIG_64BIT ) && defined(CONFIG_ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE ) +return TASK_SIZE ; +#else +return 0 ; +#endif +} +/* Return TRUE if the JIT backend satisfies the following two conditions: * 1) JIT backend supports atomic_xchg() on pointer-sized words. * 2) Under the specific arch, the implementation of xchg() is the same
kernel/bpf/verifier.c +30 -0
@@ -19675,6 +19675,36 @@ static int do_misc_fixups(struct bpf_verifier_env *env) goto next_insn; } +/* Make it impossible to de-reference a userspace address */ +if (BPF_CLASS (insn->code) ==BPF_LDX && + (BPF_MODE (insn->code) ==BPF_PROBE_MEM || +BPF_MODE (insn->code) ==BPF_PROBE_MEMSX )) { +struct bpf_insn *patch = &insn_buf[0 ]; +u64 uaddress_limit =bpf_arch_uaddress_limit (); + +if (!uaddress_limit) + goto next_insn; + + *patch++ =BPF_MOV64_REG (BPF_REG_AX , insn->src_reg); +if (insn->off) + *patch++ =BPF_ALU64_IMM (BPF_ADD ,BPF_REG_AX , insn->off); + *patch++ =BPF_ALU64_IMM (BPF_RSH ,BPF_REG_AX ,32 ); + *patch++ =BPF_JMP_IMM (BPF_JLE ,BPF_REG_AX , uaddress_limit >>32 ,2 ); + *patch++ = *insn; + *patch++ =BPF_JMP_IMM (BPF_JA ,0 ,0 ,1 ); + *patch++ =BPF_MOV64_IMM (insn->dst_reg,0 ); + + cnt = patch - insn_buf; + new_prog =bpf_patch_insn_data (env, i + delta, insn_buf, cnt); +if (!new_prog) +return -ENOMEM ; + + delta += cnt -1 ; + env->prog = prog = new_prog; + insn = new_prog->insnsi + i + delta; + goto next_insn; + } +/* Implement LD_ABS and LD_IND with a rewrite, if supported by the program type. */ if (BPF_CLASS(insn->code) == BPF_LD && (BPF_MODE(insn->code) == BPF_ABS ||
Signature · 1 line
2.40.1
PATCH v6 2/3 bpf, x86: Fix PROBE_MEM runtime load check
In reply to Puranjay MohanWhen a load is marked PROBE_MEM - e.g. due to PTR_UNTRUSTED access - the address being loaded from is not necessarily valid. The BPF jit sets up exception handlers for each such load which catch page faults and 0 out the destination register.
If the address for the load is outside kernel address space, the load will escape the exception handling and crash the kernel. To prevent this from happening, the emits some instruction to verify that addr is > end of userspace addresses.
x86 has a legacy vsyscall ABI where a page at address 0xffffffffff600000 is mapped with user accessible permissions. The addresses in this page are considered userspace addresses by the fault handler. Therefore, a BPF program accessing this page will crash the kernel.
This patch fixes the runtime checks to also check that the PROBE_MEM address is below VSYSCALL_ADDR.
Example BPF program:
SEC("fentry/tcp_v4_connect")
int BPF_PROG(fentry_tcp_v4_connect, struct sock *sk)
{
*(volatile unsigned long *)&sk->sk_tsq_flags;
return 0;}
BPF Assembly:
0: (79) r1 = *(u64 *)(r1 +0)
1: (79) r1 = *(u64 *)(r1 +344)
2: (b7) r0 = 0
3: (95) exit
x86-64 JIT
==========
BEFORE AFTER
------ ----- 0: nopl 0x0(%rax,%rax,1) 0: nopl 0x0(%rax,%rax,1)
5: xchg %ax,%ax 5: xchg %ax,%ax
7: push %rbp 7: push %rbp
8: mov %rsp,%rbp 8: mov %rsp,%rbp
b: mov 0x0(%rdi),%rdi b: mov 0x0(%rdi),%rdi
-------------------------------------------------------------------------------
f: movabs $0x100000000000000,%r11 f: movabs $0xffffffffff600000,%r10
19: add $0x2a0,%rdi 19: mov %rdi,%r11
20: cmp %r11,%rdi 1c: add $0x2a0,%r11
23: jae 0x0000000000000029 23: sub %r10,%r11
25: xor %edi,%edi 26: movabs $0x100000000a00000,%r10
27: jmp 0x000000000000002d 30: cmp %r10,%r11
29: mov 0x0(%rdi),%rdi 33: ja 0x0000000000000039
--------------------------------\ 35: xor %edi,%edi
2d: xor %eax,%eax \ 37: jmp 0x0000000000000040
2f: leave \ 39: mov 0x2a0(%rdi),%rdi
30: ret \--------------------------------------------
40: xor %eax,%eax
42: leave
43: ret--- arch/x86/net/bpf_jit_comp.c | 57 ++++++++++++++++--------------------- 1 file changed, 25 insertions(+), 32 deletions(-)
arch/x86/net/bpf_jit_comp.c +25 -32
@@ -1807,36 +1807,41 @@ st: if (is_imm8(insn->off))if (BPF_MODE (insn->code) ==BPF_PROBE_MEM ||BPF_MODE (insn->code) ==BPF_PROBE_MEMSX ) {/* Conservatively check that src_reg + insn->off is a kernel address: -* src_reg + insn->off >= TASK_SIZE_MAX + PAGE_SIZE -* src_reg is used as scratch for src_reg += insn->off and restored -* after emit_ldx if necessary +* src_reg + insn->off > TASK_SIZE_MAX + PAGE_SIZE +* and +* src_reg + insn->off < VSYSCALL_ADDR */ -u64 limit =TASK_SIZE_MAX +PAGE_SIZE ; +u64 limit =TASK_SIZE_MAX +PAGE_SIZE -VSYSCALL_ADDR ;u8 *end_of_jmp; -/* At end of these emitted checks, insn->off will have been added -* to src_reg, so no need to do relative load with insn->off offset -*/ - insn_off =0 ; +/* movabsq r10, VSYSCALL_ADDR */ +emit_mov_imm64 (&prog,BPF_REG_AX , (long )VSYSCALL_ADDR >>32 , + (u32 )(long )VSYSCALL_ADDR ); -/* movabsq r11, limit */ -EMIT2 (add_1mod (0x48 ,AUX_REG ),add_1reg (0xB8 ,AUX_REG )); -EMIT ((u32 )limit,4 ); -EMIT (limit >>32 ,4 ); +/* mov src_reg, r11 */ +EMIT_mov (AUX_REG , src_reg);if (insn->off) { -/* add src_reg, insn->off */ -maybe_emit_1mod (&prog, src_reg, true); -EMIT2_off32 (0x81 ,add_1reg (0xC0 , src_reg), insn->off); +/* add r11, insn->off */ +maybe_emit_1mod (&prog,AUX_REG , true); +EMIT2_off32 (0x81 ,add_1reg (0xC0 ,AUX_REG ), insn->off); } -/* cmp src_reg, r11 */ -maybe_emit_mod (&prog, src_reg,AUX_REG , true); -EMIT2 (0x39 ,add_2reg (0xC0 , src_reg,AUX_REG )); +/* sub r11, r10 */ +maybe_emit_mod (&prog,AUX_REG ,BPF_REG_AX , true); +EMIT2 (0x29 ,add_2reg (0xC0 ,AUX_REG ,BPF_REG_AX )); + +/* movabsq r10, limit */ +emit_mov_imm64 (&prog,BPF_REG_AX , (long )limit >>32 , + (u32 )(long )limit); + +/* cmp r10, r11 */ +maybe_emit_mod (&prog,AUX_REG ,BPF_REG_AX , true); +EMIT2 (0x39 ,add_2reg (0xC0 ,AUX_REG ,BPF_REG_AX )); -/* if unsigned '>=', goto load */ -EMIT2 (X86_JAE ,0 ); +/* if unsigned '>', goto load */ +EMIT2 (X86_JA ,0 ); end_of_jmp = prog;/* xor dst_reg, dst_reg */
@@ -1862,18 +1867,6 @@ st: if (is_imm8(insn->off))/* populate jmp_offset for JMP above */ start_of_ldx[-1 ] = prog - start_of_ldx; -if (insn->off && src_reg != dst_reg) { -/* sub src_reg, insn->off -* Restore src_reg after "add src_reg, insn->off" in prev -* if statement. But if src_reg == dst_reg, emit_ldx -* above already clobbered src_reg, so no need to restore. -* If add src_reg, insn->off was unnecessary, no need to -* restore either. -*/ -maybe_emit_1mod (&prog, src_reg, true); -EMIT2_off32 (0x81 ,add_1reg (0xE8 , src_reg), insn->off); - } -if (!bpf_prog->aux->extable)break ;
Signature · 1 line
2.40.1
PATCH v6 3/3 selftests/bpf: Test PROBE_MEM of VSYSCALL_ADDR on x86-64
In reply to Puranjay MohanThe vsyscall is a legacy API for fast execution of system calls. It maps a page at address VSYSCALL_ADDR into the userspace program. This address is in the top 10MB of the address space:
ffffffffff600000 - ffffffffff600fff | 4 kB | legacy vsyscall ABI
The last commit fixes the x86-64 BPF JIT to skip accessing addresses in this memory region. Add this address to bpf_testmod_return_ptr() so we can make sure that it is fixed.
After this change and without the previous commit, subprogs_extable selftest will crash the kernel.
--- tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c | 3 +++ 1 file changed, 3 insertions(+)
tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c +3 -0
@@ -205,6 +205,9 @@ __weak noinline struct file *bpf_testmod_return_ptr(int arg)case 5 :return (void *)~(1ull <<30 );/* trigger extable */ case 6 :return &f;/* valid addr */ case 7 :return (void *)((long )&f |1 );/* kernel tricks */ +#ifdef CONFIG_X86_64 +case 8 :return (void *)VSYSCALL_ADDR ;/* vsyscall page address */ +#endif default :return NULL ; } }
Signature · 1 line
2.40.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 6 lines · On Wed, 24 Apr 2024 10:02:07 +0000 you wrote:
V5: https://lore.kernel.org/bpf/[email protected]/
Changes in V6:
- Disable the verifier's instrumentation in x86-64 and update the JIT to take care of vsyscall page in addition to userspace addresses.
- Updatebpf_testmodto test for vsyscall addresses.
Quoted 7 lines
V4: https://lore.kernel.org/bpf/[email protected]/
Changes in V5:
- UseTASK_SIZE_MAX+PAGE_SIZE,VSYSCALL_ADDRas userspace boundary in x86-64 JIT.
- Added Acked-by: Ilya Leoshkevich <[email protected]>[...]
Here is the summary with links:
- [bpf,v6,1/3] bpf: verifier: prevent userspace memory access
https://git.kernel.org/bpf/bpf/c/66e13b615a0c - [bpf,v6,2/3] bpf, x86: Fix PROBE_MEM runtime load check https://git.kernel.org/bpf/bpf/c/b599d7d26d6a - [bpf,v6,3/3] selftests/bpf: Test PROBE_MEM of VSYSCALL_ADDR on x86-64 https://git.kernel.org/bpf/bpf/c/7cd6750d9a56
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html