---

## Catalogue

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

---

## Détail

#### 1. CVE-2015-8550

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

**Version de test** : Linux-4.19.65

**Protection** : KASLR/SMEP activés, SMAP désactivé.

**Vulnérabilité** : **Double-Fetch** causé par une optimisation de compilation de gcc, permettant de détourner directement le flux de contrôle.

#### 2. CVE-2016-9793

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

**Version de test** : Linux-4.8.13

**Protection** : KASLR/SMAP/SMEP désactivés. La structure [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) falsifiée se trouve dans l'espace utilisateur, elle ne peut donc manifestement pas contourner SMAP.

**Vulnérabilité** : la fonction [sock_setsockopt()](https://elixir.bootlin.com/linux/v4.8.13/source/net/core/sock.c#L658) dans `net/core/sock.c` **gère incorrectement les valeurs négatives**, ce qui rend `sk_sndbuf` et `sk_rcvbuf` négatifs. Lors de l'appel à `write`, `skb->head` et `skb->end` sont définis de manière incorrecte, puis lors de l'appel à `close` pour la libération, un accès à l'espace utilisateur provoque une erreur. Une structure [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) est falsifiée à l'adresse utilisateur `0xfffffed0`, et le flux de contrôle est détourné via `skb_shared_info->destructor_arg->callback`.

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

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

**Version de test** : Linux-4.20.0-rc3

**Protection** : SMEP activé, KASLR/SMAP désactivés.

**Vulnérabilité** : **débordement d'entier** dans `queue_stack_map_alloc()` du module eBPF de Linux, conduisant à un débordement de tas. Le pointeur de table virtuelle est modifié pour détourner le flux de contrôle vers `xchg eax, esp`.

#### 4. CVE-2017-5123

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

**Version de test** : Linux 4.14-rc4

**Protection** : SMEP / SMAP activés, KASLR désactivé.

**Vulnérabilité** : l'implémentation de `waitid` dans `/kernel/exit.c`, lors de l'appel à `unsafe_put_user()` pour copier des données du noyau vers une adresse utilisateur, n'appelle pas `access_ok()` pour vérifier la validité de l'adresse utilisateur, ce qui permet en réalité d'écrire vers une adresse de l'espace noyau. **waitid ne vérifie pas la validité de l'adresse utilisateur, ce qui permet une écriture arbitraire à l'adresse nulle**. Il est possible d'exécuter un shellcode à l'adresse 0 ou de corrompre un cred situé dans une plage devinée pour élever les privilèges.

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

**Version de test** : Linux-4.9.12

**Protection** : SMEP/SMAP activés, kASLR désactivé.

**Vulnérabilité** : dans le protocole DCCP (Datagram Congestion Control Protocol) de la famille de protocoles IPv6 du noyau Linux, la fonction [dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) de `net/dccp/input.c` gère incorrectement la structure de données du paquet `DCCP_PKT_REQUEST` dans l'état `LISTEN`. Lorsque l'utilisateur appelle `setsockopt()` avec l'option `IPV6_RECVPKTINFO`, cela déclenche un **Double-Free de la structure `sk_buff`**. La méthode d'exploitation est similaire à celle de CVE-2016-8655. Première exploitation : heap-spray pour falsifier la structure `po->rx_ring->prb_bdqc->retire_blk_timer` et exécuter `native_write_cr4(0x406e0)` afin de désactiver SMEP/SMAP ; deuxième exploitation : heap-spray pour falsifier la structure `skb-> ... ->destructor_arg` et exécuter `commit_creds(prepare_kernel_cred(0))` pour élever les privilèges.

#### 6. CVE-2017-7308

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

**Version de test** : Linux-4.10.6

**Protection** : SMEP / SMAP activés, KASLR désactivé.

**Vulnérabilité** : la fonction [`packet_set_ring()`](https://elixir.bootlin.com/linux/v4.10.6/source/net/packet/af_packet.c#L4181) de `net/packet/af_packet.c` ne vérifie pas correctement la taille des blocs, la condition de contrôle de longueur est erronée, ce qui conduit à un **débordement de tas** nécessitant le privilège `CAP_NET_RAW`. Deux détournements de pointeur de fonction sont effectués : d'abord désactivation des protections SMEP/SMAP, puis élévation de privilèges.

#### 7. CVE-2017-8890

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

**Version de test** : Linux-4.10.15

**Protection** : SMEP activé, kASLR et SMAP désactivés.

**Vulnérabilité** : la fonction [`inet_csk_clone_lock()`](https://elixir.bootlin.com/linux/v4.10.15/source/net/ipv4/inet_connection_sock.c#L652) du fichier `net/ipv4/inet_connection_sock.c` présente une vulnérabilité de **Double-Free**. L'exploitation du Double-Free permet de falsifier le pointeur de fonction du callback RCU, de désactiver SMEP et de sauter vers un shellcode pour modifier le cred.

#### 8. CVE-2017-11176

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

**Version de test** : Linux-4.11.9

**Protection** : SMEP activé, kASLR et SMAP désactivés.

**Vulnérabilité** : dans l'implémentation des files de messages POSIX du noyau Linux, la fonction `mq_notify()` ne met pas le pointeur sock à null, ce qui provoque une UAF. Il s'agit en réalité d'une **Double-Free causée par une course**, mais la fenêtre de la course peut être prolongée indéfiniment.

#### 9. CVE-2017-16995

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

**Version de test** : Linux-4.4.110

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : problème d'**extension d'entier** dans le module eBPF de Linux. Le problème principal est que les types de valeurs des deux registres diffèrent, ce qui rend la méthode d'exécution de la fonction de vérification incohérente avec celle de la fonction réelle. Cette vulnérabilité n'implique pas d'attaque par pile ni de détournement de flux de contrôle ; elle n'utilise que des données d'appels système pour élever les privilèges. C'est une application typique des attaques orientées données (Data-Oriented Attacks) sur le noyau Linux.

#### 10. CVE-2017-1000112

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

**Version de test** : Linux-4.12.6

**Protection** : SMEP activé, SMAP/kaslr désactivés.

**Vulnérabilité** : [`__ip_append_data()`](https://elixir.bootlin.com/linux/v4.12.6/source/net/ipv4/ip_output.c#L910) dans `net/ipv4/ip_output.c` ne garantit pas la cohérence du traitement des datagrammes UDP, ce qui permet, lors de l'envoi de deux messages, de basculer du chemin UFO au chemin non-UFO, provoquant un **débordement de tas**. Lors de l'exploitation, il est possible de détourner le flux de contrôle en corrompant `skb_shared_info->destructor_arg->callback`.

#### 11. CVE-2018-5333

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

**Version de test** : Linux-4.14.13

**Protection** : SMEP activé, SMAP/kaslr désactivés.

**Vulnérabilité** : dans la fonction [`rds_cmsg_atomic()`](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L788) de `net/rds/rdma.c`, on oublie de remettre `rm->atomic.op_active` à 0, ce qui provoque un **déréférencement de pointeur nul (`null-dereference`)** lorsque [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) référence `page->page_link`. Des structures et des pointeurs de fonction sont falsifiés à l'adresse 0 pour détourner le flux de contrôle.

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

**Version de test** : Linux-4.20.0 32 bits

**Protection** : SMEP activé, SMAP/kaslr désactivés.

**Vulnérabilité** : 

- CVE-2019-9213 : [`expand_downwards()`](https://elixir.bootlin.com/linux/v4.20.7/source/mm/mmap.c#L2413) dans `mm/mmap.c` fait une erreur dans la vérification de l'adresse minimale de mmap, en effectuant la vérification de capacité sur une mauvaise tâche, ce qui contourne la restriction `mmap_min_addr` : c'est un **défaut logique**. En utilisant la commande `LD_DEBUG=help /bin/su 1>&%d` pour effectuer une écriture, le cred de l'exp est censé être vérifié, mais c'est par erreur le cred du processus d'écriture qui est vérifié, ce qui marque l'adresse basse comme accessible aux privilégiés. Seuls les systèmes 32 bits peuvent exploiter cette vulnérabilité avec succès, pour des raisons inconnues.
- CVE-2019-8956 : la fonction [`sctp_sendmsg()`](https://elixir.bootlin.com/linux/v4.20.7/source/net/sctp/socket.c#L2025) de `net/sctp/socket.c` présente une **déréférence de pointeur nul** lors du traitement du flag `SCTP_SENDALL`. Combinée à CVE-2019-9213, elle permet de contourner la restriction `mmap_min_addr`, de faire un mmap à l'adresse basse 0xd4 et de falsifier des structures pour détourner le flux de contrôle.

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

**Version de test** : Ubuntu 18.04 (4.15.0-20-generic #21)

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : [verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379) dans `net/xfrm/xfrm_user.c` gère incorrectement la validation de `dir`, ce qui provoque un **accès hors bornes** dans [__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202). À l'origine, la vulnérabilité est un hors-bounds de soustraction de 1, mais on peut emprunter un autre chemin pour construire une UAF et **écrire 8 octets de zéros sur un bloc libre**. L'objet vulnérable `xfrm_policy` se trouve dans `kmalloc-1024`, tandis que la structure cred se trouve dans `kmalloc-192`. On utilise d'abord `setxattr+userfaultfd` pour arroser des blocs `kmalloc-1024` autour de `policy0`. Après avoir libéré `policy0`, on libère simultanément les blocs arrosés, ce qui fait que, une fois ce slab libéré, il est réutilisé par le cred du processus fils c. On déclenche ensuite l'écriture de 8 octets NULL sur le bloc libre via l'UAF pour modifier `gid/suid` dans le cred, puis on ajoute l'utilisateur courant à sudoers afin d'élever les privilèges.

#### 14. CVE-2020-8835

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

**Version de test** : Linux-5.5.0

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : kernel/bpf/verifier.c ne convertit pas correctement les valeurs 64 bits en 32 bits (il prend directement les 32 bits inférieurs), ce qui provoque une **troncature d'entier** rendant la phase de validation du code BPF incohérente avec la phase d'exécution réelle, et permettant des lectures/écritures hors bornes.

#### 15. CVE-2020-27194

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

**Version de test** : Linux-5.8.14

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : lors d'une opération OR dans le vérificateur eBPF, la fonction `scalar32_min_max_or()` affecte une valeur 64 bits à une variable 32 bits, provoquant une **troncature d'entier** qui conduit à un mauvais calcul de la plage des registres, contournant ainsi les vérifications de BPF et permettant des lectures/écritures hors bornes.

#### 16. CVE-2021-3156

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

**Version de test** : Ubuntu 19.04, Sudo 1.8.27

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : lors du traitement des arguments de la ligne de commande, sudo commet une erreur logique en traitant une commande se terminant par un simple backslash, ce qui provoque un **débordement de tas**.

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

**Version de test** : Linux-5.11

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : dans le module eBPF, la fonction [`__reg_combine_64_into_32()`](https://elixir.bootlin.com/linux/v5.11.20/source/kernel/bpf/verifier.c#L1312) de `kernel/bpf/verifier.c` fait une erreur de calcul sur les registres. En exploitant l'incohérence entre la phase de vérification et la phase d'exécution réelle, on effectue des lectures/écritures hors bornes. On divulgue l'adresse de base du noyau, on falsifie une table de fonctions, on réalise des lectures/écritures arbitraires, puis on modifie le cred du thread courant.

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

**Version de test** : Linux-5.11  Linux-5.11.16

**Protection** : SMEP/SMAP/kaslr activés.

**Vulnérabilité** : dans le module eBPF, le suivi des limites 32 bits de l'ALU32 eBPF pour les opérations bit à bit (AND, OR et XOR) de `kernel/bpf/verifier.c` ne met pas correctement à jour les limites 32 bits, ce qui provoque des lectures et écritures hors bornes dans le noyau Linux et donc une exécution de code arbitraire. Les trois fonctions vulnérables sont [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) et [scalar32_min_max_xor()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7219). En exploitant l'incohérence entre la phase de vérification et la phase d'exécution réelle, on effectue des lectures/écritures hors bornes. On divulgue l'adresse de base du noyau, on falsifie une table de fonctions, on réalise des lectures/écritures arbitraires, puis on modifie le cred du thread courant.

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

**Version de test** : Linux-5.11.14

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le sous-module `ip_tables` du module `Netfilter` de `net/netfilter/x_tables.c`, lors de l'appel à `setsockopt()` avec l'option `IPT_SO_SET_REPLACE` (ou `IP6T_SO_SET_REPLACE`), la structure du noyau doit être convertie de 32 bits à 64 bits. En raison d'une erreur de calcul de la taille de conversion, l'appel à la fonction [xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731) provoque une **écriture de 0 par débordement de tas, convertible en UAF**. Un attaquant peut l'utiliser pour élever ses privilèges ou s'échapper des conteneurs docker et k8s ([kubernetes](https://zhuanlan.zhihu.com/p/29232090)). Le privilège `CAP_NET_ADMIN` est requis, ou la prise en charge des espaces de noms `user+network`.

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

**Version de test** : Linux-5.14.6

**Protection** : KASLR/SMEP/SMAP activés. `CONFIG_SLAB_FREELIST_RANDOM` / `CONFIG_SLAB_FREELIST_HARDENED` / `CONFIG_BPF_JIT_ALWAYS_ON` / `CONFIG_MEMCG` désactivés (ce dernier est activé par défaut).

**Vulnérabilité** : la fonction `loop_rw_iter()` de `fs/io_uring.c` présente une **vulnérabilité de type confusion** : `io_kiocb->rw.addr` sert à la fois d'adresse noyau et d'adresse utilisateur, mais lors de son incrémentation dans `loop_rw_iter()`, aucune distinction n'est faite, ce qui fait que lors de la lecture d'un fichier, l'adresse noyau est incrémentée par erreur, et finalement **un buffer adjacent situé à un offset contrôlable est libéré à tort** (kmalloc-32). Les conditions d'exploitation sont très strictes : comme l'objet vulnérable se trouve dans kmalloc-32, la protection freelist est désactivée ; comme l'objet `seq_operations` est alloué avec le flag `GFP_KERNEL_ACCOUNT`, le mécanisme `CONFIG_MEMCG*` est également désactivé ; cette exploitation modifie le pointeur `sk_filter->prog` dans eBPF et falsifie un programme BPF pour élever les privilèges, donc la configuration `CONFIG_BPF_JIT_ALWAYS_ON` est aussi désactivée.

#### 21. CVE-2021-4154

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

**Version de test** : Linux-5.13.3

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : la fonction [cgroup1_parse_param()](https://elixir.bootlin.com/linux/v5.13.3/source/kernel/cgroup/cgroup-v1.c#L905) de `kernel/cgroup/cgroup-v1.c` (déclenchée via l'appel système `fsconfig`) présente une confusion de type menant à une **UAF**. On peut appeler l'appel système `fsconfig` pour définir un fd arbitraire, puis, une fois ce fichier fermé, l'objet `file` correspondant au fd est libéré. Ainsi, on peut **libérer la structure `file` correspondant à n'importe quel descripteur de fichier**. Cet article utilise deux méthodes d'exploitation : DirtyCred et construction d'une ROP. En comparant les deux méthodes, DirtyCred a l'avantage d'être générique entre les versions du noyau, sans adaptation nécessaire, mais l'inconvénient de nécessiter l'écrasement d'un fichier privilégié pour élever les privilèges, ce qui la rend inefficace dans les conteneurs docker. La ROP a l'avantage de permettre des lectures/écritures arbitraires de la mémoire du noyau et l'exécution de code arbitraire, mais l'inconvénient d'une adaptation fastidieuse aux différentes versions du noyau.

#### 22. CVE-2021-42008

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

**Version de test** : Linux-5.13.12

**Protection** : KASLR / SMEP / SMAP / PTI activés.

**Vulnérabilité** : la fonction [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) de `drivers/net/hamradio/6pack.c` présente un **débordement de tas**, l'utilisateur devant posséder le privilège `CAP_NET_ADMIN`. [sixpack_decode()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L962) peut appeler plusieurs fois [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) pour décoder l'entrée et l'enregistrer dans [sixpack->cooked_buf](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L98). Le membre `sixpack->rx_count_cooked` sert d'indice d'accès à `sixpack->cooked_buf`, déterminant l'offset cible de l'écriture des octets décodés. Le problème est que si `decode_data()` est appelée plusieurs fois, `rx_count_cooked` ne cesse d'augmenter jusqu'à dépasser la longueur de `cooked_buf` (400 octets), provoquant une écriture hors bornes. En se référant à l'article [Utilisation de la structure msg_msg dans le noyau Linux pour réaliser des lectures/écritures arbitraires](https://www.anquanke.com/post/id/252558), on construit une lecture hors bornes et une écriture arbitraire pour modifier `modprobe_path` et élever les privilèges. L'inconvénient est la nécessité d'utiliser `userfaultfd`, et l'impossibilité de contourner l'exigence `CAP_NET_ADMIN`.

#### 23. CVE-2021-43267

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

**Version de test** : Linux-5.14.15

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : la vulnérabilité se situe dans le fichier `net/tipc/crypto.c`. Dans le protocole de communication au sein d'un cluster TIPC (Transparent Inter-Process Communication), la vérification de la longueur des messages de type `MSG_CRYPTO` est erronée, ce qui conduit à un **débordement de tas**. Dans la fonction [tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281), la partie données du message TIPC (structure [tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)) pointe vers le message `MSG_CRYPTO` (structure [tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)). Lors de l'allocation de l'espace pour `tipc_aead_key` et de la copie de `tipc_aead_key->key`, la validité de `tipc_aead_key->keylen` n'est pas vérifiée, ce qui provoque une copie hors bornes. Seuls `header size` et `msg size` du message TIPC sont vérifiés, mais pas `tipc_aead_key->keylen` du message `MSG_CRYPTO`. On utilise un objet élastique (`elastic object`) pour divulguer l'adresse de base du noyau, puis on modifie `tty_struct->tty_operations.ioctl` pour pointer vers un gadget d'écriture arbitraire (`mov   QWORD PTR [rdx],rsi`), et on modifie `modprobe_path` pour élever les privilèges.

#### 24. CVE-2022-0185

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

**Version de test** : Linux-5.11.22

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : l'élévation de privilèges a été réalisée sur google kctf, avec 30 000 dollars à la clé. Dans le module `File System Context` du noyau, le fichier `fs/fs_context.c` présente un **débordement d'entier** conduisant à un débordement de tas. L'attaquant doit posséder le privilège `CAP_SYS_ADMIN`, ou utiliser un espace de noms, ou encore `unshare(CLONE_NEWNS|CLONE_NEWUSER)` (équivalent à la commande `$ unshare -Urm`) pour entrer dans un espace de noms conférant `CAP_SYS_ADMIN`. Deux méthodes d'exploitation : la première utilise **FUSE** (équivalent de userfault) pour construire une écriture arbitraire et modifier `modprobe_path` ; la seconde utilise `msg_msg` pour construire une libération arbitraire, puis une ROP pour élever les privilèges.

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

**Version de test** : Linux-5.16.10

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : vulnérabilité **DirtyPipe**. Lorsque l'appel `splice` lie le cache de pages (`page cache`) d'un fichier au tampon circulaire du pipe [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26), les fonctions [copy_page_to_iter_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L384) et [push_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L547) n'initialisent pas le membre `flag` de [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) (vulnérabilité de variable non initialisée). Comme l'attribut `PIPE_BUF_FLAG_CAN_MERGE` n'est pas effacé, un appel ultérieur à `pipe_write()` croit à tort que l'opération d'écriture peut être fusionnée, et écrit ainsi des données illégitimes dans le cache de pages du fichier (restaurées après redémarrage), d'où une vulnérabilité de recouvrement arbitraire de fichiers. Cette vulnérabilité permet d'écrire dans le page cache de n'importe quel fichier ; la méthode d'élévation de privilèges consiste à modifier le page cache de `/etc/passwd` : pendant un court instant, tous les processus accédant à ce fichier verront la page de cache falsifiée.

#### 26. CVE-2022-0995

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

**Version de test** : Linux-5.11.22

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : le sous-système de notification d'événements `watch_queue` présente un **débordement de tas** ; la fonction vulnérable est [watch_queue_set_filter()](https://elixir.bootlin.com/linux/v5.16.14/source/kernel/watch_queue.c#L286). Le noyau effectue deux vérifications de validité sur le filtre de type [watch_notification_type_filter](https://elixir.bootlin.com/linux/v5.16.14/source/include/uapi/linux/watch_queue.h#L52) fourni par l'utilisateur : la première sert à déterminer la taille de mémoire à allouer, la seconde à stocker le filtre utilisateur dans cette mémoire. Cependant, les deux vérifications sont incohérentes, ce qui conduit à une allocation trop petite et permet de stocker plus de filtres que prévu, provoquant un débordement. On peut utiliser ce second débordement pour mettre à 1 des bits spécifiques d'un bloc adjacent ; la méthode d'exploitation qui suit est identique à celle de [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/)

**Version de test** : Linux-5.17

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le module nftables, les fonctions [nft_parse_register_load()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9325) et [nft_parse_register_store()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9377) ne limitent pas la plage de l'indice de registre transmis, ce qui provoque un débordement d'entier (pouvant passer la vérification de plage) et déclenche un **débordement de pile avec lectures/écritures hors bornes**. Lors de l'exploitation, il faut revenir du contexte d'interruption à l'espace utilisateur ; on utilise la fin de la fonction `__do_softirq()` pour revenir parfaitement au contexte de l'appel système, puis on appelle `switch_task_namespaces(current, &init_nsproxy)` et `commit_cred(&init_cred)` pour élever les privilèges.

#### 28. CVE-2022-2588

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

**Version de test** : Linux-5.19.1

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : similaire à [CVE-2021-3715](https://access.redhat.com/security/cve/cve-2021-3715) (voir [BlackHat 2021-Europe-Your Trash Kernel Bug, My Precious 0-day](https://zplin.me/talks/BHEU21_trash_kernel_bug.pdf), page 16) : la condition de vérification lors du retrait de l'objet `route4_filter` de la liste chaînée et lors de sa libération étant incohérente, l'objet reste dans la liste après avoir été libéré, ce qui permet de déclencher un **Double-Free** par la suite. Des `User Namespaces` sont nécessaires pour déclencher la vulnérabilité. L'élévation de privilèges utilise la méthode **DirtyCred**.

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

**Version de test** : Linux-5.18.19

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : le composant io_uring dispose d'une fonctionnalité `IORING_REGISTER_FILES` permettant de placer des fichiers dans la file `sock->receive_queue` d'io_uring. Or, le mécanisme de garbage collection GC de Linux (qui ne traite que les compteurs de vol des fichiers io_uring et sock) peut libérer par erreur les fichiers enregistrés dans io_uring comme s'il s'agissait de déchets ; lors de la prochaine utilisation de ce fichier par io_uring (écriture dans un fichier via writev, correspondant à la fonctionnalité `IORING_OP_WRITEV`), une **UAF** est déclenchée. Méthode d'exploitation : comme le GC UNIX libère par erreur une structure `file` encore utilisée par io_uring (en train d'écrire des données malveillantes dans le fichier ordinaire `"/tmp/rwA"`), on peut **adopter la méthode DirtyCred** : ouvrir un grand nombre de fichiers `"/etc/passwd"` pour recouvrir la structure `file` tout juste libérée, de sorte qu'à la fin, les données malveillantes soient réellement écrites dans le fichier `"/etc/passwd"`.

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

**Version de test** : Linux-5.17.4

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le module noyau `openvswitch`, [reserve_sfa_size()](https://elixir.bootlin.com/linux/v5.17.4/source/net/openvswitch/flow_netlink.c#L2439) présente un débordement d'entier conduisant à une **écriture hors bornes dans un tas kmalloc-0x10000** ; une technique de page-spray est nécessaire pour construire un débordement cross-cache. Cet article se base sur la **pipe-primitive** pour modifier des fichiers arbitraires, il n'est donc pas nécessaire de contourner les protections KASLR/SMEP/SMAP/KPTI, et l'exploitation fonctionne sans adaptation entre les versions. **On crée d'abord un pipe et on fait un splice vers le fichier en lecture seule `/usr/bin/mount`, puis on heap-spray pour falsifier `pipe_buffer->flags = PIPE_BUF_FLAG_CAN_MERGE`, ce qui permet d'écrire un shell suid dans `/usr/bin/mount` puis de l'exécuter pour élever les privilèges.**        Le déclenchement de l'OOB se fait deux fois : la première consiste à déborder pour falsifier `msg_msg->m_ts` et lire hors bornes le `msg_msg->m_list.next` adjacent afin de **divulguer l'adresse du tas kmalloc-1024** ; la seconde consiste à déborder pour falsifier `msg_msg->m_list.next` pour qu'il pointe vers l'adresse de tas kmalloc-1024 divulguée, afin de **construire une libération arbitraire**.

#### 31. CVE-2022-25636

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

**Version de test** : Linux-5.13.19

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le module `nf_table`, la fonction [nft_fwd_dup_netdev_offload()](https://elixir.bootlin.com/linux/v5.16.11/source/net/netfilter/nf_dup_netdev.c#L67) de `net/netfilter/nf_dup_netdev.c` présente une **écriture hors bornes (OOB write)** (le système doit prendre en charge le déchargement du traitement des paquets - Network Interface Cards (NICs), ce qui est toutefois rare en pratique), car la condition utilisée pour calculer l'espace d'allocation et celle utilisée lors de l'initialisation réelle sont incohérentes. **L'écriture déborde en écrivant l'adresse d'un objet `net_device` (situé dans kmalloc-4k)**, et la taille de l'objet vulnérable peut varier (elle est déterminée par le nombre de rules contenant le flag `NFT_OFFLOAD_F_ACTION`, pouvant se trouver dans kmalloc-128, kmalloc-192, etc.), nécessitant le privilège `SYS_ADMIN`. Lors de l'exploitation, **on utilise `msg_msgseg` pour divulguer le pointeur de tas `net_device` kmalloc-4k, on construit une libération arbitraire en écrasant le pointeur `msg_msg->security`, on utilise la fonctionnalité intégrée `ioctl(fd, SIOCGIFHWADDR, leak)` pour lire `net_device->dev_addr` et divulguer l'adresse de base du noyau, puis on falsifie le pointeur de fonction `net_device->ethtool_ops->begin` pour détourner le flux de contrôle et élever les privilèges**.

#### 32. CVE-2022-27666

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

**Version de test** : Linux-5.16.14

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : lors du concours PWN2OWN, l'élévation de privilèges sur Ubuntu 21.10 a été réalisée. Dans le module crypto esp6 du noyau, le tampon de réception est de 8 pages, mais l'expéditeur peut envoyer des données de plus de 8 pages, ce qui provoque un **débordement de pages** via la fonction [null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76). Globalement, on utilise une technique de page-spray : d'abord, on utilise l'objet élastique `user_key_payload` pour divulguer `msg_msg->next`, puis on utilise `msg_msg` pour divulguer l'adresse noyau de `seq_operations->start`, et enfin on utilise `msg_msg` et la gestion des erreurs de pages FUSE pour construire une écriture arbitraire afin de modifier `modprobe_path` et élever les privilèges.

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

**Version de test** : Linux-5.17.12

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le module `nftables`, lorsque la fonctionnalité `NFT_MSG_NEWSET` du fichier `net/netfilter/nf_tables_api.c` est utilisée pour ajouter un `nft_set` et que les expressions `lookup` et `dynset` sont traitées, en raison d'un contrôle erroné de `NFT_EXPR_STATEFUL`, l'objet `nft_expr` libéré reste dans la liste chaînée `nft_set->binding` ; l'ajout d'un nouveau `nft_expr` provoque alors une **écriture UAF** (déclencher la vulnérabilité requiert la permission `CAP_NET_ADMIN`). L'écriture UAF écrit à l'offset 0x18 d'un bloc `kmalloc-64` la valeur d'adresse située à l'offset 0x18 d'un autre bloc `kmalloc-64`. Méthode d'exploitation : utiliser **`msg_msg` des mqueues pour divulguer l'adresse de base du noyau**, car `posix_msg_tree_node->msg_list` des mqueues se trouve à l'offset 0x18 (et réside dans `kmalloc-64`), ce qui correspond exactement à l'offset de l'écriture UAF ; en outre, **`posix_msg_tree_node->msg_list` peut également servir à construire une exploitation par Unlink** afin de modifier `modprobe_path`. Utiliser `user_key_payload` pour divulguer l'adresse du tas (afin de faciliter la construction de l'unlink) est un grand classique. À noter : il faut utiliser des versions de libmnl ou de libnftnl supérieures à celles d'Ubuntu 21.04.

#### 34. CVE-2022-34918

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

**Version de test** : Linux-5.17.15

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le module nftables, la fonction [nft_set_elem_init()](https://elixir.bootlin.com/linux/v5.18.10/source/net/netfilter/nf_tables_api.c#L5459) présente un **débordement de tas**, avec une longueur de débordement pouvant atteindre `64-16=48` octets. L'objet vulnérable peut se trouver dans `kmalloc-{64,96,128,192}` (cet article choisit l'objet vulnérable en kmalloc-64 pour l'exploitation). Exploitation — on construit d'abord le layout de tas `vul_obj -> user_key_payload -> percpu_ref_data` ; le débordement modifie `user_key_payload->datalen` à 0xffff afin de divulguer l'adresse de base du noyau via `percpu_ref_data->release` et l'adresse physmap via `percpu_ref_data->ref` ; ensuite, on construit le layout `vul_obj -> simple_xattr` ; le débordement modifie la liste chaînée `simple_xattr->list`, et cette écriture arbitraire limitée est utilisée pour modifier `modprobe_path` de `/sbin/modprobe` à `/tmp/xxxxprobe` afin d'élever les privilèges (cette écriture arbitraire est déclenchée lors du retrait du xattr de la liste chaînée). La condition préalable de cette écriture arbitraire est de divulguer l'adresse physmap ; `percpu_ref_data` / `shm_file_data` contiennent tous deux à la fois l'adresse de base du noyau et l'adresse physmap.

#### 35. CVE-2023-2598

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

**Version de test** : Linux-6.3.1

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : une vulnérabilité d'écriture OOB dans le module io_uring pouvant conduire à une **lecture/écriture hors limites de la mémoire physique**. La vulnérabilité se situe dans la fonction [io_sqe_buffer_register()](https://elixir.bootlin.com/linux/v6.3.1/source/io_uring/rsrc.c#L1230) du fichier `io_uring/rsrc.c`. Lors de la vérification que les pages soumises à l'enregistrement appartiennent au même folio (page composite), elle vérifie uniquement que la page de tête du folio est identique, sans vérifier que les pages soumises correspondent à la même page. Il est donc possible d'enregistrer la même page physique (en se faisant passer pour un folio composé de plusieurs pages physiques) et de construire une lecture/écriture hors limites de longueur arbitraire sur les pages physiques.   

En exploitant cette lecture/écriture hors limites de longueur arbitraire sur les pages physiques, on peut lire/écrire arbitrairement les objets sock situés juste après, divulguer l'adresse de base du noyau via `sock->sk_data_ready`, divulguer l'adresse tas de l'objet sock via `sock.sk_error_queue.next`, **détourner le flux de contrôle** en forgeant le pointeur de fonction `sock.__sk_common.skc_prot->ioctl` pour qu'il pointe vers la fonction [call_usermodehelper_exec()](https://elixir.bootlin.com/linux/v6.3.1/source/kernel/umh.c#L434) ; il faut également forger la structure `subprocess_info` pour mener à bien l'exploitation, et finalement **exécuter `/bin/sh -c /bin/sh &>/dev/ttyS0 </dev/ttyS0` pour élever les privilèges**.

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

**Version de test** : Linux-6.3.13

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : le composant nf_tables du sous-système netfilter présente une **vulnérabilité UAF**. Dans la fonction [nft_verdict_init()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/nf_tables_api.c#L10321), il est possible de définir une valeur de verdict très grande (valeur malveillante 0xffff0000). Dans la fonction [nf_hook_slow()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/core.c#L607), lors du traitement de `NF_DROP` (0), elle libère d'abord le paquet skb puis appelle [NF_DROP_GETERR()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L19) pour modifier la valeur de retour (définie sur `NF_ACCEPT` — la valeur positive 1 — selon la valeur du verdict). Une référence ultérieure au skb déclenche l'UAF et [NF_HOOK()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L407) libère à nouveau le skb. Méthode d'exploitation : **construire des pages PMD et PTE qui se chevauchent** ; `PMD[0]`/`PMD[1]` écrasent `PTE[0]`/`PTE[1]`. En écrivant dans l'adresse virtuelle utilisateur correspondant à la page PTE, on forge la page PTE correspondant à `PMD[0]` (dont les entrées correspondent à des adresses physiques), ce qui permet, en écrivant dans l'adresse virtuelle utilisateur correspondant au PMD, de **réaliser une écriture à une adresse physique arbitraire**.

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

**Version de test** : Linux-6.6.75

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : dans le module `net/sched`, lorsque la fonction `pfifo_tail_enqueue()` est appelée sur un qdisc (dont `sch->limit == 0`), la longueur de file qlen de ce qdisc est incorrectement incrémentée (bien que la file soit pleine, un nouveau paquet est ajouté directement sans d'abord en supprimer un), tandis que la qlen du qdisc parent (l'appelant) n'est pas incrémentée ; la qlen de la file parente n'est alors plus égale à la somme des qlen des files enfants, ce qui permet de construire un UAF. Divulgation de l'adresse de base du noyau — en se basant sur le principe d'insertion des nœuds de l'arbre rouge-noir pour modifier `user_key_payload->datalen` et construire une lecture hors limites, on divulgue le pointeur de fonction `xfrm_policy_timer` contenu dans l'objet `xfrm_policy` adjacent. Détournement du flux de contrôle — forger le pointeur de fonction `UAF_hfsc_class->dequeue` ; lors de la déqueue faisant suite à l'enqueue du paquet, déclencher `hfsc_dequeue()` -> `qdisc_dequeue_peeked()` -> `sch->dequeue()` pour détourner le flux de contrôle, le registre RDI étant contrôlable.

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

**Version de test** : Linux-6.12.24

**Protection** : KASLR/SMEP/SMAP activés.

**Vulnérabilité** : le répertoire `kernel/events/` (sous-système perf) présente une vulnérabilité UAF par condition de course. Il existe une condition de course entre `__perf_event_overflow()` et `perf_remove_from_context()`. Pour les événements perf pilotés par logiciel/tracepoint, le traitement de l'overflow ne fait que désactiver la préemption (sans désactiver les interruptions matérielles). Dans ce contexte, le chemin de nettoyage `perf_event_release_kernel()` → `perf_remove_from_context()` peut s'exécuter en concurrence sur un autre CPU, ce qui libère l'état de l'événement lié aux callbacks (par exemple `event->pending_task`) alors que le chemin d'overflow l'utilise encore, provoquant un UAF. Le correctif consiste à ajouter un mécanisme de synchronisation approprié dans `__perf_event_overflow()` afin de garantir que le chemin de libération ne puisse pas progresser en concurrence pendant que le chemin d'overflow accède aux champs liés aux callbacks.
- La course (un thread Worker déclenche le chemin d'overflow du tracepoint, un thread Closer appelle en concurrence `close()` sur le fd perf_event) déclenche `WARN_ON_ONCE` ; après que le refcount atteint zéro, `task_work_add` ajoute tout de même le `pending_task` de l'événement libéré à la liste task_work.
- La réussite de la course est détectée en interrogeant le bit TAINT_WARN (512) via `/proc/sys/kernel/tainted` ; 1024 threads de spray libèrent en synchronisation, l'événement B occupant le slot slab libéré par l'événement A.
- Lorsque futex_wait retourne en espace utilisateur, `perf_pending_task` exécute `put_event(événement B)`, ce qui décrémente par erreur le refcount de l'événement B jusqu'à zéro, formant un **FD pendant (dangling FD) stable**.
- L'Oracle à ID alloue itérativement l'événement C pour sonder les changements d'ID et localiser précisément la victime ; une attaque cross-cache rend la page slab de `perf_event_cache` au buddy, puis la récupère avec `msg_msgseg`.