Commit 2011fccf authored by Andrey Ignatov's avatar Andrey Ignatov Committed by Alexei Starovoitov
Browse files

bpf: Support variable offset stack access from helpers 



Currently there is a difference in how verifier checks memory access for
helper arguments for PTR_TO_MAP_VALUE and PTR_TO_STACK with regard to
variable part of offset.

check_map_access, that is used for PTR_TO_MAP_VALUE, can handle variable
offsets just fine, so that BPF program can call a helper like this:

  some_helper(map_value_ptr + off, size);

, where offset is unknown at load time, but is checked by program to be
in a safe rage (off >= 0 && off + size < map_value_size).

But it's not the case for check_stack_boundary, that is used for
PTR_TO_STACK, and same code with pointer to stack is rejected by
verifier:

  some_helper(stack_value_ptr + off, size);

For example:
  0: (7a) *(u64 *)(r10 -16) = 0
  1: (7a) *(u64 *)(r10 -8) = 0
  2: (61) r2 = *(u32 *)(r1 +0)
  3: (57) r2 &= 4
  4: (17) r2 -= 16
  5: (0f) r2 += r10
  6: (18) r1 = 0xffff888111343a80
  8: (85) call bpf_map_lookup_elem#1
  invalid variable stack read R2 var_off=(0xfffffffffffffff0; 0x4)

Add support for variable offset access to check_stack_boundary so that
if offset is checked by program to be in a safe range it's accepted by
verifier.

Signed-off-by: default avatarAndrey Ignatov <rdna@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent dd399ac9

kernel/bpf/verifier.c

+54 −21
Original line number Original line Diff line number Diff line
@@ -2157,6 +2157,29 @@ static int check_xadd(struct bpf_verifier_env *env, int insn_idx, struct bpf_ins 
				BPF_SIZE(insn->code), BPF_WRITE, -1, true);

				BPF_SIZE(insn->code), BPF_WRITE, -1, true);

}

}





static int __check_stack_boundary(struct bpf_verifier_env *env, u32 regno,

				  int off, int access_size,

				  bool zero_size_allowed)

{

	struct bpf_reg_state *reg = reg_state(env, regno);



	if (off >= 0 || off < -MAX_BPF_STACK || off + access_size > 0 ||

	    access_size < 0 || (access_size == 0 && !zero_size_allowed)) {

		if (tnum_is_const(reg->var_off)) {

			verbose(env, "invalid stack type R%d off=%d access_size=%d\n",

				regno, off, access_size);

		} else {

			char tn_buf[48];



			tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);

			verbose(env, "invalid stack type R%d var_off=%s access_size=%d\n",

				regno, tn_buf, access_size);

		}

		return -EACCES;

	}

	return 0;

}



/* when register 'regno' is passed into function that will read 'access_size'

/* when register 'regno' is passed into function that will read 'access_size'

 * bytes from that pointer, make sure that it's within stack boundary

 * bytes from that pointer, make sure that it's within stack boundary

 * and all elements of stack are initialized.

 * and all elements of stack are initialized.
@@ -2169,7 +2192,7 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno, 
{

{

	struct bpf_reg_state *reg = reg_state(env, regno);

	struct bpf_reg_state *reg = reg_state(env, regno);

	struct bpf_func_state *state = func(env, reg);

	struct bpf_func_state *state = func(env, reg);

	int off, i, slot, spi;

	int err, min_off, max_off, i, slot, spi;





	if (reg->type != PTR_TO_STACK) {

	if (reg->type != PTR_TO_STACK) {

		/* Allow zero-byte read from NULL, regardless of pointer type */

		/* Allow zero-byte read from NULL, regardless of pointer type */
@@ -2183,21 +2206,23 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno, 
		return -EACCES;

		return -EACCES;

	}

	}





	/* Only allow fixed-offset stack reads */

	if (tnum_is_const(reg->var_off)) {

	if (!tnum_is_const(reg->var_off)) {

		min_off = max_off = reg->var_off.value + reg->off;

		char tn_buf[48];

		err = __check_stack_boundary(env, regno, min_off, access_size,



					     zero_size_allowed);

		tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);

		if (err)

		verbose(env, "invalid variable stack read R%d var_off=%s\n",

			return err;

			regno, tn_buf);

	} else {

		return -EACCES;

		min_off = reg->smin_value + reg->off;

	}

		max_off = reg->umax_value + reg->off;

	off = reg->off + reg->var_off.value;

		err = __check_stack_boundary(env, regno, min_off, access_size,

	if (off >= 0 || off < -MAX_BPF_STACK || off + access_size > 0 ||

					     zero_size_allowed);

	    access_size < 0 || (access_size == 0 && !zero_size_allowed)) {

		if (err)

		verbose(env, "invalid stack type R%d off=%d access_size=%d\n",

			return err;

			regno, off, access_size);

		err = __check_stack_boundary(env, regno, max_off, access_size,

		return -EACCES;

					     zero_size_allowed);

		if (err)

			return err;

	}

	}





	if (meta && meta->raw_mode) {

	if (meta && meta->raw_mode) {
@@ -2206,10 +2231,10 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno, 
		return 0;

		return 0;

	}

	}





	for (i = 0; i < access_size; i++) {

	for (i = min_off; i < max_off + access_size; i++) {

		u8 *stype;

		u8 *stype;





		slot = -(off + i) - 1;

		slot = -i - 1;

		spi = slot / BPF_REG_SIZE;

		spi = slot / BPF_REG_SIZE;

		if (state->allocated_stack <= slot)

		if (state->allocated_stack <= slot)

			goto err;

			goto err;
@@ -2222,8 +2247,16 @@ static int check_stack_boundary(struct bpf_verifier_env *env, int regno, 
			goto mark;

			goto mark;

		}

		}

err:

err:

		if (tnum_is_const(reg->var_off)) {

			verbose(env, "invalid indirect read from stack off %d+%d size %d\n",

			verbose(env, "invalid indirect read from stack off %d+%d size %d\n",

			off, i, access_size);

				min_off, i - min_off, access_size);

		} else {

			char tn_buf[48];



			tnum_strn(tn_buf, sizeof(tn_buf), reg->var_off);

			verbose(env, "invalid indirect read from stack var_off %s+%d size %d\n",

				tn_buf, i - min_off, access_size);

		}

		return -EACCES;

		return -EACCES;

mark:

mark:

		/* reading any byte out of 8-byte 'spill_slot' will cause

		/* reading any byte out of 8-byte 'spill_slot' will cause
@@ -2232,7 +2265,7 @@ mark: 
		mark_reg_read(env, &state->stack[spi].spilled_ptr,

		mark_reg_read(env, &state->stack[spi].spilled_ptr,

			      state->stack[spi].spilled_ptr.parent);

			      state->stack[spi].spilled_ptr.parent);

	}

	}

	return update_stack_depth(env, state, off);

	return update_stack_depth(env, state, min_off);

}

}





static int check_helper_mem_access(struct bpf_verifier_env *env, int regno,

static int check_helper_mem_access(struct bpf_verifier_env *env, int regno,

CRA Git | Maintained and supported by SUSTech CRA and CCSE