---
id: "CVE-2026-78118"
kind: "vulnerability"
aliases: ["CVE-2026-78118"]
title: "Zephyr RTOS: timer race lets a local thread corrupt kernel memory"
severity: "high"
cvss: 7.0
epss: 0.00083
exploited: false
status: "open"
category: "runtime"
products: []
ecosystems: []
tags: ["embedded", "rtos", "runtime", "smp", "zephyr"]
not_affected_if: ["no-untrusted-local-code", "no-userspace", "uniprocessor-target"]
published_at: "2026-10-21T19:17:03+00:00"
first_seen_at: "2026-10-23T21:57:29+00:00"
updated_at: "2026-10-25T03:37:02+00:00"
sources: [{"source": "nvd", "url": "https://nvd.nist.gov/vuln/detail/CVE-2026-78118", "first_seen_at": "2026-10-23T21:57:29+00:00"}, {"source": "epss", "url": "https://api.first.org/data/v1/epss?cve=CVE-2026-78118", "first_seen_at": "2026-10-24T13:15:54+00:00"}]
---

# Zephyr RTOS: timer race lets a local thread corrupt kernel memory

On multi-CPU Zephyr builds, a race between the timer expiration handler and thread abort can make the kernel write through a stale or invalid thread pointer. A local user-mode thread with CONFIG_USERSPACE can attempt to trigger it, giving out-of-bounds and use-after-free writes in supervisor context that most often crash the kernel.

_Summary, check and fix written by a model from the sources; labelled as such._

## How to check

- Check whether the build sets `CONFIG_MP_MAX_NUM_CPUS` greater than `1` in the device configuration.
- Check whether `CONFIG_USERSPACE` is enabled, since user-mode threads are needed to drive the race.
- Check the Zephyr version in use against the fixed release listed in the NVD entry.

## Fix

- Update Zephyr to the release that includes the fix splitting `z_waitq_head()` and the timer handler locking change, as listed in the NVD entry (version unknown from these sources).
- Rebuild and reflash affected firmware.

## Timeline

- 2026-10-23T21:57:29+00:00 nvd https://nvd.nist.gov/vuln/detail/CVE-2026-78118
- 2026-10-24T13:15:54+00:00 epss https://api.first.org/data/v1/epss?cve=CVE-2026-78118

## From the sources

The kernel helper z_waitq_head() (kernel/include/wait_q.h) reads the head of a thread wait queue, but on SMP systems it was called from several places without holding the scheduler spinlock _sched_spinlock that serializes wait-queue mutation. The consequential call site is z_timer_expiration_handler() in kernel/timer.c, which held only the timer subsystem lock timer_lock while reading timer->wait_q and then unpending, setting the return value of, and readying the thread it obtained. halt_thread() in kernel/sched.c removes an aborted thread from its wait queue while holding only _sched_spinlock, so the two paths are not mutually exclusive.

When the last waiter is removed on another CPU inside that window, sys_dlist_peek_head() can return the list sentinel — a pointer into the k_timer object itself — typed as a struct k_thread * (with CONFIG_WAITQ_SCALABLE, rb_get_min() can return an arbitrary node of a tree being restructured), or it can return a pointer to a thread that has already been unpended and, for dynamically allocated threads, freed. The handler then calls unpend_thread_no_timeout(), which performs a sys_dlist_remove() through pointers read from that object, and arch_thread_return_value_set(), which writes unconditionally through the pointer.

The result is out-of-bounds and use-after-free writes in supervisor context, plus scheduler state corruption; a milder outcome is a thread that has re-pended elsewhere being woken with a success return value from an unrelated blocking call. All of the primitives needed to drive the interleaving — k_timer_start(), k_timer_status_sync(), k_thread_create() and k_thread_abort() — are system calls, so with CONFIG_USERSPACE enabled an unprivileged user-mode thread can attempt the race against kernel-owned data.

Exploitation requires a multi-CPU build (CONFIG_MP_MAX_NUM_CPUS greater than one; the affected region is a no-op on uniprocessor targets), local code execution, and winning a narrow timing window, so the practical outcome is most often a kernel crash rather than controlled corruption. The fix splits the helper into z_waitq_head_locked() for callers that already hold the scheduler spinlock and a z_waitq_head() that acquires it, and brings the timer expiration handler's head read, unpend and ready under a single LOCK_SCHED_SPINLOCK region.

---

_Free to read at a human pace. An API with keys and an MCP server are in preparation; early access: hello@infrastack.ai_