bpf: Support variable offsets for syscall PTR_TO_CTX

Allow accessing PTR_TO_CTX with variable offsets in syscall programs.
Fixed offsets are already enabled for all program types that do not
convert their ctx accesses, since the changes we made in the commit
de6c7d99f898 ("bpf: Relax fixed offset check for PTR_TO_CTX"). Note
that we also lift the restriction on passing syscall context into
helpers, which was not permitted before, and passing modified syscall
context into kfuncs.

The structure of check_mem_access can be mostly shared and preserved,
but we must use check_mem_region_access to correctly verify access with
variable offsets.

The check made in check_helper_mem_access is hardened to only allow
PTR_TO_CTX for syscall programs to be passed in as helper memory. This
was the original intention of the existing code anyway, and it makes
little sense for other program types' context to be utilized as a memory
buffer. In case a convincing example presents itself in the future, this
check can be relaxed further.

We also no longer use the last-byte access to simulate helper memory
access, but instead go through check_mem_region_access. Since this no
longer updates our max_ctx_offset, we must do so manually, to keep track
of the maximum offset at which the program ctx may be accessed.

Take care to ensure that when arg_type is ARG_PTR_TO_CTX, we do not
relax any fixed or variable offset constraints around PTR_TO_CTX even in
syscall programs, and require them to be passed unmodified. There are
several reasons why this is necessary. First, if we pass a modified ctx,
then the global subprog's accesses will not update the max_ctx_offset to
its true maximum offset, and can lead to out of bounds accesses. Second,
tail called program (or extension program replacing global subprog) where
their max_ctx_offset exceeds the program they are being called from can
also cause issues. For the latter, unmodified PTR_TO_CTX is the first
requirement for the fix, the second is ensuring max_ctx_offset >= the
program they are being called from, which has to be a separate change
not made in this commit.

All in all, we can hint using arg_type when we expect ARG_PTR_TO_CTX and
make our relaxation around offsets conditional on it.

Drop coverage of syscall tests from verifier_ctx.c temporarily for
negative cases until they are updated in subsequent commits.

