blob: 9dc2c9a5f8b795b02923e3b3ccbd3197219dad13 [file]
// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */
#include <vmlinux.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_core_read.h>
#include "bpf_experimental.h"
#include "bpf_misc.h"
/*
* Variable-offset access into arrays within a BTF access chain, e.g. a[i].b,
* where 'i' is a register with a varying offset. The register's step has to
* match the stride of one of the arrays crossed while walking the access
* chain, and the maximal possible offset has to stay within that array.
*
* A program-allocated object (bpf_obj_new) is used as the source of a
* PTR_TO_BTF_ID with a shape we fully control.
*/
struct inner {
int a;
int b;
};
struct outer {
struct inner arr[8]; /* off 0, stride 8, size 64 */
char bytes[32]; /* off 64, stride 1, size 32 */
long longs[8]; /* off 96, stride 8, size 64 */
int grid[4][4]; /* off 160, 16 ints, size 64 */
};
/* arr[i].b, i in [0, 7], 4-byte read: stays within arr. */
SEC("syscall")
__success
int arr_field_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 7; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 4); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/* arr[i].b, i in [0, 15]: max offset runs past the end of arr. */
SEC("syscall")
__failure
__msg("invalid variable offset access into struct outer")
int arr_field_out_of_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 15; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 4); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/* longs[i], i in [0, 7], 8-byte read: scalar array with stride 8. */
SEC("syscall")
__success
int long_array_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
long val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 7; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u64 *)(r1 + 96); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* bytes[i], i in [0, 31], read as 4 bytes: min_off is valid within the array,
* but the 4-byte read at max_off runs past the array end. Exercises the
* size-aware bound in btf_struct_access().
*/
SEC("syscall")
__failure
__flag(BPF_F_ANY_ALIGNMENT)
__msg("invalid variable offset access into struct outer")
int byte_array_size_spanning(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 31; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 64); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/* bytes[i], i in [0, 31], 1-byte read: step 1 matches the char array stride. */
SEC("syscall")
__success
int byte_array_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 31; \
r1 += r2; \
%[val] = *(u8 *)(r1 + 64); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* arr[] accessed with step 4 (half of sizeof(struct inner)): the step is not
* a whole number of elements, so no crossed array has a matching stride.
*/
SEC("syscall")
__failure
__msg("invalid variable offset access into struct outer")
int arr_unaligned_step(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 7; \
r2 *= 4; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 0); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* grid[i][0], i in [0, 3]: steps along the outer dimension of a 2D array
* (stride 16). __btf_resolve_size() linearizes the array; the step is a
* multiple of the innermost element size (4).
*/
SEC("syscall")
__success
int grid_outer_dim(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 3; \
r2 *= 16; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 160); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* grid[0][i], i in [0, 3]: steps along the inner dimension of a 2D array
* (stride 4, the innermost element size).
*/
SEC("syscall")
__success
int grid_inner_dim(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct outer *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 3; \
r2 *= 4; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 160); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* An array of pointers within a program-allocated object. Reading a pointer
* member of a local object yields a SCALAR_VALUE, but the varying offset still
* has to be validated against the array bounds.
*/
struct with_ptrs {
struct inner *parr[8]; /* off 0, stride 8 (sizeof ptr), size 64 */
};
/* parr[i], i in [0, 7], 8-byte read: stays within parr. */
SEC("syscall")
__success
int ptr_array_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct with_ptrs *o;
long val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 7; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u64 *)(r1 + 0); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* parr[i], i in [0, 15]: max offset runs past the end of parr. Without the
* variable-offset check on the WALK_PTR path this would be wrongly accepted.
*/
SEC("syscall")
__failure
__msg("invalid variable offset access into struct with_ptrs")
int ptr_array_out_of_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct with_ptrs *o;
long val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 15; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u64 *)(r1 + 0); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* The cases above all use bpf_obj_new() (PTR_TO_BTF_ID | MEM_ALLOC). Exercise
* the trusted kernel-BTF path too, using a task_struct from
* bpf_get_current_task_btf() and its embedded char comm[] array. The comm
* offset is folded into the pointer as a constant before the varying index.
*/
/* task->comm[i], i in [0, 15], 1-byte read: stays within comm. */
SEC("syscall")
__success
int kernel_btf_array_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct task_struct *task;
int val = 0;
task = bpf_get_current_task_btf();
asm volatile (" \
r1 = %[task]; \
r1 += %[off]; \
r2 = %[i]; \
r2 &= 15; \
r1 += r2; \
%[val] = *(u8 *)(r1 + 0); \
" : [val] "=r"(val)
: [task] "r"(task), [i] "r"(i),
[off] "i"(offsetof(struct task_struct, comm))
: "r1", "r2");
return val;
}
/* task->comm[i], i in [0, 31]: max offset runs past comm. */
SEC("syscall")
__failure
__msg("invalid variable offset access into struct task_struct")
int kernel_btf_array_out_of_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct task_struct *task;
int val = 0;
task = bpf_get_current_task_btf();
asm volatile (" \
r1 = %[task]; \
r1 += %[off]; \
r2 = %[i]; \
r2 &= 31; \
r1 += r2; \
%[val] = *(u8 *)(r1 + 0); \
" : [val] "=r"(val)
: [task] "r"(task), [i] "r"(i),
[off] "i"(offsetof(struct task_struct, comm))
: "r1", "r2");
return val;
}
/*
* Array nested below a struct member at a non-zero offset. The walk descends
* through 'm' (resetting the running offset) before reaching 'arr', exercising
* the array_start = min_off - arrays[i].off telescoping across a WALK_STRUCT
* dive.
*/
struct mid {
struct inner arr[8]; /* stride 8, size 64 */
};
struct nest {
long pad; /* off 0 */
struct mid m; /* off 8 */
};
/* m.arr[i].b, i in [0, 7], 4-byte read: stays within m.arr. */
SEC("syscall")
__success
int nested_struct_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct nest *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 7; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 12); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/* m.arr[i].b, i in [0, 15]: max offset runs past the end of m.arr. */
SEC("syscall")
__failure
__msg("invalid variable offset access into struct nest")
int nested_struct_out_of_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct nest *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 15; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 12); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
/*
* A trailing flexible array member makes the struct tail an unbounded region,
* so a varying access into it has no upper bound to exceed (mirrors how
* unix_address.name[] is accessed via sun_path[i]).
*
* A custom (program) BTF struct can only be reached as a PTR_TO_BTF_ID through
* bpf_obj_new(), which does not allow flexible array members. So use a kernel
* type via an untrusted PTR_TO_BTF_ID (bpf_core_cast()). struct vring_used ends
* with a flexible array 'ring[]' of struct vring_used_elem { __virtio32 id, len; },
* mirroring a 'struct foo { int a; int b; }' flexible array.
*/
/* ring[i].len, i in [0, 63], 4-byte read: the flexible array has no upper bound. */
SEC("syscall")
__success
int flex_array_field(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct vring_used *o;
int val = 0;
o = bpf_core_cast(bpf_get_current_task_btf(), struct vring_used);
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 63; \
r2 *= 8; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 8); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
return val;
}
/*
* ring[] accessed with step 4 (half of sizeof(struct vring_used_elem)): the
* step is not a whole number of elements, so the flexible array stride does
* not match.
*/
SEC("syscall")
__failure
__msg("invalid variable offset access into struct vring_used")
int flex_array_unaligned_step(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct vring_used *o;
int val = 0;
o = bpf_core_cast(bpf_get_current_task_btf(), struct vring_used);
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 7; \
r2 *= 4; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 4); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i)
: "r1", "r2");
return val;
}
/*
* Access either name[0].sun_path[0] or one byte past sun_path.
* Step 108 does not match sizeof(struct sockaddr_un), which is 110.
* It matches the inner char array's stride, but exceeds its bounds.
* The flexible-tail exemption must not apply to that fixed array.
*/
SEC("syscall")
__failure
__msg("invalid variable offset access into struct unix_address")
int flex_array_inner_array_out_of_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct unix_address *o;
int val = 0;
o = bpf_core_cast(bpf_get_current_task_btf(), struct unix_address);
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 1; \
r2 *= %[len]; \
r1 += r2; \
%[val] = *(u8 *)(r1 + %[off]); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i),
__imm_const(len, sizeof_field(struct sockaddr_un, sun_path)),
__imm_const(off, offsetof(struct unix_address, name) +
offsetof(struct sockaddr_un, sun_path))
: "r1", "r2");
return val;
}
typedef int array_element_t;
typedef array_element_t array_type_t[4];
struct typedef_array {
array_type_t values;
};
/*
* Resolving values' size crosses both the array and element typedefs.
* Record the array ID, not the int ID left by element-type resolution.
* values[i], i in [0, 3], must pass the variable-offset array check.
*/
SEC("syscall")
__success
int typedef_array_in_bounds(void *ctx)
{
unsigned long i = bpf_get_prandom_u32();
struct typedef_array *o;
int val = 0;
o = bpf_obj_new(typeof(*o));
if (!o)
return 0;
asm volatile (" \
r1 = %[o]; \
r2 = %[i]; \
r2 &= 3; \
r2 *= %[elem_size]; \
r1 += r2; \
%[val] = *(u32 *)(r1 + 0); \
" : [val] "=r"(val)
: [o] "r"(o), [i] "r"(i),
__imm_const(elem_size, sizeof(array_element_t))
: "r1", "r2");
bpf_obj_drop(o);
return val;
}
char _license[] SEC("license") = "GPL";