---

## Catalog

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

---

## Dettagli

#### 1.CVE-2015-8550

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

**Versione testata**: Linux-4.19.65

**Protezione**: KASLR/SMEP abilitati, SMAP non abilitato.

**Vulnerabilità**: vulnerabilità **Double-Fetch** causata dall'ottimizzazione di compilazione di gcc, consente di dirottare direttamente il flusso di controllo.

#### 2. CVE-2016-9793

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

**Versione testata**: Linux-4.8.13

**Protezione**: KASLR/SMAP/SMEP non abilitati. La struttura [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) contraffatta si trova nello spazio utente, quindi ovviamente non può bypassare SMAP.

**Vulnerabilità**: la funzione [sock_setsockopt()](https://elixir.bootlin.com/linux/v4.8.13/source/net/core/sock.c#L658) in `net/core/sock.c` **gestisce erroneamente i valori negativi**, portando `sk_sndbuf` e `sk_rcvbuf` ad assumere valori negativi. Alla chiamata di `write`, `skb->head` e `skb->end` vengono impostati in modo errato; infine, alla chiamata di `close`, durante il rilascio si accede allo spazio utente e si verifica un errore. Viene contraffatta la struttura [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) all'indirizzo utente `0xfffffed0`, e il flusso di controllo viene dirottato tramite `skb_shared_info->destructor_arg->callback`.

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

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

**Versione testata**: Linux-4.20.0-rc3

**Protezione**: SMEP abilitato, KASLR/SMAP non abilitati.

**Vulnerabilità**: vulnerabilità di **integer overflow** in `queue_stack_map_alloc()` nel modulo eBPF di Linux, che causa heap overflow. Modificando il puntatore alla vtable si dirotta il flusso di controllo verso `xchg eax, esp`.

#### 4.CVE-2017-5123

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

**Versione testata**: Linux 4.14-rc4

**Protezione**: SMEP/SMAP abilitati, KASLR disabilitato.

**Vulnerabilità**: l'implementazione di `waitid` in `/kernel/exit.c`, quando chiama `unsafe_put_user()` per copiare dati dal kernel a un indirizzo dello spazio utente, non chiama `access_ok()` per verificare la validità dell'indirizzo utente, consentendo di fatto di copiare dati verso indirizzi dello spazio kernel. **La mancata validazione dell'indirizzo utente in waitid consente una scrittura arbitraria di NULL**. È possibile eseguire shellcode all'indirizzo 0 oppure sovrascrivere la cred in un intervallo ipotizzato per elevare i privilegi.

#### 5.CVE-2017-6074

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

**Versione testata**: Linux-4.9.12

**Protezione**: SMEP/SMAP abilitati, kASLR disabilitato.

**Vulnerabilità**: nel protocollo DCCP (Datagram Congestion Control Protocol) della famiglia di protocolli IP V6 del kernel Linux, la funzione [dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) in `net/dccp/input.c`, nello stato `LISTEN`, gestisce erroneamente la struttura del pacchetto `DCCP_PKT_REQUEST`; quando l'utente chiama `setsockopt()` con l'opzione `IPV6_RECVPKTINFO`, viene innescato un **Double-Free della struttura `sk_buff`**. Il metodo di sfruttamento è simile a CVE-2016-8655. Al primo trigger della vulnerabilità, tramite heap spray viene contraffatta la struttura `po->rx_ring->prb_bdqc->retire_blk_timer`, eseguendo `native_write_cr4(0x406e0)` per disabilitare SMEP/SMAP; al secondo trigger, tramite heap spray viene contraffatta la struttura `skb->...->destructor_arg`, eseguendo `commit_creds(prepare_kernel_cred(0))` per elevare i privilegi.

#### 6.CVE-2017-7308

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

**Versione testata**: Linux-4.10.6

**Protezione**: SMEP/SMAP abilitati, KASLR disabilitato.

**Vulnerabilità**: la funzione [`packet_set_ring()`](https://elixir.bootlin.com/linux/v4.10.6/source/net/packet/af_packet.c#L4181) in `net/packet/af_packet.c` non controlla correttamente la dimensione del blocco; la condizione di controllo della lunghezza è errata, causando **heap overflow**. È richiesto il privilegio `CAP_NET_RAW`. I puntatori a funzione vengono dirottati due volte: prima per disabilitare le protezioni SMEP/SMAP, poi per elevare i privilegi.

#### 7.CVE-2017-8890

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

**Versione testata**: Linux-4.10.15

**Protezione**: SMEP abilitato, kASLR e SMAP disabilitati.

**Vulnerabilità**: la funzione [`inet_csk_clone_lock()`](https://elixir.bootlin.com/linux/v4.10.15/source/net/ipv4/inet_connection_sock.c#L652) nel file `net/ipv4/inet_connection_sock.c` presenta una vulnerabilità di **Double-Free**. Sfruttando il Double-Free si altera il puntatore alla callback di RCU, si disabilita SMEP e si salta alla shellcode per modificare la cred.

#### 8.CVE-2017-11176

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

**Versione testata**: Linux-4.11.9

**Protezione**: SMEP abilitato, kASLR e SMAP disabilitati.

**Vulnerabilità**: nell'implementazione delle code di messaggi POSIX nel kernel Linux, la funzione `mq_notify()` non imposta il puntatore sock a null, causando una UAF. In realtà si tratta di una **Double-Free dovuta a una race condition**, ma la finestra della race condition può essere estesa all'infinito.

#### 9.CVE-2017-16995

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

**Versione testata**: Linux-4.4.110

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: problema di **estensione intera** nel modulo eBPF di Linux. Il problema principale è che i tipi dei valori nei due registri sono diversi, il che comporta una differenza tra il metodo di esecuzione della funzione di controllo e quello della funzione effettiva. Questa vulnerabilità non include attacchi allo stack o dirottamento del flusso di controllo; sfrutta solo i dati delle syscall per elevare i privilegi, ed è un tipico esempio di Data-Oriented Attack sul kernel Linux.

#### 10. CVE-2017-1000112

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

**Versione testata**: Linux-4.12.6

**Protezione**: SMEP abilitato, SMAP/KASLR disabilitati.

**Vulnerabilità**: [__ip_append_data()](https://elixir.bootlin.com/linux/v4.12.6/source/net/ipv4/ip_output.c#L910) in `net/ipv4/ip_output.c` non garantisce la coerenza nell'elaborazione dei datagrammi UDP; ciò consente, tra due invii di pacchetti, di passare dal percorso UFO al percorso non-UFO, causando **heap overflow**. Nello sfruttamento è possibile dirottare il flusso di controllo sovrascrivendo `skb_shared_info->destructor_arg->callback`.

#### 11. CVE-2018-5333

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

**Versione testata**: Linux-4.14.13

**Protezione**: SMEP abilitato, SMAP/KASLR disabilitati.

**Vulnerabilità**: nella funzione [`rds_cmsg_atomic()`](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L788) in `net/rds/rdma.c` si dimentica di azzerare `rm->atomic.op_active`, causando una vulnerabilità di **null-dereference** quando [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) fa riferimento a `page->page_link`. Contraffacendo struttura e puntatori a funzione all'indirizzo 0, si dirotta il flusso di controllo.

#### 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)    

**Versione testata**: Linux-4.20.0 a 32 bit

**Protezione**: SMEP abilitato, SMAP/KASLR disabilitati.

**Vulnerabilità**: 

- CVE-2019-9213: [`expand_downwards()`](https://elixir.bootlin.com/linux/v4.20.7/source/mm/mmap.c#L2413) in `mm/mmap.c` sbaglia il controllo sull'indirizzo minimo di mmap, effettuando il controllo delle capability su un task errato, consentendo di bypassare il limite di `mmap_min_addr`: **vulnerabilità logica**. Utilizzando il comando `LD_DEBUG=help /bin/su 1>&%d` per eseguire un'operazione di write, avrebbe dovuto controllare la cred dell'exploit, ma per errore ha controllato la cred del processo di write, marcando così l'indirizzo basso come accessibile con privilegi. Solo i sistemi a 32 bit riescono a sfruttare la vulnerabilità; il motivo non è noto.
- CVE-2019-8956: la funzione [`sctp_sendmsg()`](https://elixir.bootlin.com/linux/v4.20.7/source/net/sctp/socket.c#L2025) in `net/sctp/socket.c` presenta una vulnerabilità di **null pointer dereference** quando gestisce il flag `SCTP_SENDALL`. Combinata con CVE-2019-9213, bypassando il limite di `mmap_min_addr`, è possibile eseguire mmap all'indirizzo basso `0xd4` e contraffare una struttura, dirottando il flusso di controllo.

#### 13. CVE-2019-15666

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

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

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: [verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379) in `net/xfrm/xfrm_user.c` gestisce erroneamente la validazione di `dir`, causando un **accesso fuori dai limiti** in [__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202). La vulnerabilità è in origine un out-of-bounds di -1; è possibile sfruttare altri percorsi per costruire una UAF e scrivere **8 byte di NULL su un blocco libero**. L'oggetto vulnerabile `xfrm_policy` si trova in `kmalloc-1024`, mentre la struttura cred si trova in `kmalloc-192`. Innanzitutto, usando `setxattr+userfaultfd`, si spruzzano heap chunk `kmalloc-1024` attorno a `policy0`; dopo aver liberato `policy0` si liberano anche i chunk spruzzati, facendo sì che, dopo il rilascio, lo slab venga riutilizzato dalla cred del processo figlio c. Quindi si innesca la UAF per scrivere 8 byte di NULL su un blocco libero, modificando `gid/suid` nella cred, e infine si aggiunge l'utente corrente a sudoers per elevare i privilegi.

#### 14. CVE-2020-8835

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

**Versione testata**: Linux-5.5.0

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: `kernel/bpf/verifier.c` non converte correttamente i valori a 64 bit in 32 bit (prende direttamente i 32 bit inferiori), causando un **troncamento intero** che rende la fase di verifica del codice BPF incoerente con la fase di esecuzione effettiva, portando a letture/scritture fuori dai limiti.

#### 15. CVE-2020-27194

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

**Versione testata**: Linux-5.8.14

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: durante l'operazione OR nel verifier eBPF, la funzione `scalar32_min_max_or()` assegna un valore a 64 bit a una variabile a 32 bit, causando un **troncamento intero** e quindi calcolando erroneamente l'intervallo dei registri, bypassando i controlli di BPF e portando a letture/scritture fuori dai limiti.

#### 16. CVE-2021-3156

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

**Versione testata**: Ubuntu 19.04, Sudo 1.8.27

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: durante l'elaborazione degli argomenti della riga di comando, sudo commette un errore logico quando gestisce un comando che termina con un singolo backslash, causando **heap overflow**.

#### 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)

**Versione testata**: Linux-5.11

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: nel modulo eBPF, la funzione [`__reg_combine_64_into_32()`](https://elixir.bootlin.com/linux/v5.11.20/source/kernel/bpf/verifier.c#L1312) in `kernel/bpf/verifier.c` sbaglia il calcolo dei registri. Sfruttando l'incoerenza tra la fase di verifica e la fase di esecuzione effettiva, si eseguono letture/scritture fuori dai limiti. Dopo aver leakato l'indirizzo di base del kernel, contraffatto la tabella delle funzioni e implementato lettura/scrittura arbitraria, si modifica la cred del thread corrente.

#### 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)

**Versione testata**: Linux-5.11, Linux-5.11.16

**Protezione**: SMEP/SMAP/KASLR abilitati.

**Vulnerabilità**: nel modulo eBPF, il tracciamento dei bound ALU32 per le operazioni bitwise (AND, OR e XOR) in `kernel/bpf/verifier.c` non aggiorna correttamente i bound a 32 bit, causando letture e scritture fuori dai limiti nel kernel Linux e quindi l'esecuzione arbitraria di codice. Le tre funzioni vulnerabili sono [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) e [scalar32_min_max_xor()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7219). Sfruttando l'incoerenza tra la fase di verifica e la fase di esecuzione effettiva, si eseguono letture/scritture fuori dai limiti. Dopo aver leakato l'indirizzo di base del kernel, contraffatto la tabella delle funzioni e implementato lettura/scrittura arbitraria, si modifica la cred del thread corrente.

#### 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)

**Versione testata**: Linux-5.11.14

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: nel sottomodulo `ip_tables` del modulo Netfilter in `net/netfilter/x_tables.c`, quando si chiama `setsockopt()` con l'opzione `IPT_SO_SET_REPLACE` (o `IP6T_SO_SET_REPLACE`), la struttura del kernel deve essere convertita da 32 a 64 bit. A causa di un calcolo errato della dimensione di conversione, durante la chiamata a [xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731) si verifica **heap overflow con scrittura di 0, convertibile in UAF**. Un attaccante può usarla per elevare i privilegi o evadere da container docker o k8s ([kubernetes](https://zhuanlan.zhihu.com/p/29232090)). È richiesto il privilegio `CAP_NET_ADMIN` o il supporto dei namespace `user+network`.

#### 20. CVE-2021-41073

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

**Versione testata**: Linux-5.14.6

**Protezione**: KASLR/SMEP/SMAP abilitati. Non abilitati: `CONFIG_SLAB_FREELIST_RANDOM` / `CONFIG_SLAB_FREELIST_HARDENED` / `CONFIG_BPF_JIT_ALWAYS_ON` / `CONFIG_MEMCG ` (abilitato di default).

**Vulnerabilità**: la funzione `loop_rw_iter()` in `fs/io_uring.c` presenta una vulnerabilità di **type confusion**: `io_kiocb->rw.addr` funge sia da indirizzo kernel che da indirizzo utente, ma in `loop_rw_iter()` viene incrementato senza distinzione, portando a incrementare erroneamente l'indirizzo kernel durante la lettura di un file e infine a **liberare erroneamente un buffer adiacente a un offset controllabile** (kmalloc-32). Le condizioni di sfruttamento sono molto rigide: poiché l'oggetto vulnerabile si trova in kmalloc-32, è necessario disabilitare i meccanismi di protezione della freelist; poiché l'oggetto `seq_operations` viene allocato con il flag `GFP_KERNEL_ACCOUNT`, è necessario disabilitare anche i meccanismi `CONFIG_MEMCG*`; questa vulnerabilità viene sfruttata alterando il puntatore `sk_filter->prog` in eBPF e contraffando un programma BPF per elevare i privilegi, quindi è necessario disabilitare anche `CONFIG_BPF_JIT_ALWAYS_ON`.

#### 21. CVE-2021-4154

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

**Versione testata**: Linux-5.13.3

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: la funzione [cgroup1_parse_param()](https://elixir.bootlin.com/linux/v5.13.3/source/kernel/cgroup/cgroup-v1.c#L905) in `kernel/cgroup/cgroup-v1.c` (innescata tramite la syscall `fsconfig`) presenta una type confusion che porta a una **vulnerabilità UAF**. È possibile chiamare la syscall `fsconfig` per impostare un fd arbitrario; quando il file viene infine chiuso, l'oggetto `file` corrispondente al fd viene liberato. In questo modo possiamo **liberare la struttura `file` corrispondente a un qualsiasi descrittore di file**. Questo articolo adotta due metodi di sfruttamento: il primo è DirtyCred, il secondo è la costruzione di una ROP. Confrontando i due metodi, DirtyCred ha il vantaggio di essere valido su diverse versioni del kernel senza bisogno di adattamento; lo svantaggio è che richiede di sovrascrivere un file privilegiato per elevare i privilegi, quindi non funziona in container come docker. La ROP ha il vantaggio di poter leggere/scrivere arbitrariamente la memoria del kernel ed eseguire codice arbitrario; lo svantaggio è che l'adattamento alle diverse versioni del kernel è molto laborioso.

#### 22. CVE-2021-42008

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

**Versione testata**: Linux-5.13.12

**Protezione**: KASLR / SMEP / SMAP / PTI abilitati.

**Vulnerabilità**: la funzione [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) in `drivers/net/hamradio/6pack.c` presenta **heap overflow**; l'utente deve avere il privilegio `CAP_NET_ADMIN`. [sixpack_decode()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L962) può chiamare [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) più volte, decodificando l'input e salvandolo in [sixpack->cooked_buf](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L98). Il membro `sixpack->rx_count_cooked` funge da indice per accedere a `sixpack->cooked_buf`, determinando l'offset di destinazione per i byte decodificati. Il problema è che, chiamando ripetutamente `decode_data()`, `rx_count_cooked` continua a incrementare finché non supera la lunghezza di `cooked_buf` (400 byte), causando una scrittura fuori dai limiti. Facendo riferimento a [Utilizzo della struttura msg_msg nel kernel Linux per implementare lettura/scrittura a indirizzi arbitrari](https://www.anquanke.com/post/id/252558), si costruiscono lettura fuori dai limiti e scrittura a indirizzi arbitrari, alterando `modprobe_path` per elevare i privilegi. Lo svantaggio è che bisogna usare `userfaultfd` e non si può aggirare il requisito di `CAP_NET_ADMIN`.

#### 23. CVE-2021-43267

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

**Versione testata**: Linux-5.14.15

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: la vulnerabilità si trova nel file `net/tipc/crypto.c`; nel protocollo di comunicazione intra-cluster TIPC (Transparent Inter-Process Communication), la validazione della lunghezza dei messaggi di tipo `MSG_CRYPTO` è errata e causa **heap overflow**. Nella funzione [tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281), la parte dati del messaggio TIPC (struttura [tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)) punta al messaggio `MSG_CRYPTO` (struttura [tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)); quando viene allocato lo spazio per `tipc_aead_key` e copiato `tipc_aead_key->key`, non viene verificata la validità di `tipc_aead_key->keylen`, causando una copia fuori dai limiti. Vengono controllati solo `header size` e `msg size` del messaggio TIPC, ma non `tipc_aead_key->keylen` del messaggio `MSG_CRYPTO`. Utilizzando un oggetto elastico si leakano l'indirizzo di base del kernel e si altera `tty_struct->tty_operations.ioctl` per puntare a un gadget di scrittura arbitraria (`mov QWORD PTR [rdx], rsi`), modificando `modprobe_path` per elevare i privilegi.

#### 24. CVE-2022-0185

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

**Versione testata**: Linux-5.11.22

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: è stato completato il privilege escalation su Google kCTF, vincendo 30.000 dollari. Nel modulo `File System Context` del kernel, nel file `fs/fs_context.c`, è presente un **integer overflow** che causa heap overflow. L'attaccante deve disporre del privilegio `CAP_SYS_ADMIN`, oppure usare i namespace o usare `unshare(CLONE_NEWNS|CLONE_NEWUSER)` (equivalente al comando `$ unshare -Urm`) per entrare in un namespace con privilegio `CAP_SYS_ADMIN`. Ci sono due metodi di sfruttamento: il primo usa **FUSE** (equivalente a userfault) per costruire una scrittura a indirizzo arbitrario e modificare `modprobe_path`; il secondo usa `msg_msg` per costruire un free arbitrario e poi una ROP per elevare i privilegi.

#### 25. CVE-2022-0847

[writeup](https://bsauce.github.io/2022/04/03/CVE-2022-0847/)      riferimento-[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)

**Versione testata**: Linux-5.16.10

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: **vulnerabilità DirtyPipe**. Quando la chiamata `splice` collega la page cache del file al buffer circolare della pipe [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26), le funzioni [copy_page_to_iter_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L384) e [push_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L547) non inizializzano il membro `flag` di [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) (vulnerabilità da variabile non inizializzata). Poiché l'attributo `PIPE_BUF_FLAG_CAN_MERGE` non viene cancellato, nelle successive chiamate a `pipe_write()` si crede erroneamente che l'operazione di scrittura possa essere unita, scrivendo così dati illegittimi nella page cache del file (ripristinabile al riavvio), portando a una vulnerabilità di sovrascrittura di file arbitrari. Questa vulnerabilità permette di scrivere nella page cache di qualsiasi file; il metodo di privilege escalation consiste nel modificare la page cache di `/etc/passwd`, così per un breve periodo tutti i processi che accedono a quel file vedranno la pagina di cache alterata.

#### 26. CVE-2022-0995

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

**Versione testata**: Linux-5.11.22

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: il sottosistema di notifica eventi `watch_queue` presenta **heap overflow**; la funzione vulnerabile è [watch_queue_set_filter()](https://elixir.bootlin.com/linux/v5.16.14/source/kernel/watch_queue.c#L286). Il kernel esegue due controlli di validità sul filtro di tipo [watch_notification_type_filter](https://elixir.bootlin.com/linux/v5.16.14/source/include/uapi/linux/watch_queue.h#L52) passato dall'utente: il primo controllo serve a determinare la dimensione di memoria da allocare, il secondo a memorizzare il filtro utente in tale memoria. Tuttavia i due controlli sono incoerenti, quindi lo spazio allocato è troppo piccolo e si possono memorizzare più filtri causando overflow. Sfruttando il secondo overflow è possibile impostare a 1 bit specifici di un heap chunk adiacente; il metodo di sfruttamento successivo è lo stesso di [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/)      [riferimento](https://blog.dbouman.nl/2022/04/02/How-The-Tables-Have-Turned-CVE-2022-1015-1016/)

**Versione testata**: Linux-5.17

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: nel modulo nftables, le funzioni [nft_parse_register_load()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9325) e [nft_parse_register_store()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9377) non limitano l'intervallo dell'indice dei registri passato in ingresso, causando un integer overflow (che supera la validazione dell'intervallo) e innescando **stack overflow con letture/scritture fuori dai limiti**. Nello sfruttamento è necessario tornare dal contesto di interrupt al contesto utente; occorre sfruttare la parte finale della funzione `__do_softirq()` per tornare perfettamente al contesto della syscall, quindi chiamare `switch_task_namespaces(current, &init_nsproxy)` e `commit_cred(&init_cred)` per elevare i privilegi.

#### 28. CVE-2022-2588

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

**Versione testata**: Linux-5.19.1

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: simile a [CVE-2021-3715](https://access.redhat.com/security/cve/cve-2021-3715) (vedi [BlackHat 2021-Europe-Your Trash Kernel Bug, My Precious 0-day](https://zplin.me/talks/BHEU21_trash_kernel_bug.pdf), pagina 16): poiché le condizioni di controllo durante la rimozione e il rilascio dell'oggetto `route4_filter` dalla lista sono incoerenti, l'oggetto rimane nella lista anche dopo essere stato liberato, consentendo in seguito di innescare un **Double-Free**. È necessario disporre di `User Namespaces` per innescarlo. Per l'elevazione dei privilegi viene usato il metodo **DirtyCred**.

#### 29. CVE-2022-2602

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

**Versione testata**: Linux-5.18.19

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: nel componente io_uring esiste una funzionalità, `IORING_REGISTER_FILES`, che consente di inserire file nella coda `sock->receive_queue` di io_uring. Il meccanismo di garbage collection (GC) di Linux (che gestisce solo i conteggi fluttuanti dei file io_uring e sock) può liberare come spazzatura i file registrati in io_uring; al successivo utilizzo del file da parte di io_uring (scrittura di un file tramite writev, corrispondente alla funzionalità `IORING_OP_WRITEV`) viene innescata una **vulnerabilità UAF**. Per lo sfruttamento, poiché il GC di UNIX_GC libera erroneamente la struttura `file` ancora in uso in `io_uring` (che sta scrivendo dati malevoli nel file normale `"/tmp/rwA"`), è possibile **adottare il metodo DirtyCred**: aprire molti file `"/etc/passwd"` per sovrascrivere la struttura `file` appena liberata, così alla fine i dati malevoli verranno effettivamente scritti nel file `"/etc/passwd"`.

#### 30. CVE-2022-2639

[writeup](https://bsauce.github.io/2022/11/24/CVE-2022-2639/)      [riferimento](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/)

**Versione testata**: Linux-5.17.4

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: nel modulo kernel `openvswitch`, [reserve_sfa_size()](https://elixir.bootlin.com/linux/v5.17.4/source/net/openvswitch/flow_netlink.c#L2439) presenta un integer overflow che causa **heap overflow di scrittura in kmalloc-0x10000**; è necessario usare page spray per costruire un overflow cross-cache. Questo articolo si basa su una `pipe-primitive` per alterare file arbitrari, quindi non è necessario bypassare le protezioni KASLR/SMEP/SMAP/KPTI e lo sfruttamento funziona senza adattamenti tra versioni diverse. **Innanzitutto si crea una pipe e si esegue splice sul file di sola lettura `/usr/bin/mount`; con heap spray si contraffà `pipe_buffer->flags = PIPE_BUF_FLAG_CAN_MERGE`, così da poter scrivere una suid-shell nel file `/usr/bin/mount` ed eseguire il privilege escalation.** L'OOB viene innescato due volte: la prima volta l'overflow altera `msg_msg->m_ts` e legge fuori dai limiti l'adiacente `msg_msg->m_list.next`, **leakando l'indirizzo heap kmalloc-1024**; la seconda volta l'overflow altera `msg_msg->m_list.next` per farlo puntare all'indirizzo heap kmalloc-1024 leakato, **costruendo un free arbitrario**.

#### 31. CVE-2022-25636

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

**Versione testata**: Linux-5.13.19

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: nel modulo `nf_table`, la funzione [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` presenta una **scrittura OOB**, poiché il calcolo dello spazio allocato non è coerente con la condizione di controllo durante l'inizializzazione effettiva (il sistema deve supportare l'offload dell'elaborazione dei pacchetti - Network Interface Cards (NIC) - cosa rara nella pratica). L'overflow scrive l'indirizzo di un oggetto `net_device` (situato in kmalloc-4k). Inoltre la dimensione dell'oggetto vulnerabile può variare (dipende dal numero di regole passate con il flag `NFT_OFFLOAD_F_ACTION`, può essere in `kmalloc-128`, `kmalloc-192`, ecc.). È richiesto il privilegio `SYS_ADMIN`. Nello sfruttamento: **tramite `msg_msgseg` si leakano i puntatori heap di `net_device` in kmalloc-4k; sovrascrivendo il puntatore `msg_msg->security` si costruisce un free arbitrario; usando la funzionalità integrata `ioctl(fd, SIOCGIFHWADDR, leak)` si legge `net_device->dev_addr` per leakare l'indirizzo di base del kernel; contraffando il puntatore a funzione `net_device->ethtool_ops->begin` si dirotta il flusso di controllo per elevare i privilegi**.

#### 32. CVE-2022-27666

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

**Versione testata**: Linux-5.16.14

**Protezione**: KASLR/SMEP/SMAP abilitati.

**Vulnerabilità**: alla competizione PWN2OWN è stato completato il privilege escalation su Ubuntu 21.10. Nel modulo crypto esp6 del kernel, il buffer di ricezione è di 8 pagine, ma il mittente può inviare dati superiori a 8 pagine, causando un **page overflow** tramite la funzione [null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76). Nel complesso si usa la tecnica del page spray: prima si utilizza l'oggetto elastico `user_key_payload` per leakare `msg_msg->next`, poi si usa `msg_msg` per leakare l'indirizzo kernel di `seq_operations->start`, infine si usano `msg_msg` e la gestione dei page fault di FUSE per costruire una scrittura arbitraria e alterare `modprobe_path` per elevare i privilegi.

#### 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)

**Versione testata**: Linux-5.17.12

**Protezione**: KASLR/SMEP/SMAP attivi.

**Vulnerabilità**: nel modulo `nftables`, quando `net/netfilter/nf_tables_api.c` usa la funzionalità `NFT_MSG_NEWSET` per aggiungere un `nft_set`, durante la gestione delle expression `lookup` e `dynset`, a causa di un errato controllo `NFT_EXPR_STATEFUL`, l'oggetto `nft_expr` rimane nella lista `nft_set->binding` dopo essere stato liberato; quando si aggiunge una nuova `nft_expr`, si verifica una **scrittura UAF** (per innescare la vulnerabilità è necessario il permesso `CAP_NET_ADMIN`). La scrittura UAF scrive all'offset 0x18 di un blocco `kmalloc-64` il valore dell'indirizzo all'offset 0x18 di un altro blocco heap `kmalloc-64`. Metodo di sfruttamento: si usa **`msg_msg` nelle mqueue per fare leak dell'indirizzo di base del kernel**, perché `posix_msg_tree_node->msg_list` nelle mqueue ha offset 0x18 (ed è in `kmalloc-64`), esattamente l'offset della scrittura UAF; inoltre **`posix_msg_tree_node->msg_list` può essere usato anche per costruire uno sfruttamento Unlink** per alterare `modprobe_path`. Usare `user_key_payload` per fare leak dell'indirizzo heap (utile per costruire l'unlink) è un classico. Nota: è necessario usare libmnl o libnftnl di versione superiore a quella presente in ubuntu21.04.

#### 34. CVE-2022-34918

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

**Versione testata**: Linux-5.17.15

**Protezione**: KASLR/SMEP/SMAP attivi.

**Vulnerabilità**: nel modulo nftables, la funzione [nft_set_elem_init()](https://elixir.bootlin.com/linux/v5.18.10/source/net/netfilter/nf_tables_api.c#L5459) presenta un **heap overflow** di lunghezza fino a `64-16=48` byte; l'oggetto vulnerabile può trovarsi in `kmalloc-{64,96,128,192}` (in questo articolo, per lo sfruttamento, si sceglie l'oggetto vulnerabile in kmalloc-64). Sfruttamento: prima si costruisce il layout di heap `vul_obj -> user_key_payload -> percpu_ref_data`; l'overflow modifica `user_key_payload->datalen` a 0xffff, in modo da ottenere il leak dell'indirizzo di base del kernel da `percpu_ref_data->release` e dell'indirizzo physmap da `percpu_ref_data->ref`; poi si costruisce il layout di heap `vul_obj -> simple_xattr`; l'overflow modifica la lista `simple_xattr->list` e, sfruttando questa scrittura arbitraria limitata, si modifica `modprobe_path` da `/sbin/modprobe` a `/tmp/xxxxprobe` per elevare i privilegi (la scrittura arbitraria viene innescata quando l'xattr viene rimosso dalla lista). Il prerequisito di questa scrittura arbitraria è ottenere il leak dell'indirizzo physmap; sia `percpu_ref_data` che `shm_file_data` contengono sia l'indirizzo di base del kernel che l'indirizzo physmap.

#### 35. CVE-2023-2598

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

**Versione testata**: Linux-6.3.1

**Protezione**: KASLR/SMEP/SMAP attivi.

**Vulnerabilità**: una vulnerabilità di scrittura OOB nel modulo io_uring, che può causare **lettura/scrittura fuori dai limiti della memoria fisica**. La vulnerabilità si trova nella funzione [io_sqe_buffer_register()](https://elixir.bootlin.com/linux/v6.3.1/source/io_uring/rsrc.c#L1230) nel file `io_uring/rsrc.c`: quando si verifica che le pagine proposte per la registrazione appartengano alla stessa pagina composita, viene controllato solo che la prima pagina della compound page sia la stessa, senza verificare che le pagine proposte siano la stessa pagina. È quindi possibile registrare la stessa pagina fisica (spacciandola per una compound page composta da più pagine fisiche) e realizzare una lettura/scrittura fuori dai limiti di lunghezza arbitraria sulla pagina fisica.

Sfruttando la lettura/scrittura fuori dai limiti di lunghezza arbitraria sulla pagina fisica, è possibile leggere/scrivere arbitrariamente l'oggetto sock successivo; tramite `sock->sk_data_ready` si ottiene il leak dell'indirizzo di base del kernel, tramite `sock.sk_error_queue.next` si ottiene il leak dell'indirizzo heap dell'oggetto sock; falsificando il puntatore a funzione `sock.__sk_common.skc_prot->ioctl` in modo che punti a [call_usermodehelper_exec()](https://elixir.bootlin.com/linux/v6.3.1/source/kernel/umh.c#L434) si **dirotta il flusso di controllo**; è inoltre necessario falsificare la struttura `subprocess_info` per completare lo sfruttamento e infine **eseguire `/bin/sh -c /bin/sh &>/dev/ttyS0 </dev/ttyS0` per elevare i privilegi**.

#### 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)

**Versione testata**: Linux-6.3.13

**Protezione**: KASLR/SMEP/SMAP attivi.

**Vulnerabilità**: nel componente nf_tables del sottosistema netfilter è presente una **vulnerabilità UAF**. Nella funzione [nft_verdict_init()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/nf_tables_api.c#L10321) è consentito impostare un valore di verdict molto grande (valore malevolo 0xffff0000); nella funzione [nf_hook_slow()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/core.c#L607), durante la gestione di `NF_DROP` (0), viene prima liberato il pacchetto skb e viene chiamata [NF_DROP_GETERR()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L19) per modificare il valore di ritorno (impostato a `NF_ACCEPT` - valore positivo 1, in base al valore di verdict). Il successivo riferimento all'oggetto skb innesca la UAF e [NF_HOOK()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L407) libera nuovamente l'oggetto skb. Metodo di sfruttamento: **si costruiscono pagine PMD e PTE sovrapposte**; `PMD[0]`/`PMD[1]` sovrascrivono `PTE[0]`/`PTE[1]`; scrivendo negli indirizzi virtuali utente corrispondenti alla pagina PTE si falsifica la pagina PTE corrispondente a `PMD[0]` (le voci corrispondono a indirizzi fisici), in modo che scrivendo negli indirizzi virtuali utente corrispondenti al PMD si **realizzi una scrittura a un indirizzo fisico arbitrario**.

#### 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)

**Versione testata**: Linux-6.6.75

**Protezione**: KASLR/SMEP/SMAP attivi.

**Vulnerabilità**: nel modulo `net/sched`, quando si chiama la funzione `pfifo_tail_enqueue()` su un qdisc (con `sch->limit == 0`), la lunghezza della coda qlen di quel qdisc viene erroneamente incrementata (nonostante la coda sia piena, viene aggiunto un nuovo pacchetto senza prima scartarne uno), mentre la qlen del qdisc padre (il chiamante) non viene incrementata; questo fa sì che la qlen della coda padre non sia uguale alla somma delle qlen delle code figlie, rendendo possibile costruire una UAF. Leak dell'indirizzo di base del kernel: sfruttando il principio di inserimento di un nodo nell'albero rosso-nero si modifica `user_key_payload->datalen` per costruire una lettura fuori dai limiti e ottenere il leak del puntatore a funzione `xfrm_policy_timer` nell'oggetto `xfrm_policy` adiacente. Dirottamento del flusso di controllo: si falsifica il puntatore a funzione `UAF_hfsc_class->dequeue`; tramite la rimozione dalla coda dopo l'inserimento del pacchetto si innesca la sequenza `hfsc_dequeue()` -> `qdisc_dequeue_peeked()` -> `sch->dequeue()`, dirottando il flusso di controllo con il registro RDI controllabile.

#### 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)

**Versione testata**: Linux-6.12.24

**Protezione**: KASLR/SMEP/SMAP attivi.

**Vulnerabilità**: in `kernel/events/` (sottosistema perf) esiste una vulnerabilità UAF dovuta a una condizione di competizione. Esiste una race condition tra `__perf_event_overflow()` e `perf_remove_from_context()`. Per gli eventi perf guidati da software/tracepoint, la gestione dell'overflow disabilita solo la preemption (non disattiva gli interrupt hardware). In questo contesto, il percorso di cleanup `perf_event_release_kernel()` → `perf_remove_from_context()` può essere eseguito in modo concorrente su un'altra CPU, liberando lo stato dell'evento correlato ai callback (ad esempio `event->pending_task`) mentre il percorso di overflow lo sta ancora utilizzando, causando una UAF. La soluzione è aggiungere un adeguato meccanismo di sincronizzazione in `__perf_event_overflow()`, assicurando che il percorso di rilascio non possa avanzare in modo concorrente mentre il percorso di overflow accede ai campi correlati ai callback.
- La race (il thread Worker innesca il percorso di overflow del tracepoint, il thread Closer esegue in modo concorrente `close()` sulla fd dell'evento perf) innesca `WARN_ON_ONCE`; dopo che il refcount è sceso a zero, `task_work_add` aggiunge comunque `pending_task` dell'evento già liberato alla lista task_work.
- Eseguendo il polling di `/proc/sys/kernel/tainted` per il bit TAINT_WARN (512) si rileva il successo della race; 1024 thread di spray si sincronizzano per la liberazione e usano l'evento B per occupare lo slot slab liberato dall'evento A.
- Quando `futex_wait` ritorna in userland, `perf_pending_task` esegue `put_event(evento B)`, decrementando erroneamente il refcount dell'evento B a 0, formando una **FD pendente stabile**.
- L'ID Oracle alloca iterativamente l'evento C per sondare i cambiamenti di ID e individuare con precisione la vittima; l'attacco cross-cache restituisce la pagina slab di `perf_event_cache` al buddy e poi la rialloca con `msg_msgseg`.