Reviewed-by: Emil Tsalapatis <emil@etsalapatis.com>
Acked-by: Puranjay Mohan <puranjay@kernel.org>
Acked-by: Mykyta Yatsenko <yatsenko@meta.com>
Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Link: https://lore.kernel.org/r/20260406194403.1649608-2-memxor@gmail.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c
index 84699a428077d66f68203cdcccddee5f8207cd34..7d68f7d1230d2ae21de94af1ee8a45a85a8c2866 100644 (file)
--- a/kernel/bpf/verifier.c
+++ b/kernel/bpf/verifier.c
@@ -5983,6 +5983,10 @@ static int __check_mem_access(struct bpf_verifier_env *env, int regno,
                verbose(env, "invalid access to packet, off=%d size=%d, R%d(id=%d,off=%d,r=%d)\n",
                        off, size, regno, reg->id, off, mem_size);
                break;
+       case PTR_TO_CTX:
+               verbose(env, "invalid access to context, ctx_size=%d off=%d size=%d\n",
+                       mem_size, off, size);
+               break;
        case PTR_TO_MEM:
        default:
                verbose(env, "invalid access to memory, mem_size=%u off=%d size=%d\n",
@@ -6476,9 +6480,14 @@ static int check_packet_access(struct bpf_verifier_env *env, u32 regno, int off,
        return 0;
 }
 
+static bool is_var_ctx_off_allowed(struct bpf_prog *prog)
+{
+       return resolve_prog_type(prog) == BPF_PROG_TYPE_SYSCALL;
+}
+
 /* check access to 'struct bpf_context' fields.  Supports fixed offsets only */
-static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, int size,
-                           enum bpf_access_type t, struct bpf_insn_access_aux *info)
+static int __check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, int size,
+                             enum bpf_access_type t, struct bpf_insn_access_aux *info)
 {
        if (env->ops->is_valid_access &&
            env->ops->is_valid_access(off, size, t, env->prog, info)) {
@@ -6509,6 +6518,34 @@ static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off,
        return -EACCES;
 }
 
+static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, u32 regno,
+                           int off, int access_size, enum bpf_access_type t,
+                           struct bpf_insn_access_aux *info)
+{
+       /*
+        * Program types that don't rewrite ctx accesses can safely
+        * dereference ctx pointers with fixed offsets.
+        */
+       bool var_off_ok = is_var_ctx_off_allowed(env->prog);
+       bool fixed_off_ok = !env->ops->convert_ctx_access;
+       struct bpf_reg_state *regs = cur_regs(env);
+       struct bpf_reg_state *reg = regs + regno;
+       int err;
+
+       if (var_off_ok)
+               err = check_mem_region_access(env, regno, off, access_size, U16_MAX, false);
+       else
+               err = __check_ptr_off_reg(env, reg, regno, fixed_off_ok);
+       if (err)
+               return err;
+       off += reg->umax_value;
+
+       err = __check_ctx_access(env, insn_idx, off, access_size, t, info);
+       if (err)
+               verbose_linfo(env, insn_idx, "; ");
+       return err;
+}
+
 static int check_flow_keys_access(struct bpf_verifier_env *env, int off,
                                  int size)
 {
@@ -7939,17 +7976,12 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
                if (!err && value_regno >= 0 && (t == BPF_READ || rdonly_mem))
                        mark_reg_unknown(env, regs, value_regno);
        } else if (reg->type == PTR_TO_CTX) {
-               /*
-                * Program types that don't rewrite ctx accesses can safely
-                * dereference ctx pointers with fixed offsets.
-                */
-               bool fixed_off_ok = !env->ops->convert_ctx_access;
-               struct bpf_retval_range range;
                struct bpf_insn_access_aux info = {
                        .reg_type = SCALAR_VALUE,
                        .is_ldsx = is_ldsx,
                        .log = &env->log,
                };
+               struct bpf_retval_range range;
 
                if (t == BPF_WRITE && value_regno >= 0 &&
                    is_pointer_value(env, value_regno)) {
@@ -7957,19 +7989,7 @@ static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regn
                        return -EACCES;
                }
 
-               err = __check_ptr_off_reg(env, reg, regno, fixed_off_ok);
-               if (err < 0)
-                       return err;
-
-               /*
-                * Fold the register's constant offset into the insn offset so
-                * that is_valid_access() sees the true effective offset.
-                */
-               if (fixed_off_ok)
-                       off += reg->var_off.value;
-               err = check_ctx_access(env, insn_idx, off, size, t, &info);
-               if (err)
-                       verbose_linfo(env, insn_idx, "; ");
+               err = check_ctx_access(env, insn_idx, regno, off, size, t, &info);
                if (!err && t == BPF_READ && value_regno >= 0) {
                        /* ctx access returns either a scalar, or a
                         * PTR_TO_PACKET[_META,_END]. In the latter
@@ -8543,22 +8563,16 @@ static int check_helper_mem_access(struct bpf_verifier_env *env, int regno,
                return check_ptr_to_btf_access(env, regs, regno, 0,
                                               access_size, BPF_READ, -1);
        case PTR_TO_CTX:
-               /* in case the function doesn't know how to access the context,
-                * (because we are in a program of type SYSCALL for example), we
-                * can not statically check its size.
-                * Dynamically check it now.
-                */
-               if (!env->ops->convert_ctx_access) {
-                       int offset = access_size - 1;
-
-                       /* Allow zero-byte read from PTR_TO_CTX */
-                       if (access_size == 0)
-                               return zero_size_allowed ? 0 : -EACCES;
-
-                       return check_mem_access(env, env->insn_idx, regno, offset, BPF_B,
-                                               access_type, -1, false, false);
+               /* Only permit reading or writing syscall context using helper calls. */
+               if (is_var_ctx_off_allowed(env->prog)) {
+                       int err = check_mem_region_access(env, regno, 0, access_size, U16_MAX,
+                                                         zero_size_allowed);
+                       if (err)
+                               return err;
+                       if (env->prog->aux->max_ctx_offset < reg->umax_value + access_size)
+                               env->prog->aux->max_ctx_offset = reg->umax_value + access_size;
+                       return 0;
                }
-
                fallthrough;
        default: /* scalar_value or invalid ptr */
                /* Allow zero-byte read from NULL, regardless of pointer type */
@@ -9502,6 +9516,7 @@ static const struct bpf_reg_types mem_types = {
                PTR_TO_MEM | MEM_RINGBUF,
                PTR_TO_BUF,
                PTR_TO_BTF_ID | PTR_TRUSTED,
+               PTR_TO_CTX,
        },
 };
 
@@ -9811,6 +9826,16 @@ static int check_func_arg_reg_off(struct bpf_verifier_env *env,
                 * still need to do checks instead of returning.
                 */
                return __check_ptr_off_reg(env, reg, regno, true);
+       case PTR_TO_CTX:
+               /*
+                * Allow fixed and variable offsets for syscall context, but
+                * only when the argument is passed as memory, not ctx,
+                * otherwise we may get modified ctx in tail called programs and
+                * global subprogs (that may act as extension prog hooks).
+                */
+               if (arg_type != ARG_PTR_TO_CTX && is_var_ctx_off_allowed(env->prog))
+                       return 0;
+               fallthrough;
        default:
                return __check_ptr_off_reg(env, reg, regno, false);
        }
@@ -10858,7 +10883,7 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog,
                         * invalid memory access.
                         */
                } else if (arg->arg_type == ARG_PTR_TO_CTX) {
-                       ret = check_func_arg_reg_off(env, reg, regno, ARG_DONTCARE);
+                       ret = check_func_arg_reg_off(env, reg, regno, ARG_PTR_TO_CTX);
                        if (ret < 0)
                                return ret;
                        /* If function expects ctx type in BTF check that caller
@@ -13732,7 +13757,6 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_
                                }
                        }
                        fallthrough;
-               case KF_ARG_PTR_TO_CTX:
                case KF_ARG_PTR_TO_DYNPTR:
                case KF_ARG_PTR_TO_ITER:
                case KF_ARG_PTR_TO_LIST_HEAD:
@@ -13750,6 +13774,9 @@ static int check_kfunc_args(struct bpf_verifier_env *env, struct bpf_kfunc_call_
                case KF_ARG_PTR_TO_IRQ_FLAG:
                case KF_ARG_PTR_TO_RES_SPIN_LOCK:
                        break;
+               case KF_ARG_PTR_TO_CTX:
+                       arg_type = ARG_PTR_TO_CTX;
+                       break;
                default:
                        verifier_bug(env, "unknown kfunc arg type %d", kf_arg_type);
                        return -EFAULT;

diff --git a/tools/testing/selftests/bpf/progs/verifier_ctx.c b/tools/testing/selftests/bpf/progs/verifier_ctx.c
index 371780290c0dae9a6e5f2393665a6642396aa005..ae756764ffba8be633d5c16966b878b871f9740a 100644 (file)
--- a/tools/testing/selftests/bpf/progs/verifier_ctx.c
+++ b/tools/testing/selftests/bpf/progs/verifier_ctx.c
@@ -359,7 +359,6 @@ __naked void syscall_ctx_fixed_off_write(void)
                : __clobber_all);                                       \
        }
 
-no_rewrite_ctx_access("syscall", syscall, 4, u32);
 no_rewrite_ctx_access("kprobe", kprobe, 8, u64);
 no_rewrite_ctx_access("tracepoint", tp, 8, u64);
 no_rewrite_ctx_access("raw_tp", raw_tp, 8, u64);

diff --git a/tools/testing/selftests/bpf/progs/verifier_global_subprogs.c b/tools/testing/selftests/bpf/progs/verifier_global_subprogs.c
index f02012a2fbaa14e13e87aab20a0a4a409d1d9a01..2250fc31574d5bbb36fece7414174d99533ce52d 100644 (file)
--- a/tools/testing/selftests/bpf/progs/verifier_global_subprogs.c
+++ b/tools/testing/selftests/bpf/progs/verifier_global_subprogs.c
@@ -134,7 +134,6 @@ __noinline __weak int subprog_user_anon_mem(user_struct_t *t)
 
 SEC("?tracepoint")
 __failure __log_level(2)
-__msg("invalid bpf_context access")
 __msg("Caller passes invalid args into func#1 ('subprog_user_anon_mem')")
 int anon_user_mem_invalid(void *ctx)
 {