Skip to contentSkip to conversation

bpf: Reject arena frees below the arena base

PATCH Superseded Yiyang Chen 2 participants 6 messages Jun 30 – Jul 2

Subsystems (3)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover bpf: Reject arena frees below the arena base

bpf_arena_free_pages() can be called with a scalar arena address. The runtime reconstructs a full user address from the arena base and the low 32 bits before returning the range to the arena free tree. A scalar one page below the arena base can otherwise produce an out-of-domain free-tree offset and make a later allocation return an address below the arena mapping.

Patch 1 rejects frees whose reconstructed full user address is below user_vm_start. Patch 2 adds verifier_arena coverage for the scalar-below-base case.

Yiyang Chen (2):
bpf: Reject arena frees below the arena base selftests/bpf: Cover scalar arena frees below the base

 kernel/bpf/arena.c                            |  2 +
 .../selftests/bpf/progs/verifier_arena.c      | 41 ++++++++++++++++---
 2 files changed, 38 insertions(+), 5 deletions(-)

base-commit: 7feeed42d8b97d0db0eab2c1c30aa86f110fe49c

Signature · 1 line
2.34.1
#1 lore raw

PATCH 1/2 bpf: Reject arena frees below the arena base

bpf_arena_free_pages() accepts scalar arena addresses. The runtime masks the address to the low 32 bits and reconstructs a full user address from the arena base before returning the range to the arena free tree.

When the scalar value is below the low 32 bits of the arena base, full_uaddr falls below user_vm_start. The existing upper-end clipping then turns this into an out-of-range free-tree offset. A later allocation can reuse that offset and return an address below the arena mapping.

Reject such frees before computing the clipped range.

Fixes 317460317a02a ("bpf: Introduce bpf_arena.")
---
 kernel/bpf/arena.c | 2 ++
 1 file changed, 2 insertions(+)
