CVE-2026-46242
Beschrijving NL
In de Linux kernel is de volgende kwetsbaarheid verholpen:
eventpoll: ep_remove struct eventpoll/ struct file UAF repareren
ep_remove() (via ep_remove_file()) gewist bestand->f_ep onder
file->f_lock maar bleef vervolgens @file gebruiken in de kritieke sectie
(is_file_epoll(), hlist_del_rcu() door het hoofd, spin_unlock). Een gelijktijdig __fput() nemen van het eventpoll_release() fastpath in
dat venster de voorbijgaande NUL observeerde, overgeslagen
eventpoll_release_file() en liep naar f_op->release / file_free(). Voor de epoll-horloges-epoll case is f_op->release
ep_eventpoll_release() -> ep_clear_and_put() -> ep_free(), die
kfree()s de bekeken struct eventpoll. Zijn ingebedde ->refs
hlist_head is precies waar epi->fllink.pprev punten, dus de
volgende hlist_del_rcu() 's "*pprev = next" krabbelt in bevrijd
kmalloc-192 geheugen. Bovendien is het STRUCT-bestand SLAB_TYPESAFE_BY_RCU, dus de sleuf
backing @file kan worden gerecycled door alloc_empty_file() --
f_lock en f_ep opnieuw initialiseren -- terwijl ep_remove() nog steeds
nominaal in dat slot. Het resultaat is een aanvaller-controleerbaar
kmem_cache_free() tegen de verkeerde slab-cache. Pin @file via epi_fget() bovenaan ep_remove() en gate de
kritieke sectie op de pin geslaagd. Met de pincode vastgehouden @file
kan refcount nul niet bereiken, wat __fput() uit en
houdt de bekeken struct eventpoll in leven over de
hlist_del_rcu () en het f_lock-gebruik, waardoor beide UAF's worden gesloten. Als de pin mislukt @file has already reached refcount zero and its
__fput() is onderweg. Omdat we zijn gestopt voordat we f_ep hebben opgeruimd,
dat pad neemt het langzame pad eventpoll_release() mee naar
eventpoll_release_file() en blokkeert op ep->mtx tot de ober
ep_clear_and_put() van side laat het vallen. Het aandeel van de op borgtocht betaalde epi in
ep->refcount blijft intact, zodat de achterliggende ep_refcount_dec_and_test()
in ep_clear_and_put() kan de eventpoll niet vrijmaken van onder
eventpoll_release_file(); de verweesde epi wordt daar vervolgens opgeruimd. Een succesvolle pin bewijst ook dat we niet racen
eventpoll_release_file() op deze epi, dus laat de nu overbodige
opnieuw controleren van epi->sterven onder f_lock. De goedkope lockless
READ_ONCE(epi->dying) fast-path bailout blijft.
Origineel (Engels) tonen
In the Linux kernel, the following vulnerability has been resolved:
eventpoll: fix ep_remove struct eventpoll / struct file UAF
ep_remove() (via ep_remove_file()) cleared file->f_ep under
file->f_lock but then kept using @file inside the critical section
(is_file_epoll(), hlist_del_rcu() through the head, spin_unlock).
A concurrent __fput() taking the eventpoll_release() fastpath in
that window observed the transient NULL, skipped
eventpoll_release_file() and ran to f_op->release / file_free().
For the epoll-watches-epoll case, f_op->release is
ep_eventpoll_release() -> ep_clear_and_put() -> ep_free(), which
kfree()s the watched struct eventpoll. Its embedded ->refs
hlist_head is exactly where epi->fllink.pprev points, so the
subsequent hlist_del_rcu()'s "*pprev = next" scribbles into freed
kmalloc-192 memory.
In addition, struct file is SLAB_TYPESAFE_BY_RCU, so the slot
backing @file could be recycled by alloc_empty_file() --
reinitializing f_lock and f_ep -- while ep_remove() is still
nominally inside that lock. The upshot is an attacker-controllable
kmem_cache_free() against the wrong slab cache.
Pin @file via epi_fget() at the top of ep_remove() and gate the
critical section on the pin succeeding. With the pin held @file
cannot reach refcount zero, which holds __fput() off and
transitively keeps the watched struct eventpoll alive across the
hlist_del_rcu() and the f_lock use, closing both UAFs.
If the pin fails @file has already reached refcount zero and its
__fput() is in flight. Because we bailed before clearing f_ep,
that path takes the eventpoll_release() slow path into
eventpoll_release_file() and blocks on ep->mtx until the waiter
side's ep_clear_and_put() drops it. The bailed epi's share of
ep->refcount stays intact, so the trailing ep_refcount_dec_and_test()
in ep_clear_and_put() cannot free the eventpoll out from under
eventpoll_release_file(); the orphaned epi is then cleaned up
there.
A successful pin also proves we are not racing
eventpoll_release_file() on this epi, so drop the now-redundant
re-check of epi->dying under f_lock. The cheap lockless
READ_ONCE(epi->dying) fast-path bailout stays.