| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-Id: <20221123141546.238297-3-sunhao.th@gmail.com>
Date: Wed, 23 Nov 2022 22:15:45 +0800
From: Hao Sun <sunhao.th@...il.com>
To: bpf@...r.kernel.org
Cc: ast@...nel.org, daniel@...earbox.net, john.fastabend@...il.com,
andrii@...nel.org, martin.lau@...ux.dev, song@...nel.org,
yhs@...com, kpsingh@...nel.org, sdf@...gle.com, haoluo@...gle.com,
jolsa@...nel.org, davem@...emloft.net,
linux-kernel@...r.kernel.org, Hao Sun <sunhao.th@...il.com>
Subject: [PATCH bpf-next 2/3] bpf: Sanitize LDX in jited BPF progs with KASAN
Make 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.
Signed-off-by: Hao Sun <sunhao.th@...il.com>
---
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(-)
diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c
index ceaef69adc49..0fc67383ffa8 100644
--- a/arch/x86/net/bpf_jit_comp.c
+++ b/arch/x86/net/bpf_jit_comp.c
@@ -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);
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index a7eb99928fee..350d890a39ac 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -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 */
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index af214f0191e0..c0c11d24dc7b 100644
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -15238,6 +15238,17 @@ BPF_ASAN_STORE(16);
BPF_ASAN_STORE(32);
BPF_ASAN_STORE(64);
+#define BPF_ASAN_LOAD(n) \
+ notrace u64 bpf_asan_load##n(u##n *addr) \
+ { \
+ return *addr; \
+ }
+
+BPF_ASAN_LOAD(8);
+BPF_ASAN_LOAD(16);
+BPF_ASAN_LOAD(32);
+BPF_ASAN_LOAD(64);
+
#endif
/* Do various post-verification rewrites in a single program pass.
@@ -15454,6 +15465,83 @@ static int do_misc_fixups(struct bpf_verifier_env *env)
insn = new_prog->insnsi + i + delta;
continue;
}
+
+ /* Sanitize LDX operation*/
+ if (BPF_CLASS(insn->code) == BPF_LDX) {
+ struct bpf_insn sanitize_fn;
+ struct bpf_insn *patch = &insn_buf[0];
+ bool dst_is_r0 = insn->dst_reg == BPF_REG_0;
+ bool dst_is_r1 = insn->dst_reg == BPF_REG_1;
+
+ if (in_patch_use_ax || insn->src_reg == BPF_REG_10)
+ continue;
+
+ switch (BPF_SIZE(insn->code)) {
+ case BPF_B:
+ sanitize_fn = BPF_EMIT_CALL(bpf_asan_load8);
+ break;
+ case BPF_H:
+ sanitize_fn = BPF_EMIT_CALL(bpf_asan_load16);
+ break;
+ case BPF_W:
+ sanitize_fn = BPF_EMIT_CALL(bpf_asan_load32);
+ break;
+ case BPF_DW:
+ sanitize_fn = BPF_EMIT_CALL(bpf_asan_load64);
+ break;
+ }
+
+ /* Backup R0 and R1, REG_AX and dst_reg are free. */
+ if (insn->src_reg == BPF_REG_1) {
+ if (!dst_is_r0)
+ *patch++ = BPF_MOV64_REG(BPF_REG_AX, BPF_REG_0);
+ } else if (insn->src_reg == BPF_REG_0) {
+ if (!dst_is_r1)
+ *patch++ = BPF_MOV64_REG(BPF_REG_AX, BPF_REG_1);
+ *patch++ = BPF_MOV64_REG(BPF_REG_1, BPF_REG_0);
+ } else if (!dst_is_r1) {
+ *patch++ = BPF_MOV64_REG(BPF_REG_AX, BPF_REG_1);
+ *patch++ = BPF_MOV64_REG(BPF_REG_1, insn->src_reg);
+ if (!dst_is_r0)
+ *patch++ = BPF_MOV64_REG(insn->dst_reg, BPF_REG_0);
+ } else {
+ *patch++ = BPF_MOV64_REG(BPF_REG_1, insn->src_reg);
+ *patch++ = BPF_MOV64_REG(BPF_REG_AX, BPF_REG_0);
+ }
+ if (insn->off != 0)
+ *patch++ = BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, insn->off);
+ /* Invoke sanitize fn, R1~R5 are stored to stack during jit. */
+ *patch++ = sanitize_fn;
+ if (insn->off != 0)
+ *patch++ = BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -insn->off);
+ if (insn->src_reg == BPF_REG_1) {
+ if (!dst_is_r0)
+ *patch++ = BPF_MOV64_REG(BPF_REG_0, BPF_REG_AX);
+ } else if (insn->src_reg == BPF_REG_0) {
+ *patch++ = BPF_MOV64_REG(BPF_REG_0, BPF_REG_1);
+ if (!dst_is_r1)
+ *patch++ = BPF_MOV64_REG(BPF_REG_1, BPF_REG_AX);
+ } else if (!dst_is_r1) {
+ if (!dst_is_r0)
+ *patch++ = BPF_MOV64_REG(BPF_REG_0, insn->dst_reg);
+ if (insn->src_reg == insn->dst_reg)
+ *patch++ = BPF_MOV64_REG(insn->src_reg, BPF_REG_1);
+ *patch++ = BPF_MOV64_REG(BPF_REG_1, BPF_REG_AX);
+ } else {
+ *patch++ = BPF_MOV64_REG(BPF_REG_0, BPF_REG_AX);
+ }
+ *patch++ = *insn;
+ 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;
+ continue;
+ }
#endif
if (insn->code != (BPF_JMP | BPF_CALL))
--
2.38.1
Powered by blists - more mailing lists