Direct naar de inhoud
⚡ Kritieke cyberalerts voor jouw sector & systemen — direct in je inbox. Aanmelden →
CVE's Videos Dagbriefing

← Terug naar CVE-database

CVE-2026-74700

HIGH · 7.8 CVSS Gepubliceerd:

Beschrijving NL

In de Linux kernel is de volgende kwetsbaarheid verholpen:

net/sched: cls_api: Verkrijg altijd rtnl_lock bij het vernietigen van vergrendelde classificaties

Een andere uitdaging met ontgrendelde filters. Er is een kort venster in tc_new_tfilter waar een tcf_proto te vinden is
en waarnaar kort wordt verwezen door een volledig niet-gerelateerd, ontgrendeld classificatieverzoek
en een race veroorzaken. Feng creëerde een poc die deze race creëerde met twee draden, waarvan er één een
u32 filter en andere een bloemenfilter in dezelfde keten/prio:

1. Beide threads voeren tc_new_tfilter in, beide vinden de ketting leeg, beide
druppelfilter_ketting_slot
2. u32 beëindigt eerst tcf_proto_create("u32"), gesprekken
tcf_chain_tp_insert_unique() -> plaatst u32_tp in de ketting
3. bloem eindigt tcf_proto_create("bloem") later, roept
tcf_chain_tp_insert_unique() -> tcf_chain_tp_find() ziet nu u32_tp
al aanwezig, neemt er een verwijzing op, vernietigt de eigen tp_new van de bloem
en geeft u32_tp terug aan de beller. Bloem raakt dan de soort mismatch controle (omdat het verzocht om soort
"bloem" maar tp->ops->soort is "u32") en gaat door het dwaalpad
die tcf_proto_put() aanroept op u32_tp. Als de u32-draad al
door zijn eigen fout gegaan (de change() -oproep is mislukt op de lege PoC's
opties) en liet de refs maken en invoegen, de put van flower is de
laatste en daalt de refcnt van u32_tp naar nul. Op dit moment draaittp->ops- >destroy() in een context die nooit
rtnl_lock. Wanneer dat gebeurt, kan dit een UAF veroorzaken zoals de volgende
(geïllustreerd door de PoC):

[ +0.000710] BUG: KASAN: slab-use-after-free in u32_init (net/sched/cls_u32.c:393)
[ +0.000281] Aflezen van maat 8 op adr ffff888120022f00 door taak poc_feng_xue/524

Oproeptracering:
u32_init (net/sched/cls_u32.c:393)
tc_new_tfilter (net/sched/cls_api.c:2378)

Toegewezen door taak 526:
u32_init (net/sched/cls_u32.c:378)
tc_new_tfilter (net/sched/cls_api.c:2378)

Bevrijd door taak 522: kfree
u32_destroy (net/sched/cls_u32.c:662)
tcf_proto_destroy (net/sched/cls_api.c:446)
tcf_proto_put (net/sched/cls_api.c:459)
tc_new_tfilter (net/sched/cls_api.c:2459)

Los dit op door tcf_proto_destroy() rtnl_lock rond te laten gaan
tp->ops->destroy() voor vergrendelde classifiers wanneer rtnl niet wordt vastgehouden. Om uit te leggen waarom ik een tijdelijke variabele "not_lockless" heb gebruikt, wil ik wijzen op een
semi-gerelateerde opmerking over rtnl_held versus TCF_proto_OPS_DOIT_UNLOCKED (hier toevoegen
voor toekomstige opruiming indien dit nodig wordt geacht):
De parameter rtnl_held en de vlag TCF_proto_OPS_DOIT_UNLOCKED ZIJN
overbodige bronnen van waarheid voor de vraag of rtnl_lock wordt vastgehouden. Van de negen
classificeerder destroy(..rtnl_held..) callbacks, raadpleegt alleen flower de
rtnl_held parameter die het doorstuurt naar tc_setup_cb_destroy()
en tc_setup_cb_call(). De andere acht (u32, flow, bpf, cgroup, route, basic,
fw, mall) het volledig negeren;-> degenen die tc_setup_cb_destroy()
(u32, bpf, mall) hardcode altijd waar in plaats van de parameter door te sturen. Een toekomstige opschoning moet de parameter rtnl_held verwijderen uit de destroy callback
handtekening volledig te ondertekenen en bellers uitsluitend te laten vertrouwen op hun kennis of
ze worden uitgevoerd in een ontgrendelde context.

