CVE-2026-52910 — reuseport cBPF use-after-free रिप्रोड्यूसर

CVE-2026-52910 के लिए एक रेस रिप्रोड्यूसर और स्ट्रेस टूलकिट, जो Linux kernel के classic BPF (cBPF) reuseport selector प्रोग्राम के हैंडलिंग में एक use-after-free (UAF) है, जिसे upstream में commit "bpf: Free reuseport cBPF prog after RCU grace period" द्वारा ठीक किया गया है।

[!WARNING] यह एक kernel स्ट्रेस टूल है। कमजोर kernel पर यह जानबूझकर एक use-after-free रेस विंडो को चौड़ा करता है; एक हिट मशीन को क्रैश या करप्ट कर सकती है। इसे केवल उन मशीनों पर चलाएँ जिनके आप मालिक हैं या जिन्हें परीक्षण के लिए स्पष्ट रूप से अधिकृत किया गया है (टेस्ट VM, अस्थायी CI मशीनें), कभी भी प्रोडक्शन सिस्टम पर नहीं।

एक मिनट में बग

SO_REUSEPORT कई sockets को एक ही UDP पोर्ट बाइंड करने देता है; प्रत्येक आने वाले पैकेट के लिए kernel reuseport_select_sock() (net/core/sock_reuseport.c) में समूह के एक socket को चुनता है। एक समूह एक selector प्रोग्राम इंस्टॉल कर सकता है — एक classic BPF प्रोग्राम जो setsockopt(SO_ATTACH_REUSEPORT_CBPF) के साथ अटैच किया जाता है — जो प्रति पैकेट तय करता है कि समूह का कौन सा socket इसे प्राप्त करेगा। प्रोग्राम RX softirq (नेटवर्क रिसीव प्रोसेसिंग) में एक RCU read-side critical section के अंदर निष्पादित होता है।

बग: जब प्रोग्राम को setsockopt() (reuseport_attach_prog() / reuseport_detach_prog()) के माध्यम से बदला या डिटैच किया जाता है, तो पुराना cBPF प्रोग्राम sk_reuseport_prog_free() द्वारा तुरंत फ्री कर दिया जाता है, बिना इन-फ्लाइट RCU रीडर्स की प्रतीक्षा किए। एक CPU जो अभी भी फ्री किए गए प्रोग्राम के निर्देशों को चला रहा है, फ्री की गई vmalloc'd मेमोरी पढ़ता है:

sequenceDiagram
    autonumber
    participant C as CPU0 — churner thread
    participant K as setsockopt() path
    participant R as CPU1 — RX softirq

    R->>R: rcu_read_lock()
    R->>R: prog = rcu_dereference(reuse->prog)
    C->>K: setsockopt(SO_ATTACH_REUSEPORT_CBPF, progB)
    K->>K: swap progA → progB
    K->>K: sk_reuseport_prog_free(progA)
    Note right of K: unfixed kernels: bpf_prog_free()<br/>runs NOW — no RCU grace period
    R->>R: execute progA->insns (run_bpf_filter)
    Note right of R: progA was already freed<br/>KASAN: vmalloc-out-of-bounds
    Note over K: fix: call_rcu(sk_reuseport_prog_free_rcu) —<br/>free deferred by one RCU grace period

eBPF selector पथ (SO_ATTACH_REUSEPORT_EBPF) प्रभावित नहीं है: यह पहले से ही प्रोग्राम को deferred bpf_prog_put() चरणों के माध्यम से रिलीज़ करता है। फिक्स cBPF पथ को भी वही व्यवहार देता है — पुराने प्रोग्राम के फ्री होने से पहले एक RCU grace period।

Upstream KASAN रिपोर्ट (7.0 डीबग kernel पर):

BUG: KASAN: vmalloc-out-of-bounds in reuseport_select_sock+0xedc/0x1220
Read of size 4 at addr ffffc9000051e004 by task slowme/10208
 net/core/sock_reuseport.c:596

इस रेपो में क्या है

त्वरित शुरुआत

एक Linux टेस्ट बॉक्स पर:

$ make
$ sudo ./run_hammer.sh 600        # 10-minute run
...
== result: RC=0 (0 clean / 1 setup / 2 splat / 3 leak / 4 integrity) ==

आवश्यकताएँ:

• एक Linux टेस्ट बॉक्स जिसे आप क्रैश कर सकते हैं (VM या बेयर मेटल)। एक KASAN-सक्षम kernel की दृढ़ता से सिफारिश की जाती है — KASAN के बिना, एक रेस हिट पूरी तरह से अनदेखी रह सकती है।
• gcc और bash।
• रैपर की जाँचों के लिए root (dmesg, /proc/vmallocinfo, sysctl); हैमर स्वयं अनप्रिविलेज्ड चलता है (upstream रिप्रो UID 1000 के रूप में चला)।
• एक आइडल मशीन: बैकग्राउंड ट्रैफ़िक और अन्य BPF उपयोगकर्ता लीक चेक में शोर जोड़ते हैं।
• हैमर 21000 से शुरू होने वाले UDP पोर्ट बाइंड करता है (प्रति reuseport समूह एक पोर्ट) — सुनिश्चित करें कि वे खाली हैं।

अपेक्षित परिणाम:

• कमजोर kernel — dmesg में KASAN splat → RC=2; कभी-कभी हैमर की इंटीग्रिटी चेक पहले फायर होती है → RC=4।
• फिक्स्ड kernel — साफ़ रन, RC=0, स्थिर bpf_prog vmalloc गिनती।

