CVE-2026-74714
Beschrijving NL
In de Linux kernel is de volgende kwetsbaarheid verholpen:
bpf: tcp: Fix use-after-free in bpf_iter_tcp_established_batch()
reqsk_queue_hash_req() publiceert een TCP_NEW_syn_RECV request_sock op
de ehash-ketting, laat de bakvergrendeling vallen en zet pas daarna
rsk_refcnt naar 3. Vergrendelbare lezers zoals __inet_lookup_established() behandelen dit met
refcount_inc_not_zero(), maar bpf_iter_tcp_established_batch() gebruikt plain
sock_hold() terwijl u de bakvergrendeling vasthoudt, in de veronderstelling dat de
lock garandeert sk_refcnt > 0. Die veronderstelling geldt niet voor
request_sock:
CPU 0 CPU 1
----- -----
tcp_conn_request()
reqsk_queue_hash_req()
inet_ehash_insert(req)
spin_lock(bak)
__sk_nulls_add_node_rcu(req) // rsk_refcnt == 0
spin_unlock(bucket)
bpf_iter_tcp_established_batch()
spin_lock(bak) sock_hold(req) rsk_refcnt, 3) // clobbers verzadigde waarde
die naar voren komt als:
refcount_t: toevoeging op 0; gebruik-na-vrij. WAARSCHUWING: lib/refcount.c:25 bij refcount_warn_saturate+0x48/0x90, CPU#1
Oproeptracering:
bpf_iter_tcp_established_batch+0x14e/0x170
bpf_iter_tcp_batch+0x53/0x200
bpf_iter_tcp_seq_next+0x27/0x70
bpf_seq_read+0x107/0x410
vfs_read+0xb9/0x380
De gestolen referentie van de iterator gaat verloren wanneer de CPU van de uitgever
refcount_set() overschrijft de telling, waardoor de socket één referentie heeft
kort. Wanneer de laatste legitieme eigenaar zijn referentie laat vallen, is de reqsk
bevrijd terwijl ze nog steeds bereikbaar zijn, wat leidt tot gebruik-na-vrij. Dit reproduceert in seconden met tcp_syncookies =0, een handvol threads
doen connect()/close() met een lokale luisteraar terwijl anderen een
iter/tcp link in een strakke lus. Gebruik refcount_inc_NOT_Zero() en sla de socket over bij een storing. Een overgeslagen
stopcontact is nog steeds onderdeel van de bak, dus blijf het in rekening brengen verwacht. De herallocaties zijn op maat van verwacht, en een verzoek sok waarvan
refcount wordt gepubliceerd terwijl de vergrendeling wordt vastgehouden tijdens de laatste hertoewijzing
moet al ruimte hebben. Een overgeslagen socket wordt geteld in verwacht, maar nooit gebatcht, dus end_sk
kan kort van verwachting zijn op een batch die daadwerkelijk compleet is. Beslis
volledigheid door de vraag of de wandeling in plaats daarvan een stopcontact achterliet. De
WAARSCHUWING na de vergrendelde realloc controleert hetzelfde, ter vervanging van een
end_sk == verwachte controle die dat pad niet kon vasthouden sinds
commit cdec67a489d4 ("bpf: tcp: Zorg ervoor dat iter->batch altijd
bevat een snapshot van een volle emmer "). Als elk bijpassend stopcontact in een emmer mid-init is (refcount 0), END_sk
blijft 0. Ga door naar de volgende emmer in plaats van een batch-invoer te retourneren
die deze ronde nooit was gevuld.
Origineel (Engels) tonen
In the Linux kernel, the following vulnerability has been resolved:
bpf: tcp: Fix use-after-free in bpf_iter_tcp_established_batch()
reqsk_queue_hash_req() publishes a TCP_NEW_SYN_RECV request_sock onto
the ehash chain, drops the bucket lock, and only afterwards sets
rsk_refcnt to 3.
Lockless readers such as __inet_lookup_established() handle this with
refcount_inc_not_zero(), but bpf_iter_tcp_established_batch() uses plain
sock_hold() while holding the bucket lock, on the assumption that the
lock guarantees sk_refcnt > 0. That assumption does not hold for
request_sock:
CPU 0 CPU 1
----- -----
tcp_conn_request()
reqsk_queue_hash_req()
inet_ehash_insert(req)
spin_lock(bucket)
__sk_nulls_add_node_rcu(req) // rsk_refcnt == 0
spin_unlock(bucket)
bpf_iter_tcp_established_batch()
spin_lock(bucket)
sock_hold(req) rsk_refcnt, 3) // clobbers saturated value
which surfaces as:
refcount_t: addition on 0; use-after-free.
WARNING: lib/refcount.c:25 at refcount_warn_saturate+0x48/0x90, CPU#1
Call Trace:
bpf_iter_tcp_established_batch+0x14e/0x170
bpf_iter_tcp_batch+0x53/0x200
bpf_iter_tcp_seq_next+0x27/0x70
bpf_seq_read+0x107/0x410
vfs_read+0xb9/0x380
The iterator's stolen reference is lost when the publishing CPU's
refcount_set() overwrites the count, leaving the socket one reference
short. When the last legitimate owner drops its reference the reqsk is
freed while still reachable, leading to use-after-free.
This reproduces in seconds with tcp_syncookies=0, a handful of threads
doing connect()/close() to a local listener while others read an
iter/tcp link in a tight loop.
Use refcount_inc_not_zero() and skip the socket on failure. A skipped
socket is still part of the bucket, so keep counting it in expected.
The reallocations are sized from expected, and a request sock whose
refcount gets published while the lock is held across the last realloc
must already have room.
A skipped socket is counted in expected but never batched, so end_sk
can be short of expected on a batch that is actually complete. Decide
completeness by whether the walk left any socket behind instead. The
WARN after the locked realloc checks the same, replacing an
end_sk == expected check that could not hold on that path since
commit cdec67a489d4 ("bpf: tcp: Make sure iter->batch always
contains a full bucket snapshot").
If every matching socket in a bucket is mid-init (refcount 0), end_sk
stays 0. Advance to the next bucket rather than returning a batch entry
that was never filled this round.