---

## Katalog

1. CVE-2015-8550
2. CVE-2016-9793
3. 4-20-BPF-integer
4. CVE-2017-5123
5. CVE-2017-6074
6. CVE-2017-7308
7. CVE-2017-8890
8. CVE-2017-11176
9. CVE-2017-16995
10. CVE-2017-1000112
11. CVE-2018-5333
12. CVE-2019-9213 & CVE-2019-8956
13. CVE-2019-15666
14. CVE-2020-8835
15. CVE-2020-27194
16. CVE-2021-3156
17. CVE-2021-31440
18. CVE-2021-3490
19. CVE-2021-22555
20. CVE-2021-41073
21. CVE-2021-4154
22. CVE-2021-42008
23. CVE-2021-43267
24. CVE-2022-0185
25. CVE-2022-0847
26. CVE-2022-0995
27. CVE-2022-1015
28. CVE-2022-2588
29. CVE-2022-2602
30. CVE-2022-2639
31. CVE-2022-25636
32. CVE-2022-27666
33. CVE-2022-32250
34. CVE-2022-34918
35. CVE-2023-2598
36. CVE-2024-1086
37. CVE-2025-21702
38. CVE-2026-23271

---

## Details

#### 1. CVE-2015-8550

[writeup](https://blog.csdn.net/panhewu9919/article/details/100891770) 

**Testversion**: Linux-4.19.65

**Schutz**: KASLR/SMEP aktiviert, SMAP nicht aktiviert.

**Schwachstelle**: Durch gcc-Compileroptimierungen verursachte **Double-Fetch-Schwachstelle**, die direkt zur Übernahme des Kontrollflusses führt.

#### 2. CVE-2016-9793

[writeup](https://blog.csdn.net/panhewu9919/article/details/120164051) 

**Testversion**: Linux-4.8.13

**Schutz**: KASLR/SMAP/SMEP nicht aktiviert. Die gefälschte [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414)-Struktur befindet sich im Userspace und kann SMAP offensichtlich nicht umgehen.

**Schwachstelle**: Die Funktion [sock_setsockopt()](https://elixir.bootlin.com/linux/v4.8.13/source/net/core/sock.c#L658) in `net/core/sock.c` **behandelt negative Werte fehlerhaft**, wodurch `sk_sndbuf` und `sk_rcvbuf` negative Werte annehmen. Beim Aufruf von `write` werden `skb->head` und `skb->end` falsch gesetzt; beim anschließenden `close` wird beim Freigeben der Userspace adressiert und ein Fehler ausgelöst. An der Userspace-Adresse `0xfffffed0` wird eine [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414)-Struktur gefälscht, über `skb_shared_info->destructor_arg->callback` wird der Kontrollfluss übernommen.

#### 3. 4-20-BPF-integer

[writeup](https://www.cnblogs.com/bsauce/p/11560224.html) 

**Testversion**: Linux-4.20.0-rc3

**Schutz**: SMEP aktiviert, KASLR/SMAP nicht aktiviert.

**Schwachstelle**: **Integer-Overflow** in `queue_stack_map_alloc()` des Linux-eBPF-Moduls, was zu einem Heap-Overflow führt. Durch Modifikation des Vtabl-Zeigers wird der Kontrollfluss zu `xchg eax, esp` umgeleitet.

#### 4. CVE-2017-5123

[writeup](https://www.jianshu.com/p/90a040114188) 

**Testversion**: Linux 4.14-rc4

**Schutz**: SMEP/SMAP aktiviert, KASLR deaktiviert.

**Schwachstelle**: Die Implementierung von `waitid` in `/kernel/exit.c` ruft beim Kopieren von Kernel-Daten an Userspace-Adressen mittels `unsafe_put_user()` keine Prüfung der Userspace-Adresse durch `access_ok()` auf, wodurch tatsächlich Daten an Kernel-Adressen geschrieben werden können. **waitid prüft die Benutzeradresse nicht, was zu einem beliebigen Null-Address-Schreibzugriff führt.** Es kann Shellcode an Adresse 0 ausgeführt oder ein `cred` in einem vermuteten Bereich überschrieben werden, um Rechte zu erweitern.

#### 5. CVE-2017-6074

[writeup](https://bsauce.github.io/2021/09/17/CVE-2017-6074/)      [reference](https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-6074)

**Testversion**: Linux-4.9.12

**Schutz**: SMEP/SMAP aktiviert, kASLR deaktiviert.

**Schwachstelle**: Im DCCP-Protokoll (Datagram Congestion Control Protocol) des IPv6-Protokollfamilie des Linux-Kernels behandelt die Funktion [dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) in `net/dccp/input.c` im Zustand `LISTEN` die Datenstruktur von `DCCP_PKT_REQUEST`-Paketen fehlerhaft. Wenn der Benutzer `setsockopt()` mit der Option `IPV6_RECVPKTINFO` aufruft, wird eine **Double-Free der `sk_buff`-Struktur** ausgelöst. Die Ausnutzung ähnelt CVE-2016-8655. Beim ersten Auslösen der Schwachstelle wird per Heap-Spraying die `po->rx_ring->prb_bdqc->retire_blk_timer`-Struktur gefälscht, um `native_write_cr4(0x406e0)` auszuführen und SMEP/SMAP zu deaktivieren; beim zweiten Auslösen wird per Heap-Spraying die `skb-> ... ->destructor_arg`-Struktur gefälscht, um `commit_creds(prepare_kernel_cred(0))` auszuführen und Rechte zu erweitern.

#### 6. CVE-2017-7308

[writeup](https://www.jianshu.com/p/b53862cd64a6)      [reference](https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-7308)

**Testversion**: Linux-4.10.6

**Schutz**: SMEP/SMAP aktiviert, KASLR deaktiviert.

**Schwachstelle**: Die Funktion [`packet_set_ring()`](https://elixir.bootlin.com/linux/v4.10.6/source/net/packet/af_packet.c#L4181) in `net/packet/af_packet.c` prüft die Blockgröße nicht korrekt; die Längenbedingung ist fehlerhaft, was zu einem **Heap-Overflow** führt. Erforderlich ist die Berechtigung `CAP_NET_RAW`. Zweimalige Übernahme von Funktionszeigern: Zuerst werden die Schutzmechanismen SMEP/SMAP deaktiviert, dann werden Rechte erweitert.

#### 7. CVE-2017-8890

[writeup](https://www.jianshu.com/p/699de662f567)      [reference](https://xz.aliyun.com/t/2383)

**Testversion**: Linux-4.10.15

**Schutz**: SMEP aktiviert, kASLR und SMAP deaktiviert.

**Schwachstelle**: Die Funktion [`inet_csk_clone_lock()`](https://elixir.bootlin.com/linux/v4.10.15/source/net/ipv4/inet_connection_sock.c#L652) in `net/ipv4/inet_connection_sock.c` weist eine **Double-Free-Schwachstelle** auf. Durch die Double-Free wird der Callback-Funktionszeiger von RCU manipuliert, SMEP deaktiviert und zu Shellcode gesprungen, um `cred` zu modifizieren.

#### 8. CVE-2017-11176

[writeup](https://www.jianshu.com/p/76041ec5c59f) 

**Testversion**: Linux-4.11.9

**Schutz**: SMEP aktiviert, kASLR und SMAP deaktiviert.

**Schwachstelle**: In der Implementierung von POSIX Message Queues im Linux-Kernel setzt die Funktion `mq_notify()` den sock-Zeiger nicht auf null, was zu UAF führt. Tatsächlich handelt es sich um eine **durch eine Race Condition verursachte Double-Free-Schwachstelle**, wobei das Race-Fenster jedoch unbegrenzt verlängert werden kann.

#### 9. CVE-2017-16995

[writeup](https://www.cnblogs.com/bsauce/p/11583310.html) 

**Testversion**: Linux-4.4.110

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: Problem der **Integer-Erweiterung** im Linux-eBPF-Modul. Das Hauptproblem ist, dass die Registerwerttypen der beiden Seiten unterschiedlich sind, sodass die Check-Funktion und die tatsächliche Ausführungsfunktion unterschiedlich arbeiten. Diese Schwachstelle beinhaltet weder Stack-Angriffe noch Kontrollflussübernahme; sie verwendet nur Systemaufrufdaten zur Rechteausweitung und ist eine typische Anwendung von Data-Oriented Attacks auf dem Linux-Kernel.

#### 10. CVE-2017-1000112

[writeup](https://www.jianshu.com/p/1fa163fd5b82)  	  [reference](https://bbs.pediy.com/thread-265319.htm)

**Testversion**: Linux-4.12.6

**Schutz**: SMEP aktiviert, SMAP/kaslr deaktiviert.

**Schwachstelle**: [__ip_append_data()](https://elixir.bootlin.com/linux/v4.12.6/source/net/ipv4/ip_output.c#L910) in `net/ipv4/ip_output.c` gewährleistet nicht die Konsistenz der UDP-Paketverarbeitung, sodass beim zweimaligen Senden von Paketen von einem UFO-Pfad zu einem non-UFO-Pfad gewechselt werden kann, was zu einem **Heap-Overflow** führt. Bei der Ausnutzung kann der Kontrollfluss durch Überschreiben von `skb_shared_info->destructor_arg->callback` übernommen werden.

#### 11. CVE-2018-5333

[writeup](https://blog.csdn.net/panhewu9919/article/details/119153052)  

**Testversion**: Linux-4.14.13

**Schutz**: SMEP aktiviert, SMAP/kaslr deaktiviert.

**Schwachstelle**: In der Funktion [`rds_cmsg_atomic()`](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L788) in `net/rds/rdma.c` wurde vergessen, `rm->atomic.op_active` auf 0 zu setzen, was bei [rds_atomic_free_op()](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L474) -> [set_page_dirty()](https://elixir.bootlin.com/linux/v4.14.13/source/mm/page-writeback.c#L2559) beim Zugriff auf `page->page_link` zu einer **Null-Dereference-Schwachstelle** führt. An Adresse 0 werden Strukturen und Funktionszeiger gefälscht, um den Kontrollfluss zu übernehmen.

#### 12. CVE-2019-9213 & CVE-2019-8956

[CVE-2019-9213-writeup](https://blog.csdn.net/panhewu9919/article/details/118557802)    [CVE-2019-8956-writeup](https://blog.csdn.net/panhewu9919/article/details/118557844)    

**Testversion**: Linux-4.20.0 32-Bit

**Schutz**: SMEP aktiviert, SMAP/kaslr deaktiviert.

**Schwachstelle**: 

- CVE-2019-9213: Die Prüfung der minimalen mmap-Adresse in [`expand_downwards()`](https://elixir.bootlin.com/linux/v4.20.7/source/mm/mmap.c#L2413) in `mm/mmap.c` ist fehlerhaft; die Capability-Prüfung wird am falschen Task durchgeführt, wodurch die Einschränkung von `mmap_min_addr` umgangen wird – eine **Logikschwachstelle**. Mit dem Befehl `LD_DEBUG=help /bin/su 1>&%d` wird eine write-Operation ausgeführt. Eigentlich sollte die cred des Exploits geprüft werden, aber fälschlicherweise wird die cred des write-Prozesses geprüft, wodurch die niedrige Adresse als privilegiert zugreifbar markiert wird. Nur 32-Bit-Systeme können die Schwachstelle erfolgreich ausnutzen; der Grund ist unbekannt.
- CVE-2019-8956: Die Funktion [`sctp_sendmsg()`](https://elixir.bootlin.com/linux/v4.20.7/source/net/sctp/socket.c#L2025) in `net/sctp/socket.c` weist bei der Verarbeitung des `SCTP_SENDALL`-Flags eine **Nullzeiger-Referenz**-Schwachstelle auf. In Kombination mit CVE-2019-9213 kann die `mmap_min_addr`-Einschränkung umgangen werden, sodass die niedrige Adresse 0xd4 per mmap gemappt, eine Struktur gefälscht und der Kontrollfluss übernommen werden kann.

#### 13. CVE-2019-15666

[writeup](https://bsauce.github.io/2021/09/14/CVE-2019-15666/)  	  [reference](https://github.com/riskeco/Lucky/blob/master/lucky0_RE.c)

**Testversion**: Ubuntu 18.04 (4.15.0-20-generic #21)

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: [verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379) in `net/xfrm/xfrm_user.c` behandelt die `dir`-Validierung fehlerhaft, was zu einem **Out-of-Bounds-Zugriff** in [__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202) führt. Die Schwachstelle ist ursprünglich ein Out-of-Bounds um 1 nach unten; über andere Pfade kann eine UAF konstruiert werden, bei der **8 Bytes null auf einen freien Block** geschrieben werden können. Das Schwachstellenobjekt `xfrm_policy` liegt in `kmalloc-1024`, die cred-Struktur in `kmalloc-192`. Zuerst werden mit `setxattr+userfaultfd` rund um `policy0` `kmalloc-1024`-Heapblöcke gesprayt. Nach dem Freigeben von `policy0` werden auch die gesprayten Blöcke freigegeben, sodass der Slab nach seiner Freigabe von der cred des Kindprozesses c wiederverwendet wird. Dann wird die UAF ausgelöst, um mit einem 8-Byte-Null-Schreiben in den freien Block die `gid/suid` in der cred zu modifizieren; anschließend wird der aktuelle Benutzer zu sudoers hinzugefügt, um Rechte zu erweitern.

#### 14. CVE-2020-8835

[writeup](https://www.cnblogs.com/bsauce/p/14123111.html)  	  [reference](https://xz.aliyun.com/t/7690)

**Testversion**: Linux-5.5.0

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: In `kernel/bpf/verifier.c` wird ein 64-Bit-Wert nicht korrekt in einen 32-Bit-Wert konvertiert (es werden direkt die niedrigen 32 Bit genommen), was zu einer **Integer-Trunkierung** führt. Dadurch stimmen die BPF-Code-Validierungsphase und die tatsächliche Ausführungsphase nicht überein, was Out-of-Bounds-Lesen/Schreiben ermöglicht.

#### 15. CVE-2020-27194

[writeup](https://www.jianshu.com/p/b6f11d8df37a)       [reference](https://github.com/willinin/CVE-2020-27194-exp)

**Testversion**: Linux-5.8.14

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: Bei der OR-Operation im eBPF-Validator weist die Funktion `scalar32_min_max_or()` einen 64-Bit-Wert einer 32-Bit-Variablen zu, was zu einer **Integer-Trunkierung** führt. Dadurch wird der Registerbereich falsch berechnet, die bpf-Prüfung umgangen und Out-of-Bounds-Lesen/Schreiben ermöglicht.

#### 16. CVE-2021-3156

[writeup](https://www.jianshu.com/p/18f36f1342b3)       [exploit](https://github.com/blasty/CVE-2021-3156)

**Testversion**: Ubuntu 19.04, Sudo 1.8.27

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: Bei der Verarbeitung von Befehlszeilenargumenten tritt in sudo bei der Behandlung von Befehlen, die mit einem einzelnen Backslash enden, ein Logikfehler auf, der zu einem **Heap-Overflow** führt.

#### 17. CVE-2021-31440

[writeup](https://bsauce.github.io/2021/06/09/CVE-2021-31440/)      [exploit](https://github.com/bsauce/kernel-exploit-factory/tree/main/CVE-2021-31440/exp)

**Testversion**: Linux-5.11

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: In der Funktion [`__reg_combine_64_into_32()`](https://elixir.bootlin.com/linux/v5.11.20/source/kernel/bpf/verifier.c#L1312) in `kernel/bpf/verifier.c` des eBPF-Moduls wird der Registerwert falsch berechnet. Durch die Inkonsistenz zwischen Validierungsphase und tatsächlicher Ausführungsphase werden Out-of-Bounds-Lesen/Schreiben ausgelöst. Nach dem Leaken der Kernel-Basisadresse, dem Fälschen einer Funktionstabelle und der Implementierung von beliebigem Lesen/Schreiben wird die cred des aktuellen Threads manipuliert.

#### 18. CVE-2021-3490

[writeup](https://bsauce.github.io/2021/08/31/CVE-2021-3490/)      [exploit](https://github.com/chompie1337/Linux_LPE_eBPF_CVE-2021-3490)

**Testversion**: Linux-5.11, Linux-5.11.16

**Schutz**: SMEP/SMAP/kaslr aktiviert.

**Schwachstelle**: Im eBPF-Modul wird bei den bitweisen Operationen (AND, OR und XOR) die 32-Bit-Grenzenverfolgung der eBPF-ALU32 in `kernel/bpf/verifier.c` nicht korrekt aktualisiert, was zu Out-of-Bounds-Lesen und -Schreiben im Linux-Kernel und damit zur Ausführung beliebigen Codes führt. Die drei anfälligen Funktionen sind [scalar32_min_max_and()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7078), [scalar32_min_max_or()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7149) und [scalar32_min_max_xor()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7219). Durch die Inkonsistenz zwischen Validierungsphase und tatsächlicher Ausführungsphase werden Out-of-Bounds-Lesen/Schreiben ausgelöst. Nach dem Leaken der Kernel-Basisadresse, dem Fälschen einer Funktionstabelle und der Implementierung von beliebigem Lesen/Schreiben wird die cred des aktuellen Threads manipuliert.

#### 19. CVE-2021-22555

[writeup](https://bsauce.github.io/2021/09/23/CVE-2021-22555/)      [exploit](https://github.com/google/security-research/blob/master/pocs/linux/cve-2021-22555/exploit.c)

**Testversion**: Linux-5.11.14

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Im `Netfilter`-Modul `net/netfilter/x_tables.c`, Untermodul `ip_tables`, muss beim Aufruf von `setsockopt()` mit der Option `IPT_SO_SET_REPLACE` (oder `IP6T_SO_SET_REPLACE`) die Kernel-Struktur von 32-Bit in 64-Bit konvertiert werden. Durch einen Fehler bei der Berechnung der Konvertierungsgröße kommt es beim Aufruf von [xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731) zu einem **Heap-Overflow, der 0 schreibt und in UAF umgewandelt werden kann**. Angreifer können damit Rechte erweitern oder aus Docker-/k8s-Containern ([kubernetes](https://zhuanlan.zhihu.com/p/29232090)) ausbrechen. Erforderlich ist die Berechtigung `CAP_NET_ADMIN` oder die Unterstützung von `user+network`-Namespaces.

#### 20. CVE-2021-41073

[writeup](https://bsauce.github.io/2022/07/11/CVE-2021-41073/)      [reference](https://www.graplsecurity.com/post/iou-ring-exploiting-the-linux-kernel)

**Testversion**: Linux-5.14.6

**Schutz**: KASLR/SMEP/SMAP aktiviert. `CONFIG_SLAB_FREELIST_RANDOM` / `CONFIG_SLAB_FREELIST_HARDENED` / `CONFIG_BPF_JIT_ALWAYS_ON` / `CONFIG_MEMCG` nicht aktiviert (letzteres ist standardmäßig aktiviert).

**Schwachstelle**: Die Funktion `loop_rw_iter()` in `fs/io_uring.c` weist eine **Type-Confusion-Schwachstelle** auf. `io_kiocb->rw.addr` dient sowohl als Kernel-Adresse als auch als Benutzeradresse, wird aber in `loop_rw_iter()` beim Inkrementieren nicht unterschieden. Dadurch wird beim Lesen einer Datei fälschlicherweise die Kernel-Adresse inkrementiert, was schließlich dazu führt, dass **ein benachbarter Puffer an einem kontrollierbaren Offset falsch freigegeben wird** (kmalloc-32). Die Ausnutzungsbedingungen sind streng: Da sich das Schwachstellenobjekt in kmalloc-32 befindet, ist der Freelist-Schutz deaktiviert; da das `seq_operations`-Objekt mit dem Flag `GFP_KERNEL_ACCOUNT` allokiert wird, ist zusätzlich der `CONFIG_MEMCG*`-Mechanismus deaktiviert. Dieser Exploit manipuliert den `sk_filter->prog`-Zeiger in eBPF und fälscht ein BPF-Programm zur Rechteausweitung, daher ist auch die Konfiguration `CONFIG_BPF_JIT_ALWAYS_ON` deaktiviert.

#### 21. CVE-2021-4154

[writeup](https://bsauce.github.io/2022/10/17/CVE-2021-4154/)      [reference](https://github.com/Markakd/DirtyCred)

**Testversion**: Linux-5.13.3

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Die Funktion [cgroup1_parse_param()](https://elixir.bootlin.com/linux/v5.13.3/source/kernel/cgroup/cgroup-v1.c#L905) in `kernel/cgroup/cgroup-v1.c` (ausgelöst über den Syscall `fsconfig`) weist eine Type-Confusion auf, die zu einer **UAF-Schwachstelle** führt. Über den Syscall `fsconfig` kann ein beliebiger fd gesetzt werden; nach dem Schließen dieser Datei wird das zugehörige `file`-Objekt freigegeben. Auf diese Weise kann die **`file`-Struktur eines beliebigen Dateideskriptors freigegeben werden**. In diesem Artikel werden zwei Methoden zur Ausnutzung verwendet: erstens DirtyCred, zweitens der Aufbau einer ROP-Kette. Im Vergleich der beiden Methoden ist DirtyCred über Kernel-Versionen hinweg universell einsetzbar und benötigt keine Anpassung, hat aber den Nachteil, dass zum Erweitern der Rechte privilegierte Dateien überschrieben werden müssen, weshalb in Docker- und anderen Containern keine Rechteausweitung möglich ist. ROP hingegen ermöglicht beliebiges Lesen/Schreiben von Kernel-Speicher und die Ausführung beliebigen Codes, hat aber den Nachteil, dass die Anpassung an verschiedene Kernel-Versionen aufwendig ist.

#### 22. CVE-2021-42008

[writeup](https://bsauce.github.io/2021/12/09/CVE-2021-42008/)      [reference](https://syst3mfailure.io/sixpack-slab-out-of-bounds)

**Testversion**: Linux-5.13.12

**Schutz**: KASLR / SMEP / SMAP / PTI aktiviert.

**Schwachstelle**: Die Funktion [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) in `drivers/net/hamradio/6pack.c` weist einen **Heap-Overflow** auf. Der Benutzer benötigt die Berechtigung `CAP_NET_ADMIN`. [sixpack_decode()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L962) kann [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) mehrfach aufrufen, um Eingaben zu dekodieren und in [sixpack->cooked_buf](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L98) zu speichern. Das Mitglied `sixpack->rx_count_cooked` dient als Index für den Zugriff auf `sixpack->cooked_buf` und bestimmt das Ziel-Offset für das Schreiben der dekodierten Bytes. Das Problem ist, dass bei mehrfachem Aufruf von `decode_data()` `rx_count_cooked` kontinuierlich inkrementiert wird, bis es die Länge von `cooked_buf` (400 Bytes) überschreitet, was zu einem Out-of-Bounds-Schreiben führt. Unter Bezugnahme auf [Ausnutzung der msg_msg-Struktur im Linux-Kernel für beliebiges Adress-Lesen/Schreiben](https://www.anquanke.com/post/id/252558) werden ein Out-of-Bounds-Read und ein beliebiges Adress-Schreiben konstruiert, um `modprobe_path` zu manipulieren und Rechte zu erweitern. Der Nachteil ist, dass `userfaultfd` benötigt wird und die Hürde von `CAP_NET_ADMIN` nicht umgangen werden kann.

#### 23. CVE-2021-43267

[writeup](https://bsauce.github.io/2021/12/06/CVE-2021-43267/)      [reference](https://haxx.in/posts/pwning-tipc/)

**Testversion**: Linux-5.14.15

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Die Schwachstelle befindet sich in der Datei `net/tipc/crypto.c`. Beim Kommunikationsprotokoll TIPC (Transparent Inter-Process Communication) für Cluster wird die Längenvalidierung von Nachrichten des Typs `MSG_CRYPTO` fehlerhaft durchgeführt, was zu einem **Heap-Overflow** führt. In der Funktion [tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281) zeigt der Datenteil der TIPC-Nachricht ([tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)-Struktur) auf die `MSG_CRYPTO`-Nachricht ([tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)-Struktur). Beim Allokieren des Speichers für `tipc_aead_key` und Kopieren von `tipc_aead_key->key` wird die Gültigkeit von `tipc_aead_key->keylen` nicht überprüft, was zu einem Kopieren über die Grenzen hinaus führt. Es werden nur die `header size` und `msg size` der TIPC-Nachricht geprüft, nicht aber `tipc_aead_key->keylen` der `MSG_CRYPTO`-Nachricht. Mit einem **elastischen Objekt** wird die Kernel-Basisadresse geleakt und `tty_struct->tty_operations.ioctl` so manipuliert, dass es auf ein beliebiges Schreib-Gadget zeigt (`mov   QWORD PTR [rdx],rsi`). Danach wird `modprobe_path` manipuliert, um Rechte zu erweitern.

#### 24. CVE-2022-0185

[writeup](https://bsauce.github.io/2022/04/08/CVE-2022-0185/)  

**Testversion**: Linux-5.11.22

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Rechteausweitung auf google kctf, 30.000 US-Dollar Preisgeld. Im `File System Context`-Modul des Kernels (Dateisystemkontext) in `fs/fs_context.c` führt ein **Integer-Overflow** zu einem Heap-Overflow. Der Angreifer benötigt die Berechtigung `CAP_SYS_ADMIN` oder tritt über Namespaces bzw. `unshare(CLONE_NEWNS|CLONE_NEWUSER)` (äquivalent zum Befehl `$ unshare -Urm`) in einen Namespace mit `CAP_SYS_ADMIN`-Berechtigung ein. Zwei Ausnutzungsmethoden: Erstens wird mit **FUSE** (vergleichbar mit userfault) ein beliebiges Adress-Schreiben konstruiert, um `modprobe_path` zu ändern; zweitens wird mit `msg_msg` eine beliebige Freigabe konstruiert und anschließend eine ROP-Kette zur Rechteausweitung aufgebaut.

#### 25. CVE-2022-0847

[writeup](https://bsauce.github.io/2022/04/03/CVE-2022-0847/)      reference-[1](https://blog.csdn.net/Breeze_CAT/article/details/123393188) [2](https://www.anquanke.com/post/id/269886) [3](https://www.freebuf.com/vuls/324700.html)

**Testversion**: Linux-5.16.10

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: **DirtyPipe-Schwachstelle**. Wenn der `splice`-Aufruf den Page Cache der Datei mit dem Ringpuffer [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) der Pipe verknüpft, initialisieren weder [copy_page_to_iter_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L384) noch [push_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L547) das Mitglied `flag` von [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) (Uninitialisierte-Variable-Schwachstelle). Da das Attribut `PIPE_BUF_FLAG_CAN_MERGE` nicht gelöscht wird, geht der anschließende `pipe_write()` fälschlicherweise davon aus, dass der Schreibvorgang zusammengeführt werden kann, wodurch illegale Daten in den Page Cache der Datei geschrieben werden (nach einem Neustart wiederherstellbar). Dies führt zu einer Schwachstelle zur beliebigen Dateiüberschreibung. Die Schwachstelle kann den Page Cache beliebiger Dateien überschreiben; die Methode zur Rechteausweitung besteht darin, den Page Cache von /etc/passwd zu modifizieren, sodass kurzzeitig alle Prozesse, die auf diese Datei zugreifen, die manipulierte Dateicache-Seite sehen.

#### 26. CVE-2022-0995

[writeup](https://bsauce.github.io/2022/04/15/CVE-2022-0995/)     

**Testversion**: Linux-5.11.22

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Das `watch_queue`-Ereignisbenachrichtigungs-Subsystem weist einen **Heap-Overflow** auf. Die anfällige Funktion ist [watch_queue_set_filter()](https://elixir.bootlin.com/linux/v5.16.14/source/kernel/watch_queue.c#L286). Der Kernel führt zweimal eine Gültigkeitsprüfung des vom Benutzer übergebenen Filters vom Typ [watch_notification_type_filter](https://elixir.bootlin.com/linux/v5.16.14/source/include/uapi/linux/watch_queue.h#L52) durch: Die erste Prüfung dient zur Bestimmung der zu allozierenden Speichergröße, die zweite zum Speichern des Benutzerfilters in diesen Speicher. Die beiden Prüfungen sind jedoch inkonsistent, sodass der allozierte Speicher zu klein ist und mehr Filter als vorgesehen hineingeschrieben werden können. Mit dem zweiten Overflow können benachbarte Heap-Blöcke an bestimmten Bitpositionen auf 1 gesetzt werden. Die weitere Ausnutzung erfolgt wie bei [CVE-2021-22555](https://bsauce.github.io/2021/09/23/CVE-2021-22555/).

#### 27. CVE-2022-1015

[writeup](https://bsauce.github.io/2022/07/16/CVE-2022-1015/)      [reference](https://blog.dbouman.nl/2022/04/02/How-The-Tables-Have-Turned-CVE-2022-1015-1016/)

**Testversion**: Linux-5.17

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Im nftables-Modul begrenzen die Funktionen [nft_parse_register_load()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9325) und [nft_parse_register_store()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9377) den Bereich der übergebenen Register-Indizes nicht, was zu einem Integer-Overflow führt (der die Bereichsprüfung umgehen kann) und damit einen **Stack-Overflow mit Out-of-Bounds-Lesen/Schreiben** auslöst. Bei der Ausnutzung muss aus dem Interrupt-Kontext in den Userspace zurückgekehrt werden. Dazu wird das Ende von `__do_softirq()` genutzt, um sauber in den Syscall-Kontext zurückzukehren. Anschließend werden `switch_task_namespaces(current, &init_nsproxy)` und `commit_cred(&init_cred)` aufgerufen, um Rechte zu erweitern.

#### 28. CVE-2022-2588

[writeup](https://bsauce.github.io/2022/10/21/CVE-2022-2588/)      [reference](https://github.com/Markakd/CVE-2022-2588)

**Testversion**: Linux-5.19.1

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Ähnlich wie bei [CVE-2021-3715](https://access.redhat.com/security/cve/cve-2021-3715) (siehe [BlackHat 2021-Europe-Your Trash Kernel Bug, My Precious 0-day](https://zplin.me/talks/BHEU21_trash_kernel_bug.pdf), Seite 16): Da die Prüfbedingungen beim Entfernen des `route4_filter`-Objekts aus der verknüpften Liste und beim Freigeben nicht übereinstimmen, bleibt das Objekt nach der Freigabe weiterhin in der Liste, sodass später ein **Double-Free** ausgelöst werden kann. Zum Auslösen werden `User Namespaces` benötigt. Zur Rechteausweitung wird die **DirtyCred**-Methode verwendet.

#### 29. CVE-2022-2602

[writeup](https://bsauce.github.io/2022/06/08/CVE-2022-2602/)      [reference](https://1day.dev/notes/CVE-2022-2602-DirtyCred-File-Exploitation-applied-on-an-io_uring-UAF/)

**Testversion**: Linux-5.18.19

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Die io_uring-Komponente bietet die Funktion `IORING_REGISTER_FILES`, mit der Dateien in die `sock->receive_queue`-Warteschlange von io_uring eingefügt werden können. Der Garbage-Collector von Linux, GC (der nur die Flugzähler von io_uring- und sock-Dateien verarbeitet), kann die in io_uring registrierten Dateien fälschlicherweise als Müll freigeben. Bei der nächsten Verwendung dieser Datei durch io_uring (Schreiben mit writev, entsprechend der Funktion `IORING_OP_WRITEV`) wird eine **UAF-Schwachstelle** ausgelöst. Ausnutzungsmethode: Da der UNIX_GC-Mechanismus fälschlicherweise die noch verwendete Dateistruktur in `io_uring` freigibt (es wird gerade bösartige Daten in die normale Datei `"/tmp/rwA"` geschrieben), kann die **DirtyCred-Methode** angewendet werden: Es werden viele `"/etc/passwd"`-Dateien geöffnet, um die gerade freigegebene `file`-Struktur zu überschreiben. Dadurch werden die bösartigen Daten letztlich tatsächlich in die Datei `"/etc/passwd"` geschrieben.

#### 30. CVE-2022-2639

[writeup](https://bsauce.github.io/2022/11/24/CVE-2022-2639/)      [reference](https://veritas501.github.io/2022_10_18-CVE-2022-2639%20%20openvswitch%20LPE%20%20%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)

**Testversion**: Linux-5.17.4

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Im openvswitch-Kernelmodul führt ein **Integer-Overflow** in [reserve_sfa_size()](https://elixir.bootlin.com/linux/v5.17.4/source/net/openvswitch/flow_netlink.c#L2439) zu einem **Heap-Overflow-Write in kmalloc-0x10000**; für den Cross-Cache-Overflow muss Page-Spraying eingesetzt werden. Dieser Artikel basiert auf dem `pipe-primitive` zur Manipulation beliebiger Dateien, daher müssen die Schutzmechanismen KASLR/SMEP/SMAP/KPTI nicht umgangen werden, und die Ausnutzung funktioniert ohne Anpassung über Kernel-Versionen hinweg. **Zuerst wird eine Pipe erstellt und per splice mit der schreibgeschützten Datei `/usr/bin/mount` verbunden. Per Heap-Spraying wird `pipe_buffer->flags = PIPE_BUF_FLAG_CAN_MERGE` gefälscht, sodass eine suid-Shell in die Datei `/usr/bin/mount` geschrieben und ausgeführt werden kann, um Rechte zu erweitern.**        Der Out-of-Bounds wird zweimal ausgelöst: Beim ersten Mal wird durch den Overflow `msg_msg->m_ts` manipuliert, um den benachbarten `msg_msg->m_list.next` **out-of-bounds zu lesen und die kmalloc-1024-Heap-Adresse zu leaken**; beim zweiten Mal wird durch den Overflow `msg_msg->m_list.next` auf die geleakte kmalloc-1024-Heap-Adresse geändert, um **eine beliebige Freigabe zu konstruieren**.

#### 31. CVE-2022-25636

[writeup](https://bsauce.github.io/2022/12/13/CVE-2022-25636/)      [reference](https://github.com/Bonfee/CVE-2022-25636)

**Testversion**: Linux-5.13.19

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: In der Funktion [nft_fwd_dup_netdev_offload()](https://elixir.bootlin.com/linux/v5.16.11/source/net/netfilter/nf_dup_netdev.c#L67) in `net/netfilter/nf_dup_netdev.c` des `nf_table`-Moduls besteht ein **OOB-Write**, da die berechnete Allokationsgröße und die Bedingung bei der tatsächlichen Initialisierung nicht übereinstimmen (das System muss Paketverarbeitungs-Offloading – Network Interface Cards (NICs) – unterstützen, was in der Praxis jedoch selten vorkommt). **Es wird die Adresse eines `net_device`-Objekts (in kmalloc-4k) out-of-bounds geschrieben**, wobei die Größe des Schwachstellenobjekts variieren kann (abhängig von der Anzahl der übergebenen Rules mit dem `NFT_OFFLOAD_F_ACTION`-Flag; es kann in kmalloc-128 oder kmalloc-192 usw. liegen). Erforderlich ist die Berechtigung `SYS_ADMIN`. Bei der Ausnutzung wird **über `msg_msgseg` der `net_device`-kmalloc-4k-Heap-Zeiger geleakt, über das Überschreiben des `msg_msg->security`-Zeigers eine beliebige Freigabe konstruiert, über die eingebaute Funktion `ioctl(fd, SIOCGIFHWADDR, leak)` die `net_device->dev_addr` gelesen, um die Kernel-Basisadresse zu leaken, und über das Fälschen des Funktionszeigers `net_device->ethtool_ops->begin` der Kontrollfluss übernommen, um Rechte zu erweitern**.

#### 32. CVE-2022-27666

[writeup](https://paper.seebug.org/1889/)      [reference](https://etenal.me/archives/1825)

**Testversion**: Linux-5.16.14

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Beim PWN2OWN-Wettbewerb wurde eine Rechteausweitung auf Ubuntu 21.10 durchgeführt. Der empfangende Puffer des esp6-crypto-Moduls des Kernels ist 8 Seiten groß, aber der Absender kann Daten senden, die größer als 8 Seiten sind. Dies führt über die Funktion [null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76) zu einem **Page-Overflow**. Insgesamt wird Page-Spraying-Technik verwendet: Zuerst wird mit dem elastischen Objekt `user_key_payload` `msg_msg->next` geleakt, dann wird mit `msg_msg` die Kernel-Adresse von `seq_operations->start` geleakt, und schließlich wird mit `msg_msg` und FUSE-Seitenfehlerbehandlung ein beliebiges Schreiben konstruiert, um `modprobe_path` zu manipulieren und Rechte zu erweitern.

#### 33. CVE-2022-32250[writeup](https://bsauce.github.io/2022/11/03/CVE-2022-32250/)      [reference](https://github.com/theori-io/CVE-2022-32250-exploit)

**Testversion**: Linux-5.17.12

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Wenn das `nftables`-Modul in `net/netfilter/nf_tables_api.c` über die `NFT_MSG_NEWSET`-Funktion ein `nft_set` hinzufügt und dabei die `lookup`- und `dynset`-Expressions verarbeitet, führt eine fehlerhafte `NFT_EXPR_STATEFUL`-Prüfung dazu, dass das freigegebene `nft_expr`-Objekt weiterhin in der `nft_set->binding`-Liste verbleibt. Beim Hinzufügen eines neuen `nft_expr` entsteht so ein **UAF-Schreibzugriff** (zum Auslösen der Schwachstelle wird die Berechtigung `CAP_NET_ADMIN` benötigt). Der UAF-Schreibzugriff schreibt an den Offset 0x18 eines `kmalloc-64`-Blocks den Adresswert des Offsets 0x18 eines anderen `kmalloc-64`-Heap-Blocks. Als Ausnutzungsmethode wird **`msg_msg` aus der mqueue verwendet, um die Kernel-Basisadresse zu leaken**, da `posix_msg_tree_node->msg_list` in der mqueue den Offset 0x18 besitzt (und im `kmalloc-64`-Cache liegt) – genau der Offset des UAF-Schreibzugriffs. Darüber hinaus kann **`posix_msg_tree_node->msg_list` auch zum Aufbau eines Unlink-Exploits verwendet werden**, um `modprobe_path` zu manipulieren. Das Leaken der Heap-Adresse über `user_key_payload` (um das Unlink zu erleichtern) ist ein alter Hut. Hinweis: Es müssen libmnl- bzw. libnftnl-Versionen ab Ubuntu 21.04 verwendet werden.

#### 34. CVE-2022-34918

[writeup](https://bsauce.github.io/2022/07/26/CVE-2022-34918/)      [reference](https://www.randorisec.fr/crack-linux-firewall/)

**Testversion**: Linux-5.17.15

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Die Funktion [nft_set_elem_init()](https://elixir.bootlin.com/linux/v5.18.10/source/net/netfilter/nf_tables_api.c#L5459) im nftables-Modul weist einen **Heap-Overflow** auf. Die Überlauflänge kann bis zu `64-16=48` Bytes betragen. Das verwundbare Objekt kann sich in `kmalloc-{64,96,128,192}` befinden (im vorliegenden Exploit wird ein verwundbares Objekt im kmalloc-64-Cache gewählt). Ausnutzung: Zunächst wird das Heap-Layout `vul_obj -> user_key_payload -> percpu_ref_data` aufgebaut; durch den Überlauf wird `user_key_payload->datalen` auf 0xffff manipuliert, um über `percpu_ref_data->release` die Kernel-Basisadresse und über `percpu_ref_data->ref` die physmap-Basisadresse zu leaken. Anschließend wird das Heap-Layout `vul_obj -> simple_xattr` aufgebaut; durch den Überlauf wird die `simple_xattr->list`-Liste manipuliert. Mit diesem eingeschränkten beliebigen Schreibzugriff wird `modprobe_path` von `/sbin/modprobe` zu `/tmp/xxxxprobe` geändert, um Privilegien zu erlangen (der beliebige Schreibzugriff wird beim Entfernen des xattr aus der Liste ausgelöst). Voraussetzung für diesen beliebigen Schreibzugriff ist das Leaken der physmap-Adresse; `percpu_ref_data` / `shm_file_data` enthalten jeweils sowohl die Kernel-Basisadresse als auch die physmap-Adresse.

#### 35. CVE-2023-2598

[writeup](https://bsauce.github.io/2024/07/30/CVE-2023-2598/)      [reference](https://anatomic.rip/cve-2023-2598/)

**Testversion**: Linux-6.3.1

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Im io_uring-Modul existiert eine OOB-Schreibschwachstelle, die zu **Out-of-Bounds-Lese-/Schreibzugriffen auf physischen Speicher** führen kann. Die Schwachstelle befindet sich in der Funktion [io_sqe_buffer_register()](https://elixir.bootlin.com/linux/v6.3.1/source/io_uring/rsrc.c#L1230) im Verzeichnis `io_uring/rsrc.c`. Bei der Prüfung, ob die eingereichten, zu registrierenden Pages zu derselben zusammengesetzten Page (compound page) gehören, wird lediglich geprüft, ob die Kopf-Page der jeweiligen compound page übereinstimmt, nicht jedoch, ob die eingereichten Pages dieselbe Page sind. Dadurch kann dieselbe physische Page registriert werden (die sich als eine compound page aus mehreren physischen Pages ausgibt), wodurch ein Out-of-Bounds-Lese-/Schreibzugriff beliebiger Länge auf physische Pages konstruiert werden kann.   

Mit dem OOB-Lese-/Schreibzugriff beliebiger Länge auf physische Pages kann das dahinterliegende sock-Objekt beliebig gelesen und beschrieben werden. Über `sock->sk_data_ready` wird die Kernel-Basisadresse geleakt, über `sock.sk_error_queue.next` die Heap-Adresse des sock-Objekts. Durch Fälschen des Funktionszeigers `sock.__sk_common.skc_prot->ioctl`, sodass er auf die Funktion [call_usermodehelper_exec()](https://elixir.bootlin.com/linux/v6.3.1/source/kernel/umh.c#L434) zeigt, wird die **Kontrollflussübernahme** durchgeführt; zusätzlich muss die `subprocess_info`-Struktur gefälscht werden, um den Exploit abzuschließen. Schließlich wird **`/bin/sh -c /bin/sh &>/dev/ttyS0 </dev/ttyS0` ausgeführt, um Privilegien zu erlangen**.

#### 36. CVE-2024-1086

[writeup](https://bsauce.github.io/2024/05/10/CVE-2024-1086/)      [reference](https://yanglingxi1993.github.io/dirty_pagetable/dirty_pagetable.html)

**Testversion**: Linux-6.3.13

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Im nf_tables-Bestandteil des netfilter-Subsystems existiert eine **UAF-Schwachstelle**. In der Funktion [nft_verdict_init()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/nf_tables_api.c#L10321) ist es erlaubt, einen sehr großen Verdict-Wert (bösartiger Wert 0xffff0000) zu setzen. In der Funktion [nf_hook_slow()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/core.c#L607) wird bei der Verarbeitung von `NF_DROP` (0) zunächst das skb-Datenpaket freigegeben und [NF_DROP_GETERR()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L19) aufgerufen, um den Rückgabewert zu verändern (basierend auf dem Verdict-Wert wird `NF_ACCEPT` gesetzt – der positive Wert 1). Beim späteren Zugriff auf das skb wird die UAF ausgelöst; [NF_HOOK()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L407) gibt das skb erneut frei. Ausnutzungsmethode: **Es werden überlappende PMD- und PTE-Pages konstruiert**. `PMD[0]`/`PMD[1]` überschreiben `PTE[0]`/`PTE[1]`. Durch Schreibzugriffe auf die Benutzervirtualadresse, die der PTE-Page entspricht, wird die zu `PMD[0]` gehörende PTE-Page gefälscht (deren Einträge physischen Adressen entsprechen). Auf diese Weise kann durch Schreibzugriffe auf die der PMD entsprechende Benutzervirtualadresse **ein beliebiger Schreibzugriff auf physische Adressen realisiert werden**.

#### 37. CVE-2025-21702

[writeup](https://bsauce.github.io/2026/01/27/CVE-2025-21702/)      [reference](https://github.com/quanggle97/security-research/tree/master/pocs/linux/kernelctf/CVE-2025-21702_lts_cos)

**Testversion**: Linux-6.6.75

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: Im Modul `net/sched` führt der Aufruf der Funktion `pfifo_tail_enqueue()` für einen qdisc-Scheduler (bei dem `sch->limit == 0` gesetzt ist) dazu, dass die Warteschlangenlänge qlen dieses qdisc fälschlicherweise erhöht wird (obwohl die Warteschlange bereits voll ist, wird direkt ein neues Paket hinzugefügt, ohne zuvor ein Paket zu verwerfen), während die Länge qlen des übergeordneten qdisc (des Aufrufers) nicht erhöht wird. Dadurch entspricht die qlen der übergeordneten Warteschlange nicht mehr der Summe der qlen der untergeordneten Warteschlangen, sodass eine UAF konstruiert werden kann. Leaken der Kernel-Basisadresse: Mithilfe des Einfügeprinzips von Rot-Schwarz-Baum-Knoten (Red-Black-Tree) wird `user_key_payload->datalen` manipuliert, um einen Out-of-Bounds-Read zu konstruieren und den Funktionszeiger `xfrm_policy_timer` im benachbarten `xfrm_policy`-Objekt zu leaken. Kontrollflussübernahme: Der Funktionszeiger `UAF_hfsc_class->dequeue` wird gefälscht; über die Entnahme (dequeue) des Pakets nach dem Einreihen (enqueue) wird die Kontrollflussübernahme über `hfsc_dequeue()` -> `qdisc_dequeue_peeked()` -> `sch->dequeue()` ausgelöst; das RDI-Register ist kontrollierbar.

#### 38. CVE-2026-23271

[writeup](https://bsauce.github.io/2026/05/29/CVE-2026-23271/)      [reference](https://github.com/simond67/security-research/tree/Add-kernelCTF-CVE-2026-23271_lts/pocs/linux/kernelctf/CVE-2026-23271_lts)

**Testversion**: Linux-6.12.24

**Schutz**: KASLR/SMEP/SMAP aktiviert.

**Schwachstelle**: In `kernel/events/` (perf-Subsystem) existiert eine UAF-Schwachstelle aufgrund einer Race Condition. Zwischen `__perf_event_overflow()` und `perf_remove_from_context()` besteht eine Race Condition. Bei software-/tracepoint-getriebenen perf-Events deaktiviert die Overflow-Behandlung lediglich die Präemption (die harten Interrupts werden nicht abgeschaltet). In diesem Kontext kann der Bereinigungspfad `perf_event_release_kernel()` → `perf_remove_from_context()` parallel auf einer anderen CPU ausgeführt werden, wodurch callbackbezogener Event-Zustand (z. B. `event->pending_task`) freigegeben wird, während er vom Overflow-Pfad noch verwendet wird – was zu einer UAF führt. Der Fix besteht darin, in `__perf_event_overflow()` einen geeigneten Synchronisationsmechanismus zu ergänzen, der sicherstellt, dass der Freigabepfad nicht parallel fortschreiten kann, solange der Overflow-Pfad auf callbackbezogene Felder zugreift.

- Die Race Condition (der Worker-Thread triggert den Tracepoint-Overflow-Pfad, während der Closer-Thread gleichzeitig `close()` für den perf_event-FD aufruft) löst `WARN_ON_ONCE` aus; nachdem der Refcount auf Null gefallen ist, fügt `task_work_add` das `pending_task` des bereits freigegebenen Events weiterhin zur task_work-Liste hinzu.
- Über `/proc/sys/kernel/tainted` wird das TAINT_WARN-Bit (512) abgefragt, um den erfolgreichen Wettlauf zu erkennen; 1024 Spray-Threads geben synchronisiert frei und belegen mit Event B den von Event A freigegebenen Slab-Slot.
- Wenn `futex_wait` in den Benutzermodus zurückkehrt, führt `perf_pending_task` `put_event(Event B)` aus und dekrementiert den Refcount von Event B fälschlicherweise auf 0, wodurch ein **stabiler Dangling-FD** entsteht.
- Das ID-Oracle weist wiederholt Event C zu, um ID-Änderungen zu erkennen und das Opfer präzise zu lokalisieren. Beim Cross-Cache-Angriff wird die `perf_event_cache`-Slab-Seite an den Buddy-Allocator zurückgegeben und anschließend mit `msg_msgseg` reklamiert.