---

## Catálogo

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

---

## Detalle

#### 1.CVE-2015-8550

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

**Versión de prueba**: Linux-4.19.65

**Protección**: KASLR/SMEP activados, SMAP no activado.

**Vulnerabilidad**: vulnerabilidad **Double-Fetch** causada por la optimización de compilación de gcc, que permite secuestrar directamente el flujo de control.

#### 2. CVE-2016-9793

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

**Versión de prueba**: Linux-4.8.13

**Protección**: KASLR/SMAP/SMEP no activados. La estructura [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) falsificada se encuentra en el espacio de usuario, por lo que obviamente no puede omitir SMAP.

**Vulnerabilidad**: la función [sock_setsockopt()](https://elixir.bootlin.com/linux/v4.8.13/source/net/core/sock.c#L658) en `net/core/sock.c` **maneja incorrectamente los valores negativos**, lo que hace que `sk_sndbuf` y `sk_rcvbuf` tomen valores negativos. Al llamar a `write`, `skb->head` y `skb->end` se establecen incorrectamente; finalmente, al llamar a `close` para liberar, se accede al espacio de usuario y se produce un error. Se falsifica una estructura [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) en la dirección de espacio de usuario `0xfffffed0`, y se secuestra el flujo de control mediante `skb_shared_info->destructor_arg->callback`.

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

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

**Versión de prueba**: Linux-4.20.0-rc3

**Protección**: SMEP activado, KASLR/SMAP no activados.

**Vulnerabilidad**: vulnerabilidad de **desbordamiento de entero** en `queue_stack_map_alloc()` del módulo eBPF de Linux, que provoca un desbordamiento de montón. Se modifica el puntero de la tabla virtual para secuestrar el flujo de control hacia `xchg eax, esp`.

#### 4.CVE-2017-5123

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

**Versión de prueba**: Linux 4.14-rc4

**Protección**: SMEP/SMAP activados, KASLR desactivado.

**Vulnerabilidad**: la implementación de `waitid` en `/kernel/exit.c`, al llamar a `unsafe_put_user()` para copiar datos del kernel a direcciones de espacio de usuario, no llama a `access_ok()` para verificar la legitimidad de la dirección de espacio de usuario, por lo que en realidad se pueden copiar datos a direcciones de espacio del kernel. **waitid no verifica la legitimidad de la dirección de usuario, lo que permite una escritura null en dirección arbitraria**. Se puede ejecutar shellcode en la dirección 0 o sobrescribir cred en un rango adivinado para escalar privilegios.

#### 5.CVE-2017-6074

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

**Versión de prueba**: Linux-4.9.12

**Protección**: SMEP/SMAP activados, kASLR desactivado.

**Vulnerabilidad**: la función [dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) en `net/dccp/input.c` del protocolo DCCP (Protocolo de Control de Congestión de Datagramas) de la familia de protocolos IP V6 del kernel de Linux maneja incorrectamente la estructura de datos del paquete `DCCP_PKT_REQUEST` en estado `LISTEN`; cuando el usuario llama a `setsockopt()` con la opción `IPV6_RECVPKTINFO`, se dispara un **Double-Free de la estructura `sk_buff`**. La técnica de explotación es similar a CVE-2016-8655. La primera vez que se dispara la vulnerabilidad, se rocía el heap falsificando la estructura `po->rx_ring->prb_bdqc->retire_blk_timer` y se ejecuta `native_write_cr4(0x406e0)` para desactivar SMEP/SMAP; la segunda vez, se rocía el heap falsificando la estructura `skb-> ... ->destructor_arg` y se ejecuta `commit_creds(prepare_kernel_cred(0))` para escalar privilegios.

#### 6.CVE-2017-7308

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

**Versión de prueba**: Linux-4.10.6

**Protección**: SMEP/SMAP activados, KASLR desactivado.

**Vulnerabilidad**: la función [`packet_set_ring()`](https://elixir.bootlin.com/linux/v4.10.6/source/net/packet/af_packet.c#L4181) en `net/packet/af_packet.c` no verifica correctamente el tamaño del bloque; la condición de comprobación de longitud es incorrecta, lo que provoca un **desbordamiento de montón**. Requiere privilegios `CAP_NET_RAW`. Se secuestran punteros de función dos veces: primero se desactiva la protección SMEP/SMAP y luego se escalan privilegios.

#### 7.CVE-2017-8890

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

**Versión de prueba**: Linux-4.10.15

**Protección**: SMEP activado, kASLR y SMAP desactivados.

**Vulnerabilidad**: la función [`inet_csk_clone_lock()`](https://elixir.bootlin.com/linux/v4.10.15/source/net/ipv4/inet_connection_sock.c#L652) en el archivo `net/ipv4/inet_connection_sock.c` contiene una vulnerabilidad de **Double-Free**. Se utiliza el Double-Free para alterar el puntero de la función de callback de RCU, desactivar SMEP y saltar al shellcode para modificar cred.

#### 8.CVE-2017-11176

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

**Versión de prueba**: Linux-4.11.9

**Protección**: SMEP activado, kASLR y SMAP desactivados.

**Vulnerabilidad**: en la implementación de las colas de mensajes POSIX del kernel de Linux, la función `mq_notify()` no pone a null el puntero sock, lo que causa un UAF. En realidad se trata de una vulnerabilidad de **Double-Free debida a una condición de carrera**, pero la ventana de la carrera se puede extender indefinidamente.

#### 9.CVE-2017-16995

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

**Versión de prueba**: Linux-4.4.110

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: problema de **extensión de enteros** en el módulo eBPF de Linux; el problema principal es que los tipos de valores de los dos registros son diferentes, lo que hace que la función de verificación y la función real se ejecuten de manera inconsistente. Esta vulnerabilidad no incluye ataques de pila ni secuestro del flujo de control; solo usa datos de llamadas al sistema para escalar privilegios. Es una aplicación típica de los ataques orientados a datos (Data-Oriented Attacks) en el kernel de Linux.

#### 10. CVE-2017-1000112

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

**Versión de prueba**: Linux-4.12.6

**Protección**: SMEP activado, SMAP/kASLR desactivados.

**Vulnerabilidad**: [__ip_append_data()](https://elixir.bootlin.com/linux/v4.12.6/source/net/ipv4/ip_output.c#L910) en `net/ipv4/ip_output.c` no garantiza la coherencia en el procesamiento de los datagramas UDP, de modo que al enviar paquetes dos veces se puede cambiar de la ruta UFO a la ruta non-UFO, provocando un **desbordamiento de montón**. En la explotación, se puede secuestrar el flujo de control sobrescribiendo `skb_shared_info->destructor_arg->callback`.

#### 11. CVE-2018-5333

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

**Versión de prueba**: Linux-4.14.13

**Protección**: SMEP activado, SMAP/kASLR desactivados.

**Vulnerabilidad**: en la función [`rds_cmsg_atomic()`](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L788) en `net/rds/rdma.c` se olvida poner `rm->atomic.op_active` a 0, lo que provoca una vulnerabilidad de **`null-dereference`** cuando [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) referencia `page->page_link`. Se falsifican la estructura y los punteros de función en la dirección 0 para secuestrar el flujo de control.

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

**Versión de prueba**: Linux-4.20.0 32 bits

**Protección**: SMEP activado, SMAP/kASLR desactivados.

**Vulnerabilidad**: 

- CVE-2019-9213: la función [`expand_downwards()`](https://elixir.bootlin.com/linux/v4.20.7/source/mm/mmap.c#L2413) en `mm/mmap.c` falla al comprobar la dirección mínima de mmap, realizando la comprobación de capacidades sobre una tarea incorrecta, lo que permite eludir la restricción de `mmap_min_addr`; se trata de una **vulnerabilidad lógica**. Utilizando el comando `LD_DEBUG=help /bin/su 1>&%d` para ejecutar una operación de escritura, se debería comprobar el cred del exploit, pero se comprueba erróneamente el cred del proceso de escritura, marcando así las direcciones bajas como accesibles para procesos privilegiados. Solo los sistemas de 32 bits pueden explotar con éxito esta vulnerabilidad; se desconoce la razón.
- CVE-2019-8956: la función [`sctp_sendmsg()`](https://elixir.bootlin.com/linux/v4.20.7/source/net/sctp/socket.c#L2025) en `net/sctp/socket.c` presenta una vulnerabilidad de **referencia a puntero nulo** al procesar el flag `SCTP_SENDALL`. Combinada con CVE-2019-9213, permite eludir la restricción de `mmap_min_addr`, hacer mmap a la dirección baja 0xd4, falsificar estructuras y secuestrar el flujo de control.

#### 13. CVE-2019-15666

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

**Versión de prueba**: Ubuntu 18.04 (4.15.0-20-generic #21)

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: [verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379) en `net/xfrm/xfrm_user.c` maneja incorrectamente la verificación de `dir`, lo que provoca un **acceso fuera de límites** en [__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202). La vulnerabilidad originalmente es una resta de 1 fuera de límites; se puede usar otra ruta para construir un UAF, escribiendo **null de 8 bytes en un bloque libre**. El objeto vulnerable `xfrm_policy` está en `kmalloc-1024`, y la estructura cred está en `kmalloc-192`. Primero se usa `setxattr+userfaultfd` para rociar bloques de `kmalloc-1024` alrededor de `policy0`; después de liberar `policy0`, también se liberan los bloques rociados, lo que hace que, tras la liberación de esa slab, sea reutilizada por el cred del proceso hijo c. Luego se dispara la escritura de null de 8 bytes en el bloque libre UAF para modificar `gid/suid` en cred, y finalmente se añade al usuario actual a sudoers para escalar privilegios.

#### 14. CVE-2020-8835

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

**Versión de prueba**: Linux-5.5.0

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: en `kernel/bpf/verifier.c` no se convierte correctamente el valor de 64 bits a 32 bits (se toman directamente los 32 bits bajos), lo que produce un **truncamiento de enteros**. Esto hace que la fase de verificación del código BPF y la fase de ejecución real sean inconsistentes, provocando lecturas/escrituras fuera de límites.

#### 15. CVE-2020-27194

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

**Versión de prueba**: Linux-5.8.14

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: al realizar una operación OR en el verificador de eBPF, la función `scalar32_min_max_or()` asigna un valor de 64 bits a una variable de 32 bits, lo que provoca un **truncamiento de enteros**. Esto hace que se calculen incorrectamente los rangos de los registros, permitiendo eludir la verificación de BPF y provocando lecturas/escrituras fuera de límites.

#### 16. CVE-2021-3156

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

**Versión de prueba**: Ubuntu 19.04, Sudo 1.8.27

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: al procesar los argumentos de la línea de comandos, sudo comete un error lógico al manejar un comando que termina con una barra invertida simple, lo que provoca un **desbordamiento de montón**.

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

**Versión de prueba**: Linux-5.11

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: en el módulo eBPF, la función [`__reg_combine_64_into_32()`](https://elixir.bootlin.com/linux/v5.11.20/source/kernel/bpf/verifier.c#L1312) de `kernel/bpf/verifier.c` calcula incorrectamente los registros. Se aprovecha la inconsistencia entre la fase del verificador y la fase de ejecución real para realizar lecturas/escrituras fuera de límites. Tras filtrar la dirección base del kernel, falsificar la tabla de funciones y lograr lectura/escritura arbitraria, se modifica el cred del hilo actual.

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

**Versión de prueba**: Linux-5.11  Linux-5.11.16

**Protección**: SMEP/SMAP/kASLR activados.

**Vulnerabilidad**: en el módulo eBPF, el seguimiento de límites ALU32 de eBPF para operaciones bit a bit (AND, OR y XOR) en `kernel/bpf/verifier.c` no actualiza correctamente los límites de 32 bits, lo que provoca lecturas y escrituras fuera de límites en el kernel de Linux y, por tanto, la ejecución arbitraria de código. Las tres funciones vulnerables son [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) y [scalar32_min_max_xor()](https://elixir.bootlin.com/linux/v5.13-rc3/source/kernel/bpf/verifier.c#L7219). Se aprovecha la inconsistencia entre la fase del verificador y la fase de ejecución real para realizar lecturas/escrituras fuera de límites. Tras filtrar la dirección base del kernel, falsificar la tabla de funciones y lograr lectura/escritura arbitraria, se modifica el cred del hilo actual.

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

**Versión de prueba**: Linux-5.11.14

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: en el submódulo `ip_tables` del módulo `Netfilter` en `net/netfilter/x_tables.c`, cuando se llama a `setsockopt()` con la opción `IPT_SO_SET_REPLACE` (o `IP6T_SO_SET_REPLACE`), las estructuras del kernel deben convertirse de 32 bits a 64 bits. Debido al cálculo incorrecto del tamaño de la conversión, al llamar a la función [xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731) se produce un **desbordamiento de montón que escribe 0, que puede convertirse en un UAF**. Un atacante puede utilizarlo para escalar privilegios o para escapar de contenedores docker o k8s ([kubernetes](https://zhuanlan.zhihu.com/p/29232090)). Se requiere el privilegio `CAP_NET_ADMIN`, o bien soporte de namespaces `user+network`.

#### 20. CVE-2021-41073

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

**Versión de prueba**: Linux-5.14.6

**Protección**: KASLR/SMEP/SMAP activados. No activados: `CONFIG_SLAB_FREELIST_RANDOM` / `CONFIG_SLAB_FREELIST_HARDENED` / `CONFIG_BPF_JIT_ALWAYS_ON` / `CONFIG_MEMCG ` (por defecto está activado).

**Vulnerabilidad**: la función `loop_rw_iter()` en `fs/io_uring.c` contiene una vulnerabilidad de **`type confusion`**. `io_kiocb->rw.addr` actúa tanto como dirección de kernel como dirección de usuario, pero al incrementarse en la función `loop_rw_iter()` no se hace distinción, lo que provoca que al leer un archivo se incremente erróneamente la dirección de kernel y, finalmente, se libere de forma incorrecta **un buffer adyacente en un desplazamiento controlable** (kmalloc-32). Las condiciones de explotación son muy estrictas: como el objeto vulnerable está en kmalloc-32, se desactiva el mecanismo de protección de freelist; como el objeto `seq_operations` se asigna con el flag `GFP_KERNEL_ACCOUNT`, también se desactiva el mecanismo `CONFIG_MEMCG*`; esta vulnerabilidad escala privilegios alterando el puntero `sk_filter->prog` en eBPF y falsificando un programa BPF, por lo que también se desactiva la configuración `CONFIG_BPF_JIT_ALWAYS_ON`.

#### 21. CVE-2021-4154

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

**Versión de prueba**: Linux-5.13.3

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: la función [cgroup1_parse_param()](https://elixir.bootlin.com/linux/v5.13.3/source/kernel/cgroup/cgroup-v1.c#L905) en `kernel/cgroup/cgroup-v1.c` (disparada a través de la llamada al sistema `fsconfig`) presenta una confusión de tipos que provoca una **vulnerabilidad UAF**. Se puede llamar a la syscall `fsconfig` para configurar un fd arbitrario; finalmente, al cerrar ese archivo, el objeto `file` correspondiente al fd será liberado. Así podemos **liberar la estructura `file` correspondiente a cualquier descriptor de archivo**. Este artículo utiliza dos métodos de explotación: uno es DirtyCred y el otro es construir un ROP. Comparando ambos métodos, la ventaja de DirtyCred es que es genérico entre versiones del kernel y no requiere adaptación; su desventaja es que necesita sobrescribir un archivo privilegiado para escalar privilegios, por lo que no se puede escalar en contenedores como docker. La ventaja del ROP es que permite leer/escribir arbitrariamente la memoria del kernel y ejecutar código arbitrario; su desventaja es que adaptarlo a diferentes versiones del kernel es muy tedioso.

#### 22. CVE-2021-42008

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

**Versión de prueba**: Linux-5.13.12

**Protección**: KASLR / SMEP / SMAP / PTI activados.

**Vulnerabilidad**: la función [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) en `drivers/net/hamradio/6pack.c` presenta un **desbordamiento de montón**; el usuario necesita el privilegio `CAP_NET_ADMIN`. [sixpack_decode()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L962) puede llamar a [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) varias veces, decodificando la entrada y guardándola en [sixpack->cooked_buf](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L98). El miembro `sixpack->rx_count_cooked` actúa como índice de acceso a `sixpack->cooked_buf`, determinando el desplazamiento de destino para escribir los bytes decodificados. El problema es que si se llama a `decode_data()` varias veces, `rx_count_cooked` se incrementa continuamente hasta superar la longitud de `cooked_buf` (400 bytes), provocando una escritura fuera de límites. Se consulta [Uso de la estructura msg_msg en el kernel de Linux para lograr lectura/escritura de direcciones arbitrarias](https://www.anquanke.com/post/id/252558) para construir lectura fuera de límites y escritura de direcciones arbitrarias, modificando `modprobe_path` para escalar privilegios. La desventaja es que hay que usar `userfaultfd` y no se puede sortear la barrera de `CAP_NET_ADMIN`.

#### 23. CVE-2021-43267

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

**Versión de prueba**: Linux-5.14.15

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: la vulnerabilidad se encuentra en el archivo `net/tipc/crypto.c`. En el protocolo de comunicación dentro del clúster TIPC (Transparent Inter-Process Communication), la validación de la longitud de los mensajes de tipo `MSG_CRYPTO` es incorrecta, lo que provoca un **desbordamiento de montón**. En la función [tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281), la parte de datos del mensaje TIPC (estructura [tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)) apunta al mensaje `MSG_CRYPTO` (estructura [tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)). Al asignar espacio para `tipc_aead_key` y copiar `tipc_aead_key->key`, no se valida la validez de `tipc_aead_key->keylen`, lo que provoca una copia fuera de límites. Solo se comprueban el `header size` y el `msg size` del mensaje TIPC, pero no se comprueba `tipc_aead_key->keylen` del mensaje `MSG_CRYPTO`. Se utiliza un `elastic object` para filtrar la dirección base del kernel, se modifica `tty_struct->tty_operations.ioctl` para que apunte a un gadget de escritura arbitraria (`mov   QWORD PTR [rdx],rsi`), y se modifica `modprobe_path` para escalar privilegios.

#### 24. CVE-2022-0185

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

**Versión de prueba**: Linux-5.11.22

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: se completó el escalado de privilegios en google kctf, ganando 30 000 dólares. En el módulo `File System Context` del kernel (entorno del sistema de archivos), en el archivo `fs/fs_context.c`, existe un **desbordamiento de enteros** que provoca un desbordamiento de montón. El atacante debe tener el privilegio `CAP_SYS_ADMIN`, o bien usar namespaces o `unshare(CLONE_NEWNS|CLONE_NEWUSER)` (equivalente al comando `$ unshare -Urm`) para entrar en un namespace con privilegio `CAP_SYS_ADMIN`. Hay dos métodos de explotación: uno es usar **FUSE** (equivalente a userfault) para construir una escritura de dirección arbitraria y modificar `modprobe_path`; el otro es usar `msg_msg` para construir una liberación arbitraria y luego construir un ROP para escalar privilegios.

#### 25. CVE-2022-0847

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

**Versión de prueba**: Linux-5.16.10

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: vulnerabilidad **DirtyPipe**. Cuando la llamada `splice` enlaza la caché de páginas (page cache) del archivo al buffer circular de la pipe [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26), las funciones [copy_page_to_iter_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L384) y [push_pipe()](https://elixir.bootlin.com/linux/v5.16.10/source/lib/iov_iter.c#L547) no inicializan el miembro `flag` de [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) (vulnerabilidad de variable no inicializada). Al no limpiarse el atributo `PIPE_BUF_FLAG_CAN_MERGE`, en una posterior llamada a `pipe_write()` se cree erróneamente que la operación de escritura puede fusionarse, escribiendo así datos ilegítimos en la caché de páginas del archivo (se restaura al reiniciar). Esto provoca una vulnerabilidad de sobrescritura de archivos arbitrarios. La vulnerabilidad permite escribir en la page cache de cualquier archivo; el método de escalado de privilegios consiste en modificar la page cache de `/etc/passwd`, de modo que durante un breve periodo todos los procesos que accedan a ese archivo verán la página de caché manipulada.

#### 26. CVE-2022-0995

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

**Versión de prueba**: Linux-5.11.22

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: el subsistema de notificación de eventos `watch_queue ` contiene un **desbordamiento de montón**; la función vulnerable es [watch_queue_set_filter()](https://elixir.bootlin.com/linux/v5.16.14/source/kernel/watch_queue.c#L286). El kernel realiza dos comprobaciones de validez sobre el filter de tipo [watch_notification_type_filter](https://elixir.bootlin.com/linux/v5.16.14/source/include/uapi/linux/watch_queue.h#L52) proporcionado por el usuario: la primera comprobación se usa para determinar el tamaño de memoria a asignar, y la segunda para almacenar el filter del usuario en esa memoria. Sin embargo, las dos comprobaciones son inconsistentes, de modo que el espacio asignado es demasiado pequeño y se pueden almacenar más filters de los debidos mediante desbordamiento. Se puede aprovechar el segundo desbordamiento para poner a 1 bits específicos de bloques de heap adyacentes; el método de explotación posterior es el mismo que el 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/)      [referencia](https://blog.dbouman.nl/2022/04/02/How-The-Tables-Have-Turned-CVE-2022-1015-1016/)

**Versión de prueba**: Linux-5.17

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: en el módulo nftables, las funciones [nft_parse_register_load()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9325) y [nft_parse_register_store()](https://elixir.bootlin.com/linux/v5.17/source/net/netfilter/nf_tables_api.c#L9377) no limitan el rango del índice de registro pasado, lo que provoca un desbordamiento de enteros (que puede pasar la comprobación de rango) y desencadena una **lectura/escritura fuera de límites por desbordamiento de pila**. Durante la explotación, es necesario volver del contexto de interrupción al espacio de usuario; se aprovecha el final de la función `__do_softirq()` para regresar perfectamente al contexto de la syscall, y luego se llama a `switch_task_namespaces(current, &init_nsproxy)` y `commit_cred(&init_cred)` para escalar privilegios.

#### 28. CVE-2022-2588

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

**Versión de prueba**: Linux-5.19.1

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: similar a [CVE-2021-3715](https://access.redhat.com/security/cve/cve-2021-3715) (véase [BlackHat 2021-Europe-Your Trash Kernel Bug, My Precious 0-day](https://zplin.me/talks/BHEU21_trash_kernel_bug.pdf), página 16). Debido a que las condiciones de comprobación al eliminar y liberar el objeto `route4_filter` de la lista enlazada son inconsistentes, el objeto permanece en la lista después de ser liberado, lo que permite desencadenar un **Double-Free** posteriormente. Se necesitan `User Namespaces` para desencadenarlo. Se utiliza el método **DirtCred** para escalar privilegios.

#### 29. CVE-2022-2602

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

**Versión de prueba**: Linux-5.18.19

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: el componente io_uring tiene una funcionalidad, `IORING_REGISTER_FILES`, que permite colocar archivos en la cola `sock->receive_queue` de io_uring. El mecanismo de recolección de basura (GC) de Linux (que solo gestiona el contador de referencias en vuelo de los archivos io_uring y sock) puede liberar como basura los archivos registrados en io_uring; la próxima vez que io_uring use ese archivo (para escribir un archivo con writev, correspondiente a la funcionalidad `IORING_OP_WRITEV`) se desencadena una **vulnerabilidad UAF**. En cuanto al método de explotación, dado que el mecanismo de recolección de basura UNIX_GC libera erróneamente la estructura de archivo aún en uso en `io_uring` (que está escribiendo datos maliciosos en el archivo normal `"/tmp/rwA"`), se puede **adoptar el método DirtyCred**: abrir una gran cantidad de archivos `"/etc/passwd"` para sobrescribir la estructura `file` recién liberada, de modo que finalmente se escriban datos maliciosos en el archivo `"/etc/passwd"`.

#### 30. CVE-2022-2639

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

**Versión de prueba**: Linux-5.17.4

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: en el módulo del kernel `openvswitch`, [reserve_sfa_size()](https://elixir.bootlin.com/linux/v5.17.4/source/net/openvswitch/flow_netlink.c#L2439) tiene un desbordamiento de enteros que provoca un **desbordamiento de escritura en heap `kmalloc-0x10000`**, y se necesita usar page spray para construir un desbordamiento cross-cache. Este artículo se basa en `pipe-primitive` para modificar archivos arbitrarios, por lo que no es necesario eludir los mecanismos de protección KASLR/SMEP/SMAP/KPTI; la explotación no requiere adaptación entre versiones. **Primero se crea una pipe y se hace splice al archivo de solo lectura `/usr/bin/mount`; mediante heap spray se falsifica `pipe_buffer->flags = PIPE_BUF_FLAG_CAN_MERGE`, de modo que se puede escribir una suid-shell en el archivo `/usr/bin/mount` y luego ejecutarla para escalar privilegios**.        Se dispara OOB dos veces: la primera vez, mediante el desbordamiento se modifica `msg_msg->m_ts` para leer fuera de límites el `msg_msg->m_list.next` adyacente y **filtrar la dirección de heap de kmalloc-1024**; la segunda vez, mediante el desbordamiento se modifica `msg_msg->m_list.next` para que apunte a la dirección de heap de kmalloc-1024 filtrada, **construyendo una liberación arbitraria**.

#### 31. CVE-2022-25636

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

**Versión de prueba**: Linux-5.13.19

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: en la función [nft_fwd_dup_netdev_offload()](https://elixir.bootlin.com/linux/v5.16.11/source/net/netfilter/nf_dup_netdev.c#L67) del módulo `nf_table` en `net/netfilter/nf_dup_netdev.c`, dado que la condición al calcular el espacio de asignación y al inicializar realmente es inconsistente, existe una **escritura OOB** (el sistema debe soportar la descarga de procesamiento de paquetes - Network Interface Cards (NICs), aunque es raro en la práctica). Se **escribe por desbordamiento la dirección de un objeto `net_device` (que está en kmalloc-4k)**, y el tamaño del objeto vulnerable puede variar (determinado por el número de rules con el flag `NFT_OFFLOAD_F_ACTION` pasadas, pudiendo estar en `kmalloc-128`, `kmalloc-192`, etc.). Se requiere el privilegio `SYS_ADMIN`. En la explotación, **se filtra el puntero de heap de `net_device` (kmalloc-4k) mediante `msg_msgseg`; se construye una liberación arbitraria sobrescribiendo el puntero `msg_msg->security`; se filtra la dirección base del kernel leyendo `net_device->dev_addr` con la funcionalidad incorporada `ioctl(fd, SIOCGIFHWADDR, leak)`; y se secuestra el flujo de control falsificando el puntero de función `net_device->ethtool_ops->begin` para escalar privilegios**.

#### 32. CVE-2022-27666

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

**Versión de prueba**: Linux-5.16.14

**Protección**: KASLR/SMEP/SMAP activados.

**Vulnerabilidad**: en la competición PWN2OWN se completó el escalado de privilegios en Ubuntu 21.10. En el módulo crypto esp6 del kernel, el búfer receptor es de 8 páginas, pero el remitente puede enviar datos de más de 8 páginas; la función [null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76) provoca un **desbordamiento de páginas**. En general se emplea la técnica de page spray: primero se utiliza el objeto elástico `user_key_payload` para filtrar `msg_msg->next`; luego se usa `msg_msg` para filtrar la dirección del kernel de `seq_operations->start`; por último, se usan `msg_msg` y el manejo de fallos de página de FUSE para construir una escritura arbitraria, modificando `modprobe_path` para escalar privilegios.

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

**Versión de prueba**: Linux-5.17.12

**Protección**: KASLR/SMEP/SMAP habilitados.

**Vulnerabilidad**: En el módulo `nftables`, cuando `net/netfilter/nf_tables_api.c` usa `NFT_MSG_NEWSET` para añadir un `nft_set`, al procesar las expresiones `lookup` y `dynset`, debido a una comprobación incorrecta de `NFT_EXPR_STATEFUL`, el objeto `nft_expr` liberado permanece en la lista enlazada `nft_set->binding`; al añadir un nuevo `nft_expr` se produce una **escritura UAF** (se necesita el privilegio `CAP_NET_ADMIN` para desencadenar la vulnerabilidad). La escritura UAF escribe en el offset 0x18 de un `kmalloc-64` el valor de la dirección del offset 0x18 de otro bloque `kmalloc-64`. Método de explotación: se emplea **`msg_msg` de mqueue para filtrar la base del kernel**, porque `posix_msg_tree_node->msg_list` en mqueue tiene un offset de 0x18 (y está en `kmalloc-64`), exactamente el offset de la escritura UAF; además, **`posix_msg_tree_node->msg_list` también puede usarse para construir una explotación Unlink** y modificar `modprobe_path`. Se usa `user_key_payload` para filtrar la dirección del heap (para facilitar la construcción del unlink); es un método de sobra conocido. Nota: se necesitan versiones de libmnl o libnftnl posteriores a Ubuntu 21.04.

#### 34. CVE-2022-34918

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

**Versión de prueba**: Linux-5.17.15

**Protección**: KASLR/SMEP/SMAP habilitados.

**Vulnerabilidad**: En el módulo nftables, la función [nft_set_elem_init()](https://elixir.bootlin.com/linux/v5.18.10/source/net/netfilter/nf_tables_api.c#L5459) tiene un **desbordamiento de heap**, cuya longitud puede alcanzar los `64-16=48` bytes; el objeto vulnerable puede estar en `kmalloc-{64,96,128,192}` (en este artículo se elige el objeto vulnerable kmalloc-64). Explotación: primero se construye el layout de heap `vul_obj -> user_key_payload -> percpu_ref_data`, se desborda para modificar `user_key_payload->datalen` a 0xffff, filtrando así la base del kernel mediante `percpu_ref_data->release` y la base physmap mediante `percpu_ref_data->ref`; después se construye el layout de heap `vul_obj -> simple_xattr`, se desborda para modificar la lista enlazada `simple_xattr->list`, y se aprovecha esta escritura arbitraria restringida para cambiar `modprobe_path` de `/sbin/modprobe` a `/tmp/xxxxprobe` y escalar privilegios (la escritura arbitraria se desencadena al retirar el xattr de la lista). La condición previa de esta escritura arbitraria es disponer de la dirección physmap; tanto `percpu_ref_data` como `shm_file_data` contienen tanto la base del kernel como la dirección physmap.

#### 35. CVE-2023-2598

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

**Versión de prueba**: Linux-6.3.1

**Protección**: KASLR/SMEP/SMAP habilitados.

**Vulnerabilidad**: Escritura OOB en el módulo io_uring que puede provocar **lectura/escritura fuera de límites de la memoria física**. El fallo está en la función [io_sqe_buffer_register()](https://elixir.bootlin.com/linux/v6.3.1/source/io_uring/rsrc.c#L1230), en el directorio `io_uring/rsrc.c`: al comprobar si las páginas presentadas para registro pertenecen a la misma página compuesta, solo verifica que la primera página de la página compuesta coincida, pero no comprueba si las páginas presentadas son la misma página. Se puede registrar la misma página física (haciéndola pasar por una página compuesta de varias páginas físicas) y construir así una lectura/escritura fuera de límites de longitud arbitraria sobre la página física.   

Con esta lectura/escritura fuera de límites de longitud arbitraria sobre la página física, se puede leer y escribir arbitrariamente el objeto sock contiguo posterior; mediante `sock->sk_data_ready` se filtra la base del kernel, y mediante `sock.sk_error_queue.next` se filtra la dirección de heap del objeto sock. Falsificando el puntero de función `sock.__sk_common.skc_prot->ioctl` para que apunte a [call_usermodehelper_exec()](https://elixir.bootlin.com/linux/v6.3.1/source/kernel/umh.c#L434) se **secuestra el flujo de control**; además hay que falsificar la estructura `subprocess_info` para completar la explotación y, finalmente, ejecutar `/bin/sh -c /bin/sh &>/dev/ttyS0 </dev/ttyS0` para **escalar privilegios**.

#### 36. CVE-2024-1086

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

**Versión de prueba**: Linux-6.3.13

**Protección**: KASLR/SMEP/SMAP habilitados.

**Vulnerabilidad**: Existe una **vulnerabilidad UAF** en el componente nf_tables del subsistema netfilter. En la función [nft_verdict_init()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/nf_tables_api.c#L10321) se permite establecer un valor de verdict muy grande (valor malicioso 0xffff0000); en [nf_hook_slow()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/core.c#L607), al manejar `NF_DROP` (0), primero libera el paquete skb y llama a [NF_DROP_GETERR()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L19) para modificar el valor de retorno (se establece a `NF_ACCEPT` - valor positivo 1 según el valor de verdict). Al referenciar después el skb se desencadena el UAF, y [NF_HOOK()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L407) libera el skb de nuevo. Método de explotación: **construir páginas PMD y PTE solapadas**; `PMD[0]`/`PMD[1]` sobrescriben `PTE[0]`/`PTE[1]`. Escribiendo en la dirección virtual de usuario correspondiente a la página PTE se falsifica la página PTE correspondiente a `PMD[0]` (cuyas entradas corresponden a direcciones físicas), de modo que, escribiendo en la dirección virtual de usuario correspondiente a PMD, se consigue **escritura en cualquier dirección física**.

#### 37. CVE-2025-21702

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

**Versión de prueba**: Linux-6.6.75

**Protección**: KASLR/SMEP/SMAP habilitados.

**Vulnerabilidad**: En el módulo `net/sched`, cuando se llama a `pfifo_tail_enqueue()` sobre un planificador qdisc (con `sch->limit == 0`), la longitud de cola qlen de ese qdisc se incrementa erróneamente (aunque la cola esté llena, se añade un nuevo paquete sin descartar primero uno), mientras que la qlen del qdisc padre (el llamador) no se incrementa. Esto hace que la qlen de la cola padre no sea igual a la suma de las qlen de las colas hijas, lo que permite construir un UAF. Filtración de la base del kernel: mediante el principio de inserción de nodos del árbol rojo-negro se modifica `user_key_payload->datalen` para construir una lectura fuera de límites y filtrar el puntero de función `xfrm_policy_timer` de un objeto `xfrm_policy` adyacente. Secuestro del flujo de control: se falsifica el puntero de función `UAF_hfsc_class->dequeue`; durante la dequeue posterior a la enqueue del paquete se desencadena `hfsc_dequeue()` -> `qdisc_dequeue_peeked()` -> `sch->dequeue()` y se secuestra el flujo de control; el registro RDI es controlable.

#### 38. CVE-2026-23271

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

**Versión de prueba**: Linux-6.12.24

**Protección**: KASLR/SMEP/SMAP habilitados.

**Vulnerabilidad**: Existe una vulnerabilidad UAF por condición de carrera en `kernel/events/` (subsistema perf). Hay una condición de carrera entre `__perf_event_overflow()` y `perf_remove_from_context()`. Para los eventos perf impulsados por software/tracepoint, el manejo de overflow solo deshabilita la preemption (no desactiva las interrupciones de hardware). En este contexto, la ruta de limpieza `perf_event_release_kernel()` → `perf_remove_from_context()` puede ejecutarse de forma concurrente en otra CPU, lo que libera el estado del evento relacionado con los callbacks (por ejemplo, `event->pending_task`) mientras la ruta de overflow todavía lo está usando, provocando un UAF. La solución es añadir un mecanismo de sincronización adecuado en `__perf_event_overflow()` para garantizar que la ruta de liberación no pueda avanzar de forma concurrente mientras la ruta de overflow accede a los campos relacionados con los callbacks.
- La condición de carrera (el hilo Worker dispara la ruta de overflow de tracepoint, mientras el hilo Closer ejecuta de forma concurrente `close()` sobre el fd de perf_event) dispara `WARN_ON_ONCE`; después de que el refcount llegue a cero, `task_work_add` sigue añadiendo el `pending_task` del evento ya liberado a la lista task_work.
- Se detecta el éxito de la condición de carrera sondeando el bit TAINT_WARN (512) en `/proc/sys/kernel/tainted`; 1024 hilos de spray liberan de forma sincronizada, usando el evento B para ocupar el slot de slab que liberó el evento A.
- Cuando futex_wait vuelve al modo usuario, `perf_pending_task` ejecuta `put_event(事件B)`, reduciendo erróneamente el refcount del evento B a 0 y formando un **FD colgante estable**.
- El oráculo de ID asigna de forma iterativa el evento C para sondear los cambios de ID y localizar con precisión a la víctima; en el ataque cross-cache, las páginas de slab de `perf_event_cache` se devuelven al buddy y luego se reclaman con `msg_msgseg`.