| Message ID | 20211102064535.316018-1-kafai@fb.com (mailing list archive) |
|---|---|
| State | Accepted |
| Commit | f30d4968e9aee737e174fc97942af46cfb49b484 |
| Delegated to: | BPF |
| Headers | show |
| Series | bpf: Allow doing stack read with size larger than the earlier spilled reg | expand |
Hi, Martin. On 2021/11/2 2:45 PM, Martin KaFai Lau wrote: > Below is a simplified case from a report in bcc [0]: > r4 = 20 > *(u32 *)(r10 -4) = r4 > *(u32 *)(r10 -8) = r4 /* r4 state is tracked */ > r4 = *(u64 *)(r10 -8) /* Read more than the tracked 32bit scalar. > * verifier rejects as 'corrupted spill memory'. > */ > > After commit 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill"), > the 8-byte aligned 32bit spill is also tracked by the verifier > and the reg state is stored. > > However, if 8 bytes are read from the stack instead of the tracked > 4 byte scalar, the verifier currently rejects as "corrupted spill memory". > > This patch fixes this case by allowing it to read but marks the reg as > unknown. > > Also note that, if the prog is trying to corrupt/leak an > earlier spilled pointer by spilling another <8 bytes register on top, > this has already been rejected in the check_stack_write_fixed_off(). > > [0]: https://github.com/iovisor/bcc/pull/3683 > > Fixes: 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill") > Reported-by: Hengqi Chen <hengqi.chen@gmail.com> > Reported-by: Yonghong Song <yhs@gmail.com> > Signed-off-by: Martin KaFai Lau <kafai@fb.com> > --- [...] Thanks for the quick fix. I've tested this patch and now the BCC tools work fine. Tested-by: Hengqi Chen <hengqi.chen@gmail.com> Cheers, -- Hengqi
On 11/1/21 11:45 PM, Martin KaFai Lau wrote: > Below is a simplified case from a report in bcc [0]: > r4 = 20 > *(u32 *)(r10 -4) = r4 > *(u32 *)(r10 -8) = r4 /* r4 state is tracked */ > r4 = *(u64 *)(r10 -8) /* Read more than the tracked 32bit scalar. > * verifier rejects as 'corrupted spill memory'. > */ > > After commit 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill"), > the 8-byte aligned 32bit spill is also tracked by the verifier > and the reg state is stored. > > However, if 8 bytes are read from the stack instead of the tracked > 4 byte scalar, the verifier currently rejects as "corrupted spill memory". > > This patch fixes this case by allowing it to read but marks the reg as > unknown. > > Also note that, if the prog is trying to corrupt/leak an > earlier spilled pointer by spilling another <8 bytes register on top, > this has already been rejected in the check_stack_write_fixed_off(). > > [0]: https://github.com/iovisor/bcc/pull/3683 > > Fixes: 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill") > Reported-by: Hengqi Chen <hengqi.chen@gmail.com> > Reported-by: Yonghong Song <yhs@gmail.com> > Signed-off-by: Martin KaFai Lau <kafai@fb.com> Acked-by: Yonghong Song <yhs@fb.com>
diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 3c8aa7df1773..d8012775831d 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -3088,9 +3088,12 @@ static int check_stack_read_fixed_off(struct bpf_verifier_env *env, reg = ®_state->stack[spi].spilled_ptr; if (is_spilled_reg(®_state->stack[spi])) { - if (size != BPF_REG_SIZE) { - u8 scalar_size = 0; + u8 spill_size = 1; + + for (i = BPF_REG_SIZE - 1; i > 0 && stype[i - 1] == STACK_SPILL; i--) + spill_size++; + if (size != BPF_REG_SIZE || spill_size != BPF_REG_SIZE) { if (reg->type != SCALAR_VALUE) { verbose_linfo(env, env->insn_idx, "; "); verbose(env, "invalid size of register fill\n"); @@ -3101,10 +3104,7 @@ static int check_stack_read_fixed_off(struct bpf_verifier_env *env, if (dst_regno < 0) return 0; - for (i = BPF_REG_SIZE; i > 0 && stype[i - 1] == STACK_SPILL; i--) - scalar_size++; - - if (!(off % BPF_REG_SIZE) && size == scalar_size) { + if (!(off % BPF_REG_SIZE) && size == spill_size) { /* The earlier check_reg_arg() has decided the * subreg_def for this insn. Save it first. */ @@ -3128,12 +3128,6 @@ static int check_stack_read_fixed_off(struct bpf_verifier_env *env, state->regs[dst_regno].live |= REG_LIVE_WRITTEN; return 0; } - for (i = 1; i < BPF_REG_SIZE; i++) { - if (stype[(slot - i) % BPF_REG_SIZE] != STACK_SPILL) { - verbose(env, "corrupted spill memory\n"); - return -EACCES; - } - } if (dst_regno >= 0) { /* restore register state from stack */
Below is a simplified case from a report in bcc [0]: r4 = 20 *(u32 *)(r10 -4) = r4 *(u32 *)(r10 -8) = r4 /* r4 state is tracked */ r4 = *(u64 *)(r10 -8) /* Read more than the tracked 32bit scalar. * verifier rejects as 'corrupted spill memory'. */ After commit 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill"), the 8-byte aligned 32bit spill is also tracked by the verifier and the reg state is stored. However, if 8 bytes are read from the stack instead of the tracked 4 byte scalar, the verifier currently rejects as "corrupted spill memory". This patch fixes this case by allowing it to read but marks the reg as unknown. Also note that, if the prog is trying to corrupt/leak an earlier spilled pointer by spilling another <8 bytes register on top, this has already been rejected in the check_stack_write_fixed_off(). [0]: https://github.com/iovisor/bcc/pull/3683 Fixes: 354e8f1970f8 ("bpf: Support <8-byte scalar spill and refill") Reported-by: Hengqi Chen <hengqi.chen@gmail.com> Reported-by: Yonghong Song <yhs@gmail.com> Signed-off-by: Martin KaFai Lau <kafai@fb.com> --- kernel/bpf/verifier.c | 18 ++++++------------ 1 file changed, 6 insertions(+), 12 deletions(-)