Origineel (Engels) tonen

In the Linux kernel, the following vulnerability has been resolved:

net/sched: cls_api: Always acquire rtnl_lock when destroying locked classifiers

Another challenge with unlocked filters.
There is a short window in tc_new_tfilter where a tcf_proto can be found
and briefly referenced by a totally unrelated, unlocked classifier's request
and cause a race.

Feng created a poc which created this race with two threads, one creating a
u32 filter and other a flower filter in the same chain/prio:

1. Both threads enter tc_new_tfilter, both find the chain empty, both
drop filter_chain_lock
2. u32 finishes tcf_proto_create("u32") first, calls
tcf_chain_tp_insert_unique() -> inserts u32_tp into the chain
3. flower finishes tcf_proto_create("flower") later, calls
tcf_chain_tp_insert_unique() -> tcf_chain_tp_find() now sees u32_tp
already there, takes a reference on it, destroys flower's own tp_new
and returns u32_tp to the caller.

Flower then hits the kind mismatch check (because it requested for kind
"flower" but tp->ops->kind is "u32") and goes through the errout path
which calls tcf_proto_put() on u32_tp. If the u32 thread has already
gone through its own errout (its change() call failed on the PoC's empty
options) and dropped its create and insert refs, flower's put is the
last one and drops u32_tp's refcnt to zero.

At this point tp->ops->destroy() runs in a context that never took
rtnl_lock. When that happens, it might cause a UAF like the following
(illustrated by the PoC):

[ +0.000710] BUG: KASAN: slab-use-after-free in u32_init (net/sched/cls_u32.c:393)
[ +0.000281] Read of size 8 at addr ffff888120022f00 by task poc_feng_xue/524

Call Trace:
u32_init (net/sched/cls_u32.c:393)
tc_new_tfilter (net/sched/cls_api.c:2378)

Allocated by task 526:
u32_init (net/sched/cls_u32.c:378)
tc_new_tfilter (net/sched/cls_api.c:2378)

Freed by task 522:
kfree
u32_destroy (net/sched/cls_u32.c:662)
tcf_proto_destroy (net/sched/cls_api.c:446)
tcf_proto_put (net/sched/cls_api.c:459)
tc_new_tfilter (net/sched/cls_api.c:2459)

Fix this by having tcf_proto_destroy() take rtnl_lock around
tp->ops->destroy() for locked classifiers whenever rtnl is not held.

To explain why I used a temp variable "not_lockless" I'd like to point to a
semi-related note on rtnl_held vs TCF_PROTO_OPS_DOIT_UNLOCKED (adding here
for future cleanup if deemed necessary):
The rtnl_held parameter and the TCF_PROTO_OPS_DOIT_UNLOCKED flag are
redundant sources of truth for whether rtnl_lock is held. Among the nine
classifier destroy(..rtnl_held..) callbacks, only flower consults the
rtnl_held parameter which it propagates to tc_setup_cb_destroy()
and tc_setup_cb_call(). The other eight (u32, flow, bpf, cgroup, route, basic,
fw, mall) ignore it entirely;-> those that call tc_setup_cb_destroy()
(u32, bpf, mall) hardcode true always instead of forwarding the parameter.

A future cleanup should remove the rtnl_held parameter from the destroy callback
signature entirely and have callers rely solely on their knowledge whether
they are running in an unlocked context.

References