CVE-2026-12366
Beschrijving NL
Zephyr's dynamische kernel-object verwijderingspad unref_check() in kernel/userspace/userspace.c bevrijdt de opslag van een object (k_free(dyn- >data)) zodra het aantal referenties nul bereikt, na het uitvoeren van een opschoning per objecttype. De opruimschakelaar behandelde alleen K_obj_MSGQ en K_obj_STACK; er was geen K_obj_timer-case. Een dynamisch toegewezen, geïnitialiseerde en gewapende k_timer houdt de ingesloten struct _timeout dnode gekoppeld in de wereldwijde time-outwachtrij (_timeout_q), dus het vrijmaken van de timeropslag zonder de time-out te annuleren, laat een bungelende node achter in die wachtrij. Wanneer de timer vervolgens verloopt, loopt de time-outmachine_timeout_q en roept z_timer_expiration_handler() aan op het bevrijde knooppunt, dereferencing en schrijven van bevrijde (en herbruikbare) kernelheap in kernel/ISR-context. Dit is een deterministisch gebruik-na-vrij dat niet afhankelijk is van SMP: het knooppunt in de wachtrij wordt gewoon nooit in de vrije tijd losgekoppeld. De verwijdering is bereikbaar vanuit een niet-bevoorrechte gebruikersthread onder CONFIG_USERSPACE + CONFIG_DYNAMIC_OBJECTS: een thread die de laatste toestemming op een dergelijke timer heeft, laat deze vallen via de k_object_release() syscall (of door af te sluiten, via k_thread_perms_all_clear()), en kan de timer zelf inschakelen via de k_timer_start() syscall. De free en de expiration handler draaien op kernel privilege terwijl de actor een user thread is, dus de bug is een sandbox-escape geheugencorruptie primitief bruikbaar voor privilege escalatie. De oplossing voegt k_timer_cleanup() toe (annuleer de time-out en wacht op een afhandelaar tijdens de vlucht) en roept deze op voor K_obj_TIMER voordat deze wordt vrijgegeven.
Origineel (Engels) tonen
Zephyr's dynamic kernel-object disposal path unref_check() in kernel/userspace/userspace.c frees an object's storage (k_free(dyn->data)) once its reference count reaches zero, after running a per-object-type cleanup. The cleanup switch handled only K_OBJ_MSGQ and K_OBJ_STACK; there was no K_OBJ_TIMER case. A dynamically-allocated, initialized, and armed k_timer keeps its embedded struct _timeout dnode linked in the global timeout queue (_timeout_q), so freeing the timer storage without cancelling the timeout leaves a dangling node in that queue.
When the timer next expires, the timeout machinery walks _timeout_q and invokes z_timer_expiration_handler() on the freed node, dereferencing and writing freed (and reusable) kernel heap in kernel/ISR context. This is a deterministic use-after-free that does not depend on SMP: the queued node is simply never unlinked at free time.
The disposal is reachable from an unprivileged user thread under CONFIG_USERSPACE + CONFIG_DYNAMIC_OBJECTS: a thread that holds the last permission on such a timer drops it via the k_object_release() syscall (or by exiting, through k_thread_perms_all_clear()), and can arm the timer itself via the k_timer_start() syscall. The free and the expiration handler run at kernel privilege while the actor is a user thread, so the bug is a sandbox-escape memory-corruption primitive usable for privilege escalation. The fix adds k_timer_cleanup() (cancel the timeout and wait for any in-flight handler) and calls it for K_OBJ_TIMER before freeing.