---

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

---

## Detail

#### 1. CVE-2015-8550

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

**Versão de teste**: Linux-4.19.65

**Proteção**: KASLR/SMEP ativados, SMAP desativado.

**Vulnerabilidade**: vulnerabilidade de **Double-Fetch** causada por otimização de compilação do gcc, permitindo diretamente o sequestro do fluxo de controle.

#### 2. CVE-2016-9793

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

**Versão de teste**: Linux-4.8.13

**Proteção**: KASLR/SMAP/SMEP desativados. A estrutura [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) falsificada está no espaço do usuário, obviamente não é possível contornar o SMAP.

**Vulnerabilidade**: a função [sock_setsockopt()](https://elixir.bootlin.com/linux/v4.8.13/source/net/core/sock.c#L658) em `net/core/sock.c` **trata incorretamente valores negativos**, fazendo com que `sk_sndbuf` e `sk_rcvbuf` assumam valores negativos. Ao chamar `write`, `skb->head` e `skb->end` são definidos incorretamente; ao chamar `close` para liberar, ocorre um erro ao acessar o espaço do usuário. A estrutura [skb_shared_info](https://elixir.bootlin.com/linux/v4.8.13/source/include/linux/skbuff.h#L414) é falsificada no endereço de espaço do usuário `0xfffffed0`, e o fluxo de controle é sequestrado por meio de `skb_shared_info->destructor_arg->callback`.

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

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

**Versão de teste**: Linux-4.20.0-rc3

**Proteção**: SMEP ativado, KASLR/SMAP desativados.

**Vulnerabilidade**: vulnerabilidade de **integer overflow** em `queue_stack_map_alloc()` no módulo eBPF do Linux, resultando em heap overflow. O ponteiro da vtable é modificado para sequestrar o fluxo de controle até `xchg eax, esp`.

#### 4. CVE-2017-5123

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

**Versão de teste**: Linux 4.14-rc4

**Proteção**: SMEP/SMAP ativados, KASLR desativado.

**Vulnerabilidade**: a implementação de `waitid` em `/kernel/exit.c`, ao chamar `unsafe_put_user()` para copiar dados do kernel para um endereço do espaço do usuário, não chama `access_ok()` para verificar a validade do endereço do espaço do usuário, permitindo efetivamente copiar dados para endereços do espaço do kernel. **waitid não verifica a validade do endereço do usuário, resultando em escrita arbitrária null**. É possível executar shellcode no endereço 0 ou sobrescrever uma cred em um intervalo adivinhado para escalar privilégios.

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

**Versão de teste**: Linux-4.9.12

**Proteção**: SMEP/SMAP ativados, kASLR desativado.

**Vulnerabilidade**: no DCCP (Datagram Congestion Control Protocol) do protocolo IP versão 6 do kernel Linux, a função [dccp_rcv_state_process()](https://elixir.bootlin.com/linux/v4.9.12/source/net/dccp/input.c#L574) em `net/dccp/input.c` trata incorretamente a estrutura de dados do pacote `DCCP_PKT_REQUEST` no estado `LISTEN`. Quando o usuário usa a opção `IPV6_RECVPKTINFO` para chamar `setsockopt()`, isso aciona um **Double-Free** da estrutura `sk_buff`. O método de exploração é semelhante ao CVE-2016-8655. Na primeira vez que a vulnerabilidade é acionada, o heap spray falsifica a estrutura `po->rx_ring->prb_bdqc->retire_blk_timer` para executar `native_write_cr4(0x406e0)` e desativar SMEP/SMAP; na segunda vez, o heap spray falsifica a estrutura `skb-> ... ->destructor_arg` para executar `commit_creds(prepare_kernel_cred(0))` e escalar privilégios.

#### 6. CVE-2017-7308

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

**Versão de teste**: Linux-4.10.6

**Proteção**: SMEP/SMAP ativados, KASLR desativado.

**Vulnerabilidade**: a função [`packet_set_ring()`](https://elixir.bootlin.com/linux/v4.10.6/source/net/packet/af_packet.c#L4181) em `net/packet/af_packet.c` não verifica corretamente o tamanho dos blocos; a condição de verificação de comprimento está incorreta, resultando em **heap overflow**. É necessária a permissão `CAP_NET_RAW`. Os ponteiros de função são sequestrados duas vezes: primeiro desativando as proteções SMEP/SMAP e depois escalando privilégios.

#### 7. CVE-2017-8890

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

**Versão de teste**: Linux-4.10.15

**Proteção**: SMEP ativado, kASLR/SMAP desativados.

**Vulnerabilidade**: a função [`inet_csk_clone_lock()`](https://elixir.bootlin.com/linux/v4.10.15/source/net/ipv4/inet_connection_sock.c#L652) no arquivo `net/ipv4/inet_connection_sock.c` contém uma vulnerabilidade de **Double-Free**. O Double-Free é usado para adulterar o ponteiro de callback do RCU, desativar o SMEP e saltar para o shellcode para modificar a cred.

#### 8. CVE-2017-11176

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

**Versão de teste**: Linux-4.11.9

**Proteção**: SMEP ativado, kASLR/SMAP desativados.

**Vulnerabilidade**: na implementação das filas de mensagens POSIX no kernel Linux, a função `mq_notify()` não define o ponteiro sock como null, causando UAF. Na prática, é uma vulnerabilidade de **Double-Free causada por condição de corrida**, mas o tempo da corrida pode ser estendido indefinidamente.

#### 9. CVE-2017-16995

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

**Versão de teste**: Linux-4.4.110

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: problema de **extensão de inteiros** no módulo eBPF do Linux. O principal problema é que os tipos de valores dos dois registradores são diferentes, fazendo com que a função de verificação e a função real sejam executadas de maneiras inconsistentes. Esta vulnerabilidade não envolve ataque de pilha ou sequestro de fluxo de controle; apenas utiliza dados de chamadas de sistema para escalar privilégios, sendo uma aplicação típica de Data-Oriented Attacks no kernel Linux.

#### 10. CVE-2017-1000112

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

**Versão de teste**: Linux-4.12.6

**Proteção**: SMEP ativado, SMAP/kaslr desativados.

**Vulnerabilidade**: [`__ip_append_data()`](https://elixir.bootlin.com/linux/v4.12.6/source/net/ipv4/ip_output.c#L910) em `net/ipv4/ip_output.c` não garante a consistência do processamento de datagramas UDP, fazendo com que, ao enviar mensagens duas vezes, haja uma troca do caminho UFO para o caminho non-UFO, resultando em **heap overflow**. Na exploração, é possível sequestrar o fluxo de controle sobrescrevendo `skb_shared_info->destructor_arg->callback`.

#### 11. CVE-2018-5333

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

**Versão de teste**: Linux-4.14.13

**Proteção**: SMEP ativado, SMAP/kaslr desativados.

**Vulnerabilidade**: na função [`rds_cmsg_atomic()`](https://elixir.bootlin.com/linux/v4.14.13/source/net/rds/rdma.c#L788) em `net/rds/rdma.c`, é esquecido de definir `rm->atomic.op_active` como 0, o que faz com que [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) referencie `page->page_link`, ocorrendo uma vulnerabilidade de **null-dereference**. Estruturas e ponteiros de função são falsificados no endereço 0 para sequestrar o fluxo de controle.

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

**Versão de teste**: Linux-4.20.0 32 bits

**Proteção**: SMEP ativado, SMAP/kaslr desativados.

**Vulnerabilidade**: 

- CVE-2019-9213: a função [`expand_downwards()`](https://elixir.bootlin.com/linux/v4.20.7/source/mm/mmap.c#L2413) em `mm/mmap.c` verifica incorretamente o endereço mínimo de mmap e realiza a verificação de capability na task errada, contornando a limitação de `mmap_min_addr` — **vulnerabilidade lógica**. Usando o comando `LD_DEBUG=help /bin/su 1>&%d` para executar a operação de escrita, deveria verificar a cred do exploit, mas erroneamente verifica a cred do processo de escrita, marcando o endereço baixo como acessível para processos privilegiados. Apenas sistemas de 32 bits conseguem explorar com sucesso; o motivo é desconhecido.
- CVE-2019-8956: a função [`sctp_sendmsg()`](https://elixir.bootlin.com/linux/v4.20.7/source/net/sctp/socket.c#L2025) em `net/sctp/socket.c` apresenta uma vulnerabilidade de **referência a ponteiro nulo** ao processar o flag `SCTP_SENDALL`. Combinando com o CVE-2019-9213, contornando a limitação de `mmap_min_addr`, é possível mapear o endereço baixo `0xd4`, falsificar estruturas e sequestrar o fluxo de controle.

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

**Versão de teste**: Ubuntu 18.04 (4.15.0-20-generic #21)

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: [verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379) em `net/xfrm/xfrm_user.c` trata incorretamente a validação de `dir`, causando **acesso fora dos limites** em [__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202). Originalmente, a vulnerabilidade é um decremento fora dos limites; pode-se usar outro caminho para construir UAF e **escrever null de 8 bytes em um bloco livre**. O objeto vulnerável `xfrm_policy` está em `kmalloc-1024`, e a estrutura cred está em `kmalloc-192`. Primeiro, usa-se `setxattr+userfaultfd` para pulverizar blocos `kmalloc-1024` ao redor de `policy0`. Após liberar `policy0`, os blocos pulverizados também são liberados, fazendo com que, após a liberação daquela slab, ela seja reutilizada pela cred do processo filho c. Então, aciona-se o UAF para escrever null de 8 bytes no bloco livre, modificando `gid/suid` na cred. Em seguida, adiciona-se o usuário atual ao sudoers para escalar privilégios.

#### 14. CVE-2020-8835

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

**Versão de teste**: Linux-5.5.0

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: `kernel/bpf/verifier.c` não converte corretamente valores de 64 bits para 32 bits (pega diretamente os 32 bits baixos), causando **truncamento de inteiro**, o que torna a fase de verificação do código BPF inconsistente com a fase real de execução, resultando em leitura/escrita fora dos limites.

#### 15. CVE-2020-27194

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

**Versão de teste**: Linux-5.8.14

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: durante a operação OR no verificador eBPF, a função `scalar32_min_max_or()` atribui um valor de 64 bits a uma variável de 32 bits, causando **truncamento de inteiro** e cálculo incorreto do intervalo dos registradores, contornando a verificação do BPF e resultando em leitura/escrita fora dos limites.

#### 16. CVE-2021-3156

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

**Versão de teste**: Ubuntu 19.04, Sudo 1.8.27

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: ao processar argumentos de linha de comando, o sudo comete um erro lógico ao processar comandos terminados com uma única barra invertida, resultando em **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)

**Versão de teste**: Linux-5.11

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: no módulo eBPF — a função [`__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 incorretamente os registradores. Aproveitando a inconsistência entre a fase de verificação e a fase real de execução, realiza-se leitura/escrita fora dos limites. Após vazar o endereço base do kernel, falsificar a tabela de funções e implementar leitura/escrita arbitrária, a cred da thread atual é modificada.

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

**Versão de teste**: Linux-5.11  Linux-5.11.16

**Proteção**: SMEP/SMAP/kaslr ativados.

**Vulnerabilidade**: no módulo eBPF — o rastreamento de limites das operações bit a bit (AND, OR e XOR) do ALU32 do eBPF em `kernel/bpf/verifier.c` não atualiza corretamente os limites de 32 bits, causando leitura e escrita fora dos limites no kernel Linux e, consequentemente, execução arbitrária de código. As três funções vulneráveis são [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). Aproveitando a inconsistência entre a fase de verificação e a fase real de execução, realiza-se leitura/escrita fora dos limites. Após vazar o endereço base do kernel, falsificar a tabela de funções e implementar leitura/escrita arbitrária, a cred da thread atual é modificada.

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

**Versão de teste**: Linux-5.11.14

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: no submódulo `ip_tables` do módulo `Netfilter` em `net/netfilter/x_tables.c`, ao chamar `setsockopt()` com a opção `IPT_SO_SET_REPLACE` (ou `IP6T_SO_SET_REPLACE`), a estrutura do kernel precisa ser convertida de 32 bits para 64 bits. Devido ao cálculo incorreto do tamanho da conversão, ao chamar a função [xt_compat_match_from_user()](https://elixir.bootlin.com/linux/v5.11.14/source/net/netfilter/x_tables.c#L731) ocorre **heap overflow escrevendo 0, que pode ser transformado em UAF**. O atacante pode usá-lo para escalar privilégios ou escapar de contêineres docker/k8s ([kubernetes](https://zhuanlan.zhihu.com/p/29232090)). É necessária a permissão `CAP_NET_ADMIN`, ou suporte ao namespace `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)

**Versão de teste**: Linux-5.14.6

**Proteção**: KASLR/SMEP/SMAP ativados. `CONFIG_SLAB_FREELIST_RANDOM` / `CONFIG_SLAB_FREELIST_HARDENED` / `CONFIG_BPF_JIT_ALWAYS_ON` / `CONFIG_MEMCG` desativados (por padrão estão ativados).

**Vulnerabilidade**: a função `loop_rw_iter()` em `fs/io_uring.c` contém uma vulnerabilidade de **type confusion**. `io_kiocb->rw.addr` atua tanto como endereço do kernel quanto como endereço do usuário, mas na função `loop_rw_iter()` o incremento não faz distinção, fazendo com que, ao ler um arquivo, o endereço do kernel seja incrementado incorretamente e, por fim, **um buffer adjacente em um offset controlável seja liberado incorretamente** (kmalloc-32). As condições de exploração são bastante estritas: como o objeto vulnerável está em kmalloc-32, o mecanismo de proteção da freelist é desativado; como o objeto `seq_operations` é alocado com o flag `GFP_KERNEL_ACCOUNT`, o mecanismo `CONFIG_MEMCG*` também é desativado; esta exploração modifica o ponteiro `sk_filter->prog` no eBPF e falsifica um programa BPF para escalar privilégios, por isso também é necessário desativar `CONFIG_BPF_JIT_ALWAYS_ON`.

#### 21. CVE-2021-4154

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

**Versão de teste**: Linux-5.13.3

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: a função [cgroup1_parse_param()](https://elixir.bootlin.com/linux/v5.13.3/source/kernel/cgroup/cgroup-v1.c#L905) em `kernel/cgroup/cgroup-v1.c` (acionada pela chamada de sistema `fsconfig`) contém type confusion, resultando em **UAF**. É possível chamar a syscall `fsconfig` para definir um fd arbitrário e, ao fechar esse arquivo, o objeto `file` correspondente ao fd é liberado. Assim, é possível **liberar a estrutura `file` correspondente a qualquer descritor de arquivo**. Este artigo utiliza dois métodos de exploração: um é DirtyCred e o outro é construir ROP. Comparando os dois métodos, a vantagem do DirtyCred é que é universal entre versões do kernel, sem necessidade de adaptação; a desvantagem é que requer sobrescrever um arquivo privilegiado para escalar privilégios, portanto não funciona em contêineres como docker. A vantagem do ROP é que permite leitura/escrita arbitrária na memória do kernel e execução de código arbitrário; a desvantagem é que a adaptação para diferentes versões do kernel é trabalhosa.

#### 22. CVE-2021-42008

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

**Versão de teste**: Linux-5.13.12

**Proteção**: KASLR / SMEP / SMAP / PTI ativados.

**Vulnerabilidade**: a função [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) em `drivers/net/hamradio/6pack.c` possui **heap overflow**, sendo necessário que o usuário tenha a permissão `CAP_NET_ADMIN`. [sixpack_decode()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L962) pode chamar [decode_data()](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L826) várias vezes, decodificando a entrada e salvando em [sixpack->cooked_buf](https://elixir.bootlin.com/linux/v5.13.12/source/drivers/net/hamradio/6pack.c#L98). O membro `sixpack->rx_count_cooked` atua como índice de acesso a `sixpack->cooked_buf`, determinando o offset de destino da gravação dos bytes decodificados. O problema é que, se `decode_data()` for chamado várias vezes, `rx_count_cooked` continua incrementando até ultrapassar o comprimento de `cooked_buf` (400 bytes), causando gravação fora dos limites. Referindo-se a [como usar a estrutura msg_msg no kernel Linux para implementar leitura/escrita arbitrária](https://www.anquanke.com/post/id/252558), constrói-se leitura fora dos limites e escrita arbitrária para modificar `modprobe_path` e escalar privilégios. A desvantagem é que é necessário usar `userfaultfd` e não é possível contornar a exigência de `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/)

**Versão de teste**: Linux-5.14.15

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: a vulnerabilidade está no arquivo `net/tipc/crypto.c`. No protocolo de comunicação intra-cluster TIPC (Transparent Inter-Process Communication), a validação do comprimento de mensagens do tipo `MSG_CRYPTO` está incorreta, resultando em **heap overflow**. Na função [tipc_crypto_key_rcv()](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/crypto.c#L2281), a parte de dados da mensagem TIPC (estrutura [tipc_msg](https://elixir.bootlin.com/linux/v5.14.15/source/net/tipc/msg.h#L148)) aponta para a mensagem `MSG_CRYPTO` (estrutura [tipc_aead_key](https://elixir.bootlin.com/linux/v5.14.15/source/include/uapi/linux/tipc.h#L241)). Ao alocar espaço para `tipc_aead_key` e copiar `tipc_aead_key->key`, a validade de `tipc_aead_key->keylen` não é verificada, causando cópia fora dos limites. Apenas o `header size` e o `msg size` da mensagem TIPC são verificados, mas o `tipc_aead_key->keylen` da mensagem `MSG_CRYPTO` não é verificado. Usa-se um objeto elástico para vazar o endereço base do kernel, modifica-se `tty_struct->tty_operations.ioctl` para apontar para um gadget de escrita arbitrária (`mov   QWORD PTR [rdx],rsi`) e altera-se `modprobe_path` para escalar privilégios.

#### 24. CVE-2022-0185

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

**Versão de teste**: Linux-5.11.22

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: escalada de privilégios concluída no google kctf, ganhando 30 mil dólares. No módulo `File System Context` do kernel, o arquivo `fs/fs_context.c` contém **integer overflow** que resulta em heap overflow. O atacante deve ter a permissão `CAP_SYS_ADMIN`, ou usar namespaces, ou usar `unshare(CLONE_NEWNS|CLONE_NEWUSER)` (equivalente ao comando `$ unshare -Urm`) para entrar em um namespace que contenha a permissão `CAP_SYS_ADMIN`. Dois métodos de exploração: um é usar **FUSE** (equivalente a userfault) para construir escrita arbitrária e modificar `modprobe_path`; o outro é usar `msg_msg` para construir uma liberação arbitrária e, em seguida, construir ROP para escalar privilégios.

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

**Versão de teste**: Linux-5.16.10

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: vulnerabilidade **DirtyPipe**. Quando a chamada `splice` liga o page cache do arquivo ao buffer circular do pipe [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26), as funções [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) não inicializam o membro `flag` de [pipe_buffer](https://elixir.bootlin.com/linux/v5.16.10/source/include/linux/pipe_fs_i.h#L26) (vulnerabilidade de variável não inicializada). Como o atributo `PIPE_BUF_FLAG_CAN_MERGE` não é limpo, em uma chamada posterior a `pipe_write()`, o kernel erroneamente considera que a operação de escrita pode ser mesclada, permitindo escrever dados ilegais no page cache do arquivo (restaurado após reinicialização), resultando em vulnerabilidade de sobrescrita arbitrária de arquivos. Esta vulnerabilidade pode escrever no page cache de qualquer arquivo; o método de escalada de privilégios é modificar o page cache de /etc/passwd. Em um curto período, todos os processos que acessarem esse arquivo acessarão a página de cache adulterada.

#### 26. CVE-2022-0995

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

**Versão de teste**: Linux-5.11.22

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: o subsistema de notificação de eventos `watch_queue` possui **heap overflow**. A função vulnerável é [watch_queue_set_filter()](https://elixir.bootlin.com/linux/v5.16.14/source/kernel/watch_queue.c#L286). O kernel realiza duas verificações de validade no filtro do tipo [watch_notification_type_filter](https://elixir.bootlin.com/linux/v5.16.14/source/include/uapi/linux/watch_queue.h#L52) fornecido pelo usuário: a primeira verificação é para determinar o tamanho da memória a ser alocada; a segunda é para armazenar o filtro do usuário nessa memória. No entanto, as duas verificações são inconsistentes, fazendo com que o espaço alocado seja pequeno demais, permitindo armazenar mais filtros em overflow. Pode-se aproveitar o overflow da segunda verificação para definir bits específicos em blocos adjacentes; o método de exploração subsequente é o mesmo do [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/)

**Versão de teste**: Linux-5.17

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: no módulo nftables, as funções [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) não limitam o intervalo do índice de registrador passado, causando integer overflow (capaz de passar na verificação de intervalo), desencadeando **stack overflow com leitura/escrita fora dos limites**. Para explorar, é necessário retornar do contexto de interrupção para o modo usuário, usando o final da função `__do_softirq()` para retornar perfeitamente ao contexto da syscall e, em seguida, chamar `switch_task_namespaces(current, &init_nsproxy)` e `commit_cred(&init_cred)` para escalar privilégios.

#### 28. CVE-2022-2588

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

**Versão de teste**: Linux-5.19.1

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: semelhante ao [CVE-2021-3715](https://access.redhat.com/security/cve/cve-2021-3715) (ver [BlackHat 2021-Europe-Your Trash Kernel Bug, My Precious 0-day](https://zplin.me/talks/BHEU21_trash_kernel_bug.pdf), página 16). Devido à inconsistência das condições de verificação ao remover e liberar o objeto `route4_filter` da lista encadeada, o objeto, após ser liberado, permanece na lista, permitindo acionar um **Double-Free** posteriormente. É necessário `User Namespaces` para acionar. Usa-se o método **DirtCred** para escalar privilégios.

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

**Versão de teste**: Linux-5.18.19

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: no componente io_uring, há um recurso `IORING_REGISTER_FILES` que pode colocar arquivos na fila `sock->receive_queue` do io_uring. O mecanismo de coleta de lixo (GC) do Linux (que processa apenas a contagem de voo dos arquivos io_uring e sock) pode liberar erroneamente os arquivos registrados no io_uring como lixo. Na próxima vez que o io_uring usar esse arquivo (usando writev para escrever no arquivo, correspondente ao recurso `IORING_OP_WRITEV`), ocorre uma vulnerabilidade de **UAF**. Método de exploração: como o mecanismo de coleta de lixo UNIX_GC libera erroneamente a estrutura de arquivo ainda em uso no `io_uring` (que está escrevendo dados maliciosos no arquivo comum `"/tmp/rwA"`), pode-se usar o método **DirtyCred**: abrir muitos arquivos `"/etc/passwd"` para sobrescrever a estrutura `file` recém-liberada, fazendo com que, no final, os dados maliciosos sejam realmente escritos no arquivo `"/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/)

**Versão de teste**: Linux-5.17.4

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: no módulo do kernel `openvswitch`, [reserve_sfa_size()](https://elixir.bootlin.com/linux/v5.17.4/source/net/openvswitch/flow_netlink.c#L2439) possui integer overflow que resulta em **heap overflow de escrita em kmalloc-0x10000**, sendo necessário usar page spray para construir overflow cross-cache. Este artigo usa a `pipe-primitive` para modificar arquivos arbitrários, portanto não é necessário contornar KASLR/SMEP/SMAP/KPTI, e a exploração pode ser concluída sem adaptação entre versões. **Primeiro, cria-se um pipe e faz-se splice no arquivo somente leitura `/usr/bin/mount`; com heap spray, falsifica-se `pipe_buffer->flags = PIPE_BUF_FLAG_CAN_MERGE`, permitindo escrever um suid-shell em `/usr/bin/mount` e então executá-lo para escalar privilégios**. A OOB é acionada duas vezes: a primeira vez, o overflow modifica `msg_msg->m_ts` para ler fora dos limites o `msg_msg->m_list.next` adjacente, **vazando o endereço do heap kmalloc-1024**; a segunda vez, o overflow modifica `msg_msg->m_list.next` para apontar para o endereço vazado do heap kmalloc-1024, **construindo uma liberação arbitrária**.

#### 31. CVE-2022-25636

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

**Versão de teste**: Linux-5.13.19

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: no módulo `nf_table`, a função [nft_fwd_dup_netdev_offload()](https://elixir.bootlin.com/linux/v5.16.11/source/net/netfilter/nf_dup_netdev.c#L67) em `net/netfilter/nf_dup_netdev.c` possui **OOB write** (o sistema deve suportar offload de processamento de pacotes — Network Interface Cards (NICs), o que é raro na prática) devido à inconsistência entre o cálculo do espaço de alocação e a condição de verificação durante a inicialização real. **O overflow escreve o endereço de um objeto `net_device` (localizado em kmalloc-4k)**, e o tamanho do objeto vulnerável pode variar (determinado pelo número de regras com o flag `NFT_OFFLOAD_F_ACTION` passadas, podendo estar em `kmalloc-128`, `kmalloc-192`, etc.), sendo necessária a permissão `SYS_ADMIN`. Na exploração, **usa-se `msg_msgseg` para vazar o ponteiro do heap kmalloc-4k do `net_device`, constrói-se uma liberação arbitrária sobrescrevendo o ponteiro `msg_msg->security`, usa-se o recurso nativo `ioctl(fd, SIOCGIFHWADDR, leak)` para ler `net_device->dev_addr` e vazar o endereço base do kernel, e falsifica-se o ponteiro de função `net_device->ethtool_ops->begin` para sequestrar o fluxo de controle e escalar privilégios**.

#### 32. CVE-2022-27666

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

**Versão de teste**: Linux-5.16.14

**Proteção**: KASLR/SMEP/SMAP ativados.

**Vulnerabilidade**: na competição PWN2OWN, foi concluída a escalada de privilégios no Ubuntu 21.10. No módulo esp6 crypto do kernel, o buffer de recepção é de 8 páginas, mas o remetente pode enviar dados maiores que 8 páginas, causando **page overflow** pela função [null_skcipher_crypt()](https://elixir.bootlin.com/linux/v5.16.14/source/crypto/crypto_null.c#L76). No geral, usa-se a técnica de page spray: primeiro, utiliza-se o objeto elástico `user_key_payload` para vazar `msg_msg->next`; depois, utiliza-se `msg_msg` para vazar o endereço do kernel de `seq_operations->start`; por fim, utiliza-se `msg_msg` e o tratamento de page fault do FUSE para construir escrita arbitrária, modificando `modprobe_path` para escalar privilégios.

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

**Test version**: Linux-5.17.12

**Protection**: KASLR/SMEP/SMAP habilitados.

**Vulnerability**: No módulo `nftables`, em `net/netfilter/nf_tables_api.c`, ao usar a funcionalidade `NFT_MSG_NEWSET` para adicionar um `nft_set`, ao processar as expressões `lookup` e `dynset`, devido a uma verificação incorreta de `NFT_EXPR_STATEFUL`, o objeto `nft_expr` permanece na lista encadeada `nft_set->binding` após ser liberado; ao adicionar um novo `nft_expr`, isso resulta em **escrita UAF** (é necessário privilégio `CAP_NET_ADMIN` para acionar a vulnerabilidade). A escrita UAF grava, no offset 0x18 de um `kmalloc-64`, o valor do endereço do offset 0x18 de outro bloco de heap `kmalloc-64`. Método de exploração: usar `msg_msg` da mqueue para vazar a base do kernel, pois `posix_msg_tree_node->msg_list` da mqueue está no offset 0x18 (e reside em `kmalloc-64`), exatamente o offset da escrita UAF; além disso, **`posix_msg_tree_node->msg_list` também pode ser usado para montar uma exploração Unlink** para adulterar `modprobe_path`. Usar `user_key_payload` para vazar o endereço de heap (facilitando montar o unlink) é uma técnica antiga e conhecida. Observação: é necessário usar libmnl ou libnftnl de versão superior à do 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/)

**Test version**: Linux-5.17.15

**Protection**: KASLR/SMEP/SMAP habilitados.

**Vulnerability**: No módulo nftables, a função [nft_set_elem_init()](https://elixir.bootlin.com/linux/v5.18.10/source/net/netfilter/nf_tables_api.c#L5459) possui **heap overflow**, o comprimento do estouro pode chegar a `64-16=48` bytes; o objeto vulnerável pode estar em `kmalloc-{64,96,128,192}` (neste exploit foi escolhido o objeto vulnerável em kmalloc-64). Exploração — primeiro monta-se o layout de heap `vul_obj -> user_key_payload -> percpu_ref_data`; o overflow altera `user_key_payload->datalen` para 0xffff, vazando a base do kernel de `percpu_ref_data->release` e a base physmap de `percpu_ref_data->ref`; depois monta-se o layout `vul_obj -> simple_xattr`; o overflow altera a lista encadeada `simple_xattr->list`, usando essa escrita arbitrária limitada para alterar `modprobe_path` de `/sbin/modprobe` para `/tmp/xxxxprobe` e elevar privilégio (a escrita arbitrária é acionada ao remover o xattr da lista). O pré-requisito dessa escrita arbitrária é vazar o endereço physmap; `percpu_ref_data` / `shm_file_data` contêm tanto a base do kernel quanto o endereço physmap.

#### 35. CVE-2023-2598

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

**Test version**: Linux-6.3.1

**Protection**: KASLR/SMEP/SMAP habilitados.

**Vulnerability**: Vulnerabilidade de escrita OOB no módulo io_uring, que pode causar **leitura/escrita fora dos limites da memória física**. A vulnerabilidade está na função [io_sqe_buffer_register()](https://elixir.bootlin.com/linux/v6.3.1/source/io_uring/rsrc.c#L1230) localizada em `io_uring/rsrc.c`; ao verificar se as páginas submetidas para registro pertencem à mesma folha composta (compound page), apenas verifica se a primeira página da folha composta é a mesma, sem verificar se as páginas submetidas são a mesma página. É possível registrar a mesma página física (fingindo ser uma folha composta de várias páginas físicas), construindo leitura/escrita fora dos limites de comprimento arbitrário em uma página física.   

Com a leitura/escrita fora dos limites de comprimento arbitrário em página física, é possível ler/escrever arbitrariamente o objeto sock adjacente; vaza-se a base do kernel via `sock->sk_data_ready`, vaza-se o endereço de heap do objeto sock via `sock.sk_error_queue.next`, e forja-se o ponteiro de função `sock.__sk_common.skc_prot->ioctl` apontando para a função [call_usermodehelper_exec()](https://elixir.bootlin.com/linux/v6.3.1/source/kernel/umh.c#L434) para **sequestrar o fluxo de controle**; também é necessário forjar a estrutura `subprocess_info` para completar a exploração, executando por fim **`/bin/sh -c /bin/sh &>/dev/ttyS0 </dev/ttyS0`** para elevar privilégio.

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

**Test version**: Linux-6.3.13

**Protection**: KASLR/SMEP/SMAP habilitados.

**Vulnerability**: Existe uma **vulnerabilidade de UAF** no componente nf_tables do subsistema netfilter. Na função [nft_verdict_init()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/nf_tables_api.c#L10321), é permitido definir um valor de verdict muito grande (valor malicioso 0xffff0000); na função [nf_hook_slow()](https://elixir.bootlin.com/linux/v6.3.13/source/net/netfilter/core.c#L607), ao processar `NF_DROP` (0), ela primeiro libera o pacote skb e chama [NF_DROP_GETERR()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L19) para modificar o valor de retorno (definido para `NF_ACCEPT` — valor positivo 1 — de acordo com o valor do verdict). A referência posterior ao skb aciona a UAF, e [NF_HOOK()](https://elixir.bootlin.com/linux/v6.3.13/source/include/linux/netfilter.h#L407) libera o skb novamente. Método de exploração: **construir páginas PMD e PTE sobrepostas**; `PMD[0]`/`PMD[1]` sobrescrevem `PTE[0]`/`PTE[1]`; ao escrever no endereço virtual de usuário correspondente à página PTE, forja-se a página PTE correspondente a `PMD[0]` (as entradas correspondem a endereços físicos). Assim, escrevendo no endereço virtual de usuário correspondente ao PMD, é possível **realizar escrita em endereço físico arbitrário**.

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

**Test version**: Linux-6.6.75

**Protection**: KASLR/SMEP/SMAP habilitados.

**Vulnerability**: No módulo `net/sched`, ao chamar a função `pfifo_tail_enqueue()` para um qdisc (com `sch->limit == 0`), o comprimento da fila qlen desse qdisc é incrementado incorretamente (mesmo com a fila cheia, um novo pacote é adicionado sem antes descartar um pacote), enquanto o qlen do qdisc pai (o chamador) não é incrementado; isso faz com que o qlen da fila pai não seja igual à soma dos qlens das filas filhas, permitindo construir uma UAF. Vazamento da base do kernel — usando o princípio de inserção de nós da árvore rubro-negra para adulterar `user_key_payload->datalen` e construir uma leitura fora dos limites, vazando o ponteiro de função `xfrm_policy_timer` em um objeto `xfrm_policy` adjacente. Sequestro do fluxo de controle — forjar o ponteiro de função `UAF_hfsc_class->dequeue`; por meio do dequeue após o enqueue do pacote, acionar `hfsc_dequeue()` -> `qdisc_dequeue_peeked()` -> `sch->dequeue()` para sequestrar o fluxo de controle; o registrador RDI é controlável.

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

**Test version**: Linux-6.12.24

**Protection**: KASLR/SMEP/SMAP habilitados.

**Vulnerability**: Existe uma vulnerabilidade de UAF por condição de corrida em `kernel/events/` (subsistema perf). Há uma condição de corrida entre `__perf_event_overflow()` e `perf_remove_from_context()`. Para eventos perf orientados a software/tracepoint, o tratamento de overflow apenas desabilita a preempção (não desativa as interrupções duras). Nesse contexto, o caminho de limpeza `perf_event_release_kernel()` → `perf_remove_from_context()` pode ser executado concorrentemente em outra CPU, liberando o estado relacionado a callbacks (por exemplo, `event->pending_task`) enquanto o caminho de overflow ainda o utiliza, resultando em UAF. A correção é adicionar sincronização adequada em `__perf_event_overflow()` para garantir que o caminho de liberação não avance concorrentemente durante o acesso do caminho de overflow aos campos relacionados a callbacks.
- A corrida (a thread Worker aciona o caminho de overflow via tracepoint; a thread Closer chama `close()` concorrentemente no fd do perf_event) dispara `WARN_ON_ONCE`; após a refcount chegar a zero, `task_work_add` ainda adiciona o `pending_task` do evento já liberado à lista task_work.
- Detecta-se o sucesso da corrida por meio de polling do bit TAINT_WARN(512) em `/proc/sys/kernel/tainted`; 1024 threads de spray liberam sincronizadamente, usando o evento B para ocupar o slot de slab liberado pelo evento A.
- Quando `futex_wait` retorna ao espaço do usuário, `perf_pending_task` executa `put_event(evento B)`, decrementando incorretamente a refcount do evento B para 0, formando um **FD pendurado estável**.
- O ID Oracle aloca sequencialmente o evento C para sondar mudanças de ID e localizar com precisão a vítima; o ataque entre caches devolve a página de slab `perf_event_cache` ao buddy e depois a recupera com `msg_msgseg`.