From 5e42a656cf4b28867203c0fcf7ad69c99cb11667 Mon Sep 17 00:00:00 2001 From: tunnell Date: Mon, 20 Apr 2026 07:38:42 -0500 Subject: [PATCH] Check for overflow in IncreaseHeap syscall `process_inner.mem_heap_size + delta` can wrap on RV32 if a client requests a `delta` close to `usize::MAX`. A wrapped value can land below `mem_heap_max` and pass the cap check, letting the call proceed with a bogus heap size. Use `checked_add` and return `Error::OutOfMemory` on overflow. Adds a hosted-mode behavioral test that sends `usize::MAX` as `delta` and asserts the syscall rejects it. The test doesn't cleanly distinguish patched from unpatched code on 64-bit hosted (both paths reject absurd deltas, just at different layers), but it locks in the expected behavior as regression coverage. Signed-off-by: tunnell Assisted-by: Claude Code (Opus 4.7) --- kernel/src/syscall.rs | 8 ++++++-- kernel/src/test.rs | 32 ++++++++++++++++++++++++++++++++ 2 files changed, 38 insertions(+), 2 deletions(-) diff --git a/kernel/src/syscall.rs b/kernel/src/syscall.rs index f17bd17d2..66fc53aeb 100644 --- a/kernel/src/syscall.rs +++ b/kernel/src/syscall.rs @@ -828,12 +828,16 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR let start = { ArchProcess::with_inner_mut(|process_inner| { - if process_inner.mem_heap_size + delta > process_inner.mem_heap_max { + let new_size = process_inner + .mem_heap_size + .checked_add(delta) + .ok_or(xous_kernel::Error::OutOfMemory)?; + if new_size > process_inner.mem_heap_max { return Err(xous_kernel::Error::OutOfMemory); } let start = process_inner.mem_heap_base + process_inner.mem_heap_size; - process_inner.mem_heap_size += delta; + process_inner.mem_heap_size = new_size; Ok(start as *mut u8) })? }; diff --git a/kernel/src/test.rs b/kernel/src/test.rs index 2e52c8329..e320cb71a 100644 --- a/kernel/src/test.rs +++ b/kernel/src/test.rs @@ -1210,3 +1210,35 @@ fn renormalizer() { assert!(max_element < TEST_LEN as u32); } } + +/// `IncreaseHeap` must reject a `delta` that would overflow +/// `mem_heap_size + delta`. On an RV32 target, a large `delta` +/// silently wraps past `mem_heap_size` in unchecked arithmetic, +/// which can land below `mem_heap_max` and bypass the cap check. +/// Hosted `usize` is 64-bit so the 32-bit wrap isn't directly +/// triggerable here, but the syscall must still reject an absurd +/// delta cleanly. +#[test] +fn increase_heap_rejects_absurd_delta() { + let main_thread = start_kernel(SERVER_SPEC); + + let xous_client = xous_kernel::create_process_as_thread(xous_kernel::ProcessArgsAsThread::new( + "increase_heap_overflow", + move || { + let flags = xous_kernel::MemoryFlags::R | xous_kernel::MemoryFlags::W; + + // A normal call should succeed. + let ok = xous_kernel::increase_heap(4096, flags); + assert!(ok.is_ok(), "small IncreaseHeap should succeed, got {:?}", ok); + + // A pathological delta should be rejected, not silently accepted. + let err = xous_kernel::increase_heap(usize::MAX, flags); + assert!(err.is_err(), "usize::MAX delta must be rejected, got {:?}", err); + }, + )) + .expect("spawn client"); + + crate::wait_process_as_thread(xous_client).expect("join client"); + shutdown_kernel(); + main_thread.join().expect("join kernel"); +}