kernel/bpf/arena.c +2 -0
index 49a8f7b1beef5..e28e83bed8c51 100644
@@ -693,6 +693,8 @@ static void arena_free_pages(struct bpf_arena *arena, long uaddr, long page_cnt,
 	uaddr &= PAGE_MASK;
 	kaddr = bpf_arena_get_kern_vm_start(arena) + uaddr;
 	full_uaddr = clear_lo32(arena->user_vm_start) + uaddr;
+	if (full_uaddr < arena->user_vm_start)
+		return;
 	uaddr_end = min(arena->user_vm_end, full_uaddr + (page_cnt << PAGE_SHIFT));
 	if (full_uaddr >= uaddr_end)
 		return;
Signature · 1 line
2.34.1
reviewer Reviewed-by on v1 1/2
#2 lore raw
Quoted 11 lines · Yiyang Chen

bpf_arena_free_pages() accepts scalar arena addresses. The runtime masks the address to the low 32 bits and reconstructs a full user address from the arena base before returning the range to the arena free tree.

When the scalar value is below the low 32 bits of the arena base, full_uaddr falls below user_vm_start. The existing upper-end clipping then turns this into an out-of-range free-tree offset. A later allocation can reuse that offset and return an address below the arena mapping.

This seems reasonable, my understanding is that this happens because neither arena start nor end actually has to be aligned at a 4GiB boundary, while the underlying kernel mapping does span the full 32 bits. AFAICT this bug returns an address that is not actually mapped into userspace and is inaccessible from it, correct?

If the above is correct, feel free to add:

Quoted 21 lines

Reject such frees before computing the clipped range.

Fixes 317460317a02a ("bpf: Introduce bpf_arena.")
---
 kernel/bpf/arena.c | 2 ++
 1 file changed, 2 insertions(+)
kernel/bpf/arena.c +2 -0
index 49a8f7b1beef5..e28e83bed8c51 100644
@@ -693,6 +693,8 @@ static void arena_free_pages(struct bpf_arena *arena, long uaddr, long page_cnt,
 	uaddr &= PAGE_MASK;
 	kaddr = bpf_arena_get_kern_vm_start(arena) + uaddr;
 	full_uaddr = clear_lo32(arena->user_vm_start) + uaddr;
+	if (full_uaddr < arena->user_vm_start)
+		return;
 	uaddr_end = min(arena->user_vm_end, full_uaddr + (page_cnt << PAGE_SHIFT));
 	if (full_uaddr >= uaddr_end)
 		return;
#3 lore raw
Quoted 2 lines · Emil Tsalapatis

AFAICT this bug returns an address that is not actually mapped into userspace and is inaccessible from it, correct?

Yes, that is my understanding as well.

The bad free is below user_vm_start in the user VMA. The issue is that arena_free_pages() still used the low 32 bits to compute the free-tree offset, so the one-page-below address wrapped to an out-of-domain pgoff. A later bpf_arena_alloc_pages() could then return an address outside [user_vm_start, user_vm_end).

So user space should not be able to access that address through the arena mmap; the fix is to keep that out-of-domain offset from entering the arena allocator state in the first place.

Quoted 2 lines

If the above is correct, feel free to add:

Thanks, will add it to v2.

Yiyang

#4 lore raw

PATCH 2/2 selftests/bpf: Cover scalar arena frees below the base

In reply to Yiyang Chen

Add a verifier_arena case that fills a two-page arena, calls bpf_arena_free_pages() with a scalar address one page below the arena base, and then verifies that another allocation is still rejected.

Before the runtime guard, the invalid free can repopulate the free tree with an out-of-domain offset and the final allocation succeeds.

---
 .../selftests/bpf/progs/verifier_arena.c      | 41 ++++++++++++++++---
 1 file changed, 36 insertions(+), 5 deletions(-)
tools/testing/selftests/bpf/progs/verifier_arena.c +36 -5
index 62e282f4448aa..b4bd134646607 100644
@@ -12,15 +12,17 @@
 
 #define private(name) SEC(".bss." #name) __hidden __attribute__((aligned(8)))
 
+#ifdef __TARGET_ARCH_arm64
+#define ARENA_VM_START ((1ull << 32) | (~0u - __PAGE_SIZE * 2 + 1))
+#else
+#define ARENA_VM_START ((1ull << 44) | (~0u - __PAGE_SIZE * 2 + 1))
+#endif
+
 struct {
 	__uint(type, BPF_MAP_TYPE_ARENA);
 	__uint(map_flags, BPF_F_MMAPABLE);
 	__uint(max_entries, 2); /* arena of two pages close to 32-bit boundary*/
-#ifdef __TARGET_ARCH_arm64
-        __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
-#else
-        __ulong(map_extra, (1ull << 44) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
-#endif
+	__ulong(map_extra, ARENA_VM_START); /* start of mmap() region */
 } arena SEC(".maps");
 
 SEC("socket")
@@ -93,6 +95,35 @@ int basic_alloc1(void *ctx)
 	return 0;
 }
 
+SEC("syscall")
+__success __retval(0)
+int free_scalar_below_arena(void *ctx)
+{
+	void __arena *page1, *page2, *page3;
+	__u64 bad_addr = ARENA_VM_START - __PAGE_SIZE;
+
+	page1 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (!page1)
+		return 1;
+
+	page2 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (!page2)
+		return 2;
+
+	page3 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (page3)
+		return 3;
+
+	asm volatile("" : "+r"(bad_addr));
+	bpf_arena_free_pages(&arena, (void __arena *)bad_addr, 1);
+
+	page3 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (page3)
+		return 4;
+
+	return 0;
+}
+
 SEC("socket")
 __success __retval(0)
 int basic_alloc2_nosleep(void *ctx)
Signature · 1 line
2.34.1
reviewer Reviewed-by on v1 2/2
#5 lore raw

Re: [PATCH bpf-next 2/2] selftests/bpf: Cover scalar arena frees below the base

Quoted 8 lines · Yiyang Chen

Add a verifier_arena case that fills a two-page arena, calls bpf_arena_free_pages() with a scalar address one page below the arena base, and then verifies that another allocation is still rejected.

Before the runtime guard, the invalid free can repopulate the free tree with an out-of-domain offset and the final allocation succeeds.

Nit/question below.

Quoted 45 lines
---
 .../selftests/bpf/progs/verifier_arena.c      | 41 ++++++++++++++++---
 1 file changed, 36 insertions(+), 5 deletions(-)
tools/testing/selftests/bpf/progs/verifier_arena.c +17 -5
index 62e282f4448aa..b4bd134646607 100644
@@ -12,15 +12,17 @@
 
 #define private(name) SEC(".bss." #name) __hidden __attribute__((aligned(8)))
 
+#ifdef __TARGET_ARCH_arm64
+#define ARENA_VM_START ((1ull << 32) | (~0u - __PAGE_SIZE * 2 + 1))
+#else
+#define ARENA_VM_START ((1ull << 44) | (~0u - __PAGE_SIZE * 2 + 1))
+#endif
+
 struct {
 	__uint(type, BPF_MAP_TYPE_ARENA);
 	__uint(map_flags, BPF_F_MMAPABLE);
 	__uint(max_entries, 2); /* arena of two pages close to 32-bit boundary*/
-#ifdef __TARGET_ARCH_arm64
-        __ulong(map_extra, (1ull << 32) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
-#else
-        __ulong(map_extra, (1ull << 44) | (~0u - __PAGE_SIZE * 2 + 1)); /* start of mmap() region */
-#endif
+	__ulong(map_extra, ARENA_VM_START); /* start of mmap() region */
 } arena SEC(".maps");
 
 SEC("socket")
@@ -93,6 +95,35 @@ int basic_alloc1(void *ctx)
 	return 0;
 }
 
+SEC("syscall")
+__success __retval(0)
+int free_scalar_below_arena(void *ctx)
+{
+	void __arena *page1, *page2, *page3;
+	__u64 bad_addr = ARENA_VM_START - __PAGE_SIZE;
+
+	page1 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (!page1)
+		return 1;

tools/testing/selftests/bpf/progs/verifier_arena.c int basic_alloc1(void *ctx) · line 117

Quoted 10 lines
tools/testing/selftests/bpf/progs/verifier_arena.c +10 -0
+
+	page2 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (!page2)
+		return 2;
+
+	page3 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (page3)
+		return 3;
+
+	asm volatile("" : "+r"(bad_addr));

Why the asm volatile? We use it right underneath, what does this give us.

Quoted 12 lines
tools/testing/selftests/bpf/progs/verifier_arena.c +9 -0
+	bpf_arena_free_pages(&arena, (void __arena *)bad_addr, 1);
+
+	page3 = bpf_arena_alloc_pages(&arena, NULL, 1, NUMA_NO_NODE, 0);
+	if (page3)
+		return 4;
+
+	return 0;
+}
+
 SEC("socket")
 __success __retval(0)
 int basic_alloc2_nosleep(void *ctx)