रेस विंडो बहुत छोटी है (फ्री बनाम इन-फ्लाइट RX निष्पादन), इसलिए एकल साफ़ रन को अनिर्णायक मानें। वास्तविक परीक्षण के लिए घंटों चलाएँ, उदाहरण:

$ sudo ./run_hammer.sh 86400 512 8 16 4 127.0.0.1 0

हैमर: reuseport_race_hammer

$ ./reuseport_race_hammer [dur_sec] [insns] [nports] [nsocks] [nsenders] [ip] [ebpf]

प्रत्येक समूह एक churner थ्रेड चलाता है जो एक टाइट लूप में setsockopt() के माध्यम से cBPF selector को स्वैप और डिटैच करता है, और sender थ्रेड्स समूह पर 64-बाइट UDP डेटाग्राम फ्लड करते हैं जबकि रिसीवर्स प्रति-socket डिलीवरी गिनते हैं।

रन चरण (T = dur_sec):

time ──────────────────────────────────────────────────────────────►
 [0 ──────────── T-15s)   [T-15s ── T-10s)   [T-10s ─────────── T]
       CHURN + FLOOD             SETTLE               MEASURE
 churner swaps/detaches    churn frozen,       deterministic program
 the selector prog at      final program       (selects the LAST
 max rate under full       attached             socket): EVERY packet
 UDP flood — THE           (selects LAST        must land on the LAST
 race window open          socket)              socket; snapshot A →
                                               run → snapshot B

इंटीग्रिटी चेक: माप चरण के दौरान अंतिम प्रोग्राम समूह के अंतिम socket को नियतात्मक रूप से चुनता है। यदि उस विंडो के दौरान समूह द्वारा प्राप्त पैकेट सभी उस socket पर नहीं पहुँचे, तो चयन गलत हुआ (KASAN के बिना भी एक संभावित UAF प्रभाव) → exit code 2।

हैमर exit codes: 0 PASS · 1 setup/runtime error · 2 integrity WARN।

run_hammer.sh — वन-रन रैपर

हैमर चलाता है और वे जाँचें जोड़ता है जो एकल रन को सार्थक बनाती हैं:

1. /proc/vmallocinfo में bpf_prog allocation गिनती का स्नैपशॉट लेता है;
2. net.core.optmem_max बढ़ाता है ताकि मल्टी-KB cBPF प्रोग्राम साफ़ तौर पर अटैच हों;
3. हैमर चलाता है;
4. RCU/workqueue deferred frees के पूरा होने के लिए DRAIN (डिफ़ॉल्ट 30s) प्रतीक्षा करता है;
5. dmesg में नए splats स्कैन करता है (BUG:, Oops:, WARNING:, RIP:, leaked, stuck);
6. पहले/बाद में bpf_prog vmalloc गिनती की तुलना करता है (लीक चेक), और यदि /sys/kernel/debug/kmemleak मौजूद है तो वैकल्पिक रूप से kmemleak स्कैन करता है।

Exit codes: 0 साफ़ · 1 setup त्रुटि (हैमर setup विफलता सहित) · 2 kernel splat देखा गया · 3 संभावित bpf_prog लीक · 4 हैमर इंटीग्रिटी WARN।

livepatch_cycle.sh — livepatch लाइफसाइकल परीक्षण

फिक्स पुराने cBPF प्रोग्राम को एक call_rcu() कॉलबैक से फ्री करता है। यदि आप फिक्स को livepatch (kernel live patching — चल रहे kernel में पैच किया गया कोड) के रूप में शिप करते हैं, तो कॉलबैक फ़ंक्शन स्वयं पैच मॉड्यूल में रहता है: कॉलबैक के अभी भी लंबित रहते हुए एक revert/unload कॉलबैक के पैरों के नीचे से मॉड्यूल टेक्स्ट को फ्री कर देता है। यह स्क्रिप्ट apply/revert चक्रों का अभ्यास करती है जबकि हैमर रेस विंडो को गर्म रखता है, और /sys/kernel/livepatch/*/transition और dmesg पर नज़र रखती है।

$ MODE=rcu ./livepatch_cycle.sh 20 120    # 20 cycles × 120s hammer each

Exit codes: 0 साफ़ · 1 कमांड विफलता · 2 splat या अटका हुआ transition · 4 हैमर से इंटीग्रिटी WARN।

CI

CI हैमर को दो फ्लैग सेट्स के साथ बिल्ड करता है और स्क्रिप्ट्स पर shellcheck चलाता है। Kernel रनटाइम टेस्ट जानबूझकर साझा CI रनर्स पर नहीं चलाए जाते: रिप्रोड्यूसर को रनर के kernel संस्करण पर नियंत्रण चाहिए (और कमजोर kernel पर रनर को oops कर सकता है)। उन्हें वास्तविक टेस्ट मशीनों पर चलाएँ।

संदर्भ

• NVD रिकॉर्ड: https://nvd.nist.gov/vuln/detail/CVE-2026-52910
• फिक्स: bpf: Free reuseport cBPF prog after RCU grace period — stable बैकपोर्ट्स: 08264d5bba0b, 18fc650ccd7d, 298db6167f81, 87dfb977bdb6, 90e47dc5c572, c3e3fddda6b5, f8b8f1d4bb76, fec41484e7c2
• Red Hat ट्रैकिंग: https://bugzilla.redhat.com/show_bug.cgi?id=2490779

लाइसेंस

GPL-2.0-only — देखें LICENSE।