p71924506
/
linux_old1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net: filter: be more defensive on div/mod by X==0 

The old interpreter behaviour was that we returned with 0
whenever we found a division by 0 would take place. In the new
interpreter we would currently just skip that instead and
continue execution.

It's true that a value of 0 as return might not be appropriate
in all cases, but current users (socket filters -> drop
packet, seccomp -> SECCOMP_RET_KILL, cls_bpf -> unclassified,
etc) seem fine with that behaviour. Better this than undefined
BPF program behaviour as it's expected that A contains the
result of the division. In future, as more use cases open up,
we could further adapt this return value to our needs, if
necessary.

So reintroduce return of 0 for division by 0 as in the old
interpreter. Also in case of K which is guaranteed to be 32bit
wide, sk_chk_filter() already takes care of preventing division
by 0 invoked through K, so we can generally spare us these tests.

Signed-off-by: Daniel Borkmann <dborkman@redhat.com>
Reviewed-by: Alexei Starovoitov <ast@plumgrid.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Daniel Borkmann 2014-04-05 01:04:03 +02:00 committed by David S. Miller
parent d80e773f16
commit 5f9fde5f79
1 changed files with 16 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
net/core/filter.c
View File

@ -295,43 +295,43 @@ unsigned int __sk_run_filter(void *ctx, const struct sock_filter_int *insn)
(*(s64 *) &A) >>= K; (*(s64 *) &A) >>= K;
CONT; CONT;
BPF_ALU64_BPF_MOD_BPF_X: BPF_ALU64_BPF_MOD_BPF_X:
if (unlikely(X == 0))
return 0;
tmp = A; tmp = A;
if (X) A = do_div(tmp, X);
A = do_div(tmp, X);
CONT; CONT;
BPF_ALU_BPF_MOD_BPF_X: BPF_ALU_BPF_MOD_BPF_X:
if (unlikely(X == 0))
return 0;
tmp = (u32) A; tmp = (u32) A;
if (X) A = do_div(tmp, (u32) X);
A = do_div(tmp, (u32) X);
CONT; CONT;
BPF_ALU64_BPF_MOD_BPF_K: BPF_ALU64_BPF_MOD_BPF_K:
tmp = A; tmp = A;
if (K) A = do_div(tmp, K);
A = do_div(tmp, K);
CONT; CONT;
BPF_ALU_BPF_MOD_BPF_K: BPF_ALU_BPF_MOD_BPF_K:
tmp = (u32) A; tmp = (u32) A;
if (K) A = do_div(tmp, (u32) K);
A = do_div(tmp, (u32) K);
CONT; CONT;
BPF_ALU64_BPF_DIV_BPF_X: BPF_ALU64_BPF_DIV_BPF_X:
if (X) if (unlikely(X == 0))
do_div(A, X); return 0;
do_div(A, X);
CONT; CONT;
BPF_ALU_BPF_DIV_BPF_X: BPF_ALU_BPF_DIV_BPF_X:
if (unlikely(X == 0))
return 0;
tmp = (u32) A; tmp = (u32) A;
if (X) do_div(tmp, (u32) X);
do_div(tmp, (u32) X);
A = (u32) tmp; A = (u32) tmp;
CONT; CONT;
BPF_ALU64_BPF_DIV_BPF_K: BPF_ALU64_BPF_DIV_BPF_K:
if (K) do_div(A, K);
do_div(A, K);
CONT; CONT;
BPF_ALU_BPF_DIV_BPF_K: BPF_ALU_BPF_DIV_BPF_K:
tmp = (u32) A; tmp = (u32) A;
if (K) do_div(tmp, (u32) K);
do_div(tmp, (u32) K);
A = (u32) tmp; A = (u32) tmp;
CONT; CONT;
BPF_ALU_BPF_END_BPF_TO_BE: BPF_ALU_BPF_END_BPF_TO_BE: