Commit d2b27624 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'bpf-range-marking-fixes' 



Daniel Borkmann says:

====================
Two BPF fixes for range marking

The set contains two fixes for direct packet access range
markings and test cases for all direct packet access patterns
that the verifier matches on.

They are targeted for net tree, note that once net gets merged
into net-next, there will be a minor merge conflict due to
signature change of the function find_good_pkt_pointers() as
well as data_meta patterns present in net-next tree. You can
just add bool false to the data_meta patterns and I will
follow-up with properly converting the patterns for data_meta
in a similar way.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 8695a539 b37242c7

kernel/bpf/verifier.c

+45 −12
Original line number Diff line number Diff line
@@ -2430,12 +2430,15 @@ static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn) 
}



static void find_good_pkt_pointers(struct bpf_verifier_state *state,

				   struct bpf_reg_state *dst_reg)

				   struct bpf_reg_state *dst_reg,

				   bool range_right_open)

{

	struct bpf_reg_state *regs = state->regs, *reg;

	u16 new_range;

	int i;



	if (dst_reg->off < 0)

	if (dst_reg->off < 0 ||

	    (dst_reg->off == 0 && range_right_open))

		/* This doesn't give us any range */

		return;
@@ -2446,9 +2449,13 @@ static void find_good_pkt_pointers(struct bpf_verifier_state *state, 
		 */

		return;



	/* LLVM can generate four kind of checks:

	new_range = dst_reg->off;

	if (range_right_open)

		new_range--;



	/* Examples for register markings:

	 *

	 * Type 1/2:

	 * pkt_data in dst register:

	 *

	 *   r2 = r3;

	 *   r2 += 8;
@@ -2465,7 +2472,7 @@ static void find_good_pkt_pointers(struct bpf_verifier_state *state, 
	 *     r2=pkt(id=n,off=8,r=0)

	 *     r3=pkt(id=n,off=0,r=0)

	 *

	 * Type 3/4:

	 * pkt_data in src register:

	 *

	 *   r2 = r3;

	 *   r2 += 8;
@@ -2483,7 +2490,9 @@ static void find_good_pkt_pointers(struct bpf_verifier_state *state, 
	 *     r3=pkt(id=n,off=0,r=0)

	 *

	 * Find register r3 and mark its range as r3=pkt(id=n,off=0,r=8)

	 * so that range of bytes [r3, r3 + 8) is safe to access.

	 * or r3=pkt(id=n,off=0,r=8-1), so that range of bytes [r3, r3 + 8)

	 * and [r3, r3 + 8-1) respectively is safe to access depending on

	 * the check.

	 */



	/* If our ids match, then we must have the same max_value.  And we
@@ -2494,14 +2503,14 @@ static void find_good_pkt_pointers(struct bpf_verifier_state *state, 
	for (i = 0; i < MAX_BPF_REG; i++)

		if (regs[i].type == PTR_TO_PACKET && regs[i].id == dst_reg->id)

			/* keep the maximum range already checked */

			regs[i].range = max_t(u16, regs[i].range, dst_reg->off);

			regs[i].range = max(regs[i].range, new_range);



	for (i = 0; i < MAX_BPF_STACK; i += BPF_REG_SIZE) {

		if (state->stack_slot_type[i] != STACK_SPILL)

			continue;

		reg = &state->spilled_regs[i / BPF_REG_SIZE];

		if (reg->type == PTR_TO_PACKET && reg->id == dst_reg->id)

			reg->range = max_t(u16, reg->range, dst_reg->off);

			reg->range = max(reg->range, new_range);

	}

}
@@ -2865,19 +2874,43 @@ static int check_cond_jmp_op(struct bpf_verifier_env *env, 
	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JGT &&

		   dst_reg->type == PTR_TO_PACKET &&

		   regs[insn->src_reg].type == PTR_TO_PACKET_END) {

		find_good_pkt_pointers(this_branch, dst_reg);

		/* pkt_data' > pkt_end */

		find_good_pkt_pointers(this_branch, dst_reg, false);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JGT &&

		   dst_reg->type == PTR_TO_PACKET_END &&

		   regs[insn->src_reg].type == PTR_TO_PACKET) {

		/* pkt_end > pkt_data' */

		find_good_pkt_pointers(other_branch, &regs[insn->src_reg], true);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JLT &&

		   dst_reg->type == PTR_TO_PACKET &&

		   regs[insn->src_reg].type == PTR_TO_PACKET_END) {

		find_good_pkt_pointers(other_branch, dst_reg);

		/* pkt_data' < pkt_end */

		find_good_pkt_pointers(other_branch, dst_reg, true);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JLT &&

		   dst_reg->type == PTR_TO_PACKET_END &&

		   regs[insn->src_reg].type == PTR_TO_PACKET) {

		/* pkt_end < pkt_data' */

		find_good_pkt_pointers(this_branch, &regs[insn->src_reg], false);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JGE &&

		   dst_reg->type == PTR_TO_PACKET &&

		   regs[insn->src_reg].type == PTR_TO_PACKET_END) {

		/* pkt_data' >= pkt_end */

		find_good_pkt_pointers(this_branch, dst_reg, true);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JGE &&

		   dst_reg->type == PTR_TO_PACKET_END &&

		   regs[insn->src_reg].type == PTR_TO_PACKET) {

		find_good_pkt_pointers(other_branch, &regs[insn->src_reg]);

		/* pkt_end >= pkt_data' */

		find_good_pkt_pointers(other_branch, &regs[insn->src_reg], false);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JLE &&

		   dst_reg->type == PTR_TO_PACKET &&

		   regs[insn->src_reg].type == PTR_TO_PACKET_END) {

		/* pkt_data' <= pkt_end */

		find_good_pkt_pointers(other_branch, dst_reg, false);

	} else if (BPF_SRC(insn->code) == BPF_X && opcode == BPF_JLE &&

		   dst_reg->type == PTR_TO_PACKET_END &&

		   regs[insn->src_reg].type == PTR_TO_PACKET) {

		find_good_pkt_pointers(this_branch, &regs[insn->src_reg]);

		/* pkt_end <= pkt_data' */

		find_good_pkt_pointers(this_branch, &regs[insn->src_reg], true);

	} else if (is_pointer_value(env, insn->dst_reg)) {

		verbose("R%d pointer comparison prohibited\n", insn->dst_reg);

		return -EACCES;

tools/testing/selftests/bpf/test_verifier.c

+480 −0
Original line number Diff line number Diff line
@@ -6671,6 +6671,486 @@ static struct bpf_test tests[] = { 
		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_SCHED_CLS,

	},

	{

		"XDP pkt read, pkt_end mangling, bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_3, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end mangling, bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_ALU64_IMM(BPF_SUB, BPF_REG_3, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' > pkt_end, good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' > pkt_end, bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_data' > pkt_end, bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 0),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end > pkt_data', good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_end > pkt_data', bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end > pkt_data', bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' < pkt_end, good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_data' < pkt_end, bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' < pkt_end, bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end < pkt_data', good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end < pkt_data', bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_end < pkt_data', bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 0),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' >= pkt_end, good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_data' >= pkt_end, bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' >= pkt_end, bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 0),

			BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_end >= pkt_data', good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end >= pkt_data', bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_end >= pkt_data', bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' <= pkt_end, good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_data' <= pkt_end, bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),

			BPF_JMP_IMM(BPF_JA, 0, 0, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -4),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_data' <= pkt_end, bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end <= pkt_data', good access",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),

			BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.result = ACCEPT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

	{

		"XDP pkt read, pkt_end <= pkt_data', bad access 1",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),

			BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

	},

	{

		"XDP pkt read, pkt_end <= pkt_data', bad access 2",

		.insns = {

			BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,

				    offsetof(struct xdp_md, data)),

			BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,

				    offsetof(struct xdp_md, data_end)),

			BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),

			BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),

			BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 0),

			BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1, -5),

			BPF_MOV64_IMM(BPF_REG_0, 0),

			BPF_EXIT_INSN(),

		},

		.errstr = "R1 offset is outside of the packet",

		.result = REJECT,

		.prog_type = BPF_PROG_TYPE_XDP,

		.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

	},

};



static int probe_filter_length(const struct bpf_insn *fp)

CRA Git | Maintained and supported by SUSTech CRA and CCSE