CVE-2026-31431 — "Copy Fail": Escalação de Privilégio Local no `algif_aead` do Kernel Linux

CISA KEV | CVSS 7.8 ALTO | Afeta kernels Linux 4.14 – início de 2026 (~9 anos)

Índice

Resumo Executivo
Avaliação de Risco
Análise Técnica Detalhada
Metodologia de Ataque — Red Team
Detecção e Resposta a Incidentes — Blue Team
Correção e Remediação
Ambiente de Laboratório
Referências

1. Resumo Executivo

CVE-2026-31431, apelidada de "Copy Fail", é uma vulnerabilidade de escalada de privilégio local (LPE) de alta gravidade no subsistema criptográfico do kernel Linux. Um usuário local com privilégios baixos pode escalar para root em segundos em qualquer sistema sem correção.

Impacto nos Negócios

Acesso root em qualquer servidor Linux, VM, instância de nuvem ou host de contêiner sem correção
Escape de contêiner de pods Kubernetes — o cache de páginas é compartilhado com o kernel do host
Zero pegada em disco — a exploração não deixa alterações em arquivos, páginas sujas ou trilha de auditoria via ferramentas padrão de integridade de arquivos (Tripwire, AIDE)
Afeta Red Hat, Ubuntu, Debian, SUSE, Amazon Linux e praticamente todas as principais distribuições que executam kernels de 2017 em diante

Ação Imediata Recomendada

Mitigação temporária (implantar agora, sem necessidade de reinicialização se o módulo não estiver carregado): ```bash echo "install algif_aead /bin/false" | sudo tee /etc/modprobe.d/disable-algif-aead.conf sudo rmmod algif_aead 2>/dev/null || true
Correção permanente: Atualize os pacotes do kernel por meio do gerenciador de pacotes da sua distribuição e reinicie o sistema.
Verificação: Execute detection/check_vulnerable.sh antes e depois da remediação.

2. Avaliação de Risco

Vetor CVSS 3.1```

CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H

| Métrica | Valor | Justificativa |
|--------|-------|-----------|
| Vetor de Ataque | **Local** | Requer acesso ao shell (SSH, exec em contêiner, físico) |
| Complexidade do Ataque | **Baixa** | Confiável, totalmente automatizado — não requer condição de corrida |
| Privilégios Necessários | **Baixos** | Qualquer conta de usuário sem privilégios |
| Interação do Usuário | **Nenhuma** | Nenhuma interação da vítima necessária |
| Confidencialidade | **Alta** | Comprometimento total do sistema |
| Integridade | **Alta** | Comprometimento total do sistema |
| Disponibilidade | **Alta** | Comprometimento total do sistema |

### Panorama de Ameaças

| Fator | Avaliação |
|--------|-----------|
| Disponibilidade de PoC | Pública, armada, Python autônomo de 732 bytes |
| Confiabilidade do Exploit | Alta — funciona em distros testadas sem modificação |
| Dificuldade de Detecção | Alta — sem gravações em disco, sem páginas sujas |
| Habilidade Necessária do Atacante | Baixa — script kiddie com PoC público |
| CISA KEV | Adicionado em 2026 — monitorado ativamente |
| Microsoft Defender | Sinalizado como sob investigação ativa |

### Ambientes Afetados

| Ambiente | Risco |
|-------------|------|
| Servidores Linux em hardware físico | Crítico |
| VMs Linux (nuvem ou on-premises) | Crítico |
| Nós Kubernetes | Crítico (também permite escape de contêiner) |
| Hosts Docker | Crítico |
| Hospedagem compartilhada / multi-tenant | Crítico |
| WSL2 / Linux no Windows | Avaliar conforme a versão do kernel |

---

## 3. Mergulho Técnico Aprofundado

### 3.1 Contexto: AF_ALG e AEAD

O kernel Linux expõe operações criptográficas ao espaço do usuário por meio de **soquetes AF_ALG** (`AF_ALG = 38`). Essa interface (`algif_aead`) permite que aplicações sem privilégios invoquem aceleradores de hardware criptográfico do kernel sem precisar de código em modo kernel.

**AEAD** (Autenticação de Criptografia com Dados Associados), algoritmos como AES-GCM e ChaCha20-Poly1305 são amplamente usados para TLS, criptografia de disco e protocolos VPN. O template vulnerável é `authencesn` — uma composição AEAD usando `hmac(sha256)` + `cbc(aes)` com suporte a Número de Sequência Estendido (ESN), comumente usado em IPsec.

### 3.2 Causa Raiz

Em 2017, o commit `72548b093ee3` introduziu a **operação AEAD in-place** em `algif_aead` como uma otimização de desempenho — permitindo que o motor criptográfico lesse e gravasse no mesmo buffer. Isso era falho:```
The bug chain:

1. Caller binds AF_ALG socket to:
      authencesn(hmac(sha256),cbc(aes))

2. Caller sends a decryption request via sendmsg() with specific flags

3. Caller uses splice() to feed PAGE CACHE PAGES from an open file
   descriptor directly into the socket's scatterlist

4. The authencesn template, during ESN header processing, uses the
   OUTPUT BUFFER as scratch space — writing 4 bytes past the
   expected output boundary

5. Because the scatterlist contains page cache pages (not private
   copies), this scratch write lands DIRECTLY IN THE PAGE CACHE

6. Page cache is shared kernel-wide — all processes reading the
   same file now see the modified bytes

Key insight: splice() is zero-copy — it hands page cache references
to the socket. The in-place "optimization" then writes INTO those
pages. No dirty bit is set because the write goes through the crypto
engine, not the normal write path.

3.3 A Primitiva de Escrita

A vulnerabilidade fornece uma escrita controlada de 4 bytes no cache de páginas de qualquer arquivo que o atacante possa abrir para leitura:

A escrita é repetível — o exploit faz um loop da escrita de 4 bytes para corrigir sequências de código maiores.

3.4 Cadeia de Exploração```

[1] Open /usr/bin/su (or any setuid-root binary) for reading ↓ [2] Map a copy to find target instruction bytes (e.g., UID check, execve path, security gate) ↓ [3] Compute exact page cache offset of target bytes ↓ [4] Set up AF_ALG socket → authencesn(hmac(sha256),cbc(aes)) ↓ [5] splice() the target binary's page cache into the socket ↓ [6] Trigger decryption → authencesn scratch write patches the target bytes in page cache (4 bytes per iteration) ↓ [7] Repeat for each 4-byte patch needed ↓ [8] Execute /usr/bin/su → runs root-owned setuid binary but now with attacker-controlled code in page cache ↓ [9] Root shell

### 3.5 Por que as Defesas Padrão Falham

| Defesa | Contornada? | Motivo |
|---------|-----------|--------|
| Monitoramento de Integridade de Arquivos (Tripwire/AIDE) | **Sim** | Nenhuma alteração em disco |
| Verificações de hash de arquivos do IDS | **Sim** | Bytes em disco inalterados |
| Monitoramento de arquivos `inotify` | **Sim** | Nenhum evento de escrita no VFS |
| SELinux / AppArmor | **Parcial** | Controla o processo, não a escrita no page cache via mecanismo de criptografia |
| Montagens somente leitura | **Sim** | Page cache modificado em memória, não via montagem |
| `watch` do auditd no binário | **Sim** | O audit monitora escritas no VFS — isto contorna o VFS |

### 3.6 Versões de Kernel Afetadas

| Ramo | Vulnerável até | Corrigido a partir de |
|--------|-------------------|------------|
| 4.14.x | Todas (origem da vulnerabilidade) | Sem correção upstream (EOL) |
| 5.4.x (LTS) | Todas | Backport da distribuição necessário |
| 5.10.x (LTS) | Todas | Backport da distribuição necessário |
| 5.15.x (LTS) | Todas | Backport da distribuição necessário |
| 6.1.x (LTS) | ≤ 6.1.129 | **6.1.130+** |
| 6.6.x (LTS) | ≤ 6.6.86 | **6.6.87+** |
| 6.12.x (LTS) | ≤ 6.12.22 | **6.12.23+** |
| 6.15-rc | Corrigido no rc | **6.15-rc+** |

> Os kernels de distribuição podem ter aplicado o backport da correção em números de versão diferentes. Verifique sempre o aviso de segurança da sua distribuição.

---

## 4. Metodologia de Ataque — Red Team

> **Autorização Necessária.** Esta seção existe para ajudar defensores a entender a perspectiva do atacante. Execute apenas em sistemas que você possui ou para os quais tenha autorização escrita explícita para testar.

### 4.1 Pré-requisitos

- Shell com privilégios baixos no alvo (SSH, exec em contêiner, cadeia de RCE)
- Python 3.10+ **ou** binário C compilado
- Kernel sem correção com `algif_aead` disponível

### 4.2 Reconhecimento```bash
# Check if vulnerable
uname -r
cat /proc/crypto | grep -A10 "authencesn"
lsmod | grep algif_aead

# Verify setuid target exists
ls -la /usr/bin/su /usr/bin/sudo /usr/bin/passwd

4.3 PoC Público

Os pesquisadores originais (Theori) lançaram um PoC Python autônomo totalmente funcional de 732 bytes:

Repositório: https://github.com/theori-io/copy-fail-CVE-2026-31431
Site: https://copy.fail
Arquivo: `copy_fail_exp.py````bash

Default: targets /usr/bin/su

python3 copy_fail_exp.py

Custom target

python3 copy_fail_exp.py /usr/bin/passwd

Uma cópia local está disponível em `exploit/poc.py`. Consulte `exploit/README.md` para a análise técnica.

### 4.4 Cenário de Escape de Contêiner

Como o cache de páginas do Linux é compartilhado entre todos os processos no mesmo host (incluindo host e contêineres):```
Attacker in container → patches /usr/bin/su in HOST page cache
Host user runs su → executes attacker code as root on host

Isto funciona mesmo a partir de contentores sem privilégios, desde que o kernel do host seja vulnerável.

4.5 Mapeamento MITRE ATT&CK

5. Deteção & Resposta a Incidentes — Blue Team

Este é o foco principal deste repositório.

5.1 Deteção de Vulnerabilidades

Execute o script de deteção em qualquer sistema Linux:```bash chmod +x detection/check_vulnerable.sh sudo ./detection/check_vulnerable.sh

**O que verifica:**
- Versão do kernel em relação a faixas conhecidas como vulneráveis
- Status de carregamento do módulo `algif_aead` e status de bloqueio (blacklist)
- Disponibilidade de `authencesn` em `/proc/crypto`
- Integridade do cache de páginas de binários setuid (requer root)
- Status de patch específico da distribuição
- Processos em execução para indicadores de exploração ativa

Um relatório com registro de data e hora é salvo em `/tmp/cve-2026-31431-report-*.txt`.

### 5.2 Detecção YARA

Duas regras YARA são fornecidas em `detection/yara/`:

| Arquivo de Regra | Finalidade |
|-----------|---------|
| `cve_2026_31431_base.yar` | Corresponde exatamente ao PoC público conhecido |
| `cve_2026_31431_enhanced.yar` | Detecta exploits ofuscados, compilados e variantes |```bash
# Install YARA
apt-get install yara   # Debian/Ubuntu
dnf install yara       # RHEL/Fedora
apk add yara           # Alpine

# Scan running process executables
sudo yara -r detection/yara/cve_2026_31431_enhanced.yar /proc/*/exe 2>/dev/null

# Scan common dropper locations
sudo yara -r detection/yara/cve_2026_31431_enhanced.yar /home /tmp /var/tmp /dev/shm

# Scan uploaded files / quarantine
yara detection/yara/cve_2026_31431_base.yar <suspect_file>

Por que regras aprimoradas são importantes: Os atacantes podem ofuscar o PoC público em Python (codificar strings em base64, codificar o nome do algoritmo com XOR, compilar para um binário C, remover símbolos). A regra aprimorada detecta essas variantes ao mirar invariantes que não podem ser removidos sem quebrar o exploit:

O kernel DEVE receber authencesn como o nome do algoritmo
O exploit DEVE usar splice() para obter acesso zero-copy ao page cache
O exploit DEVE criar um socket AF_ALG (família 38)

5.3 Regras do Auditd

Implante em /etc/audit/rules.d/cve-2026-31431.rules:```bash

Detect AF_ALG socket creation (family 38 = 0x26)

-a always,exit -F arch=b64 -S socket -F a0=38 -k cve_2026_31431_afalg

Detect splice() calls — used to feed page cache into the socket

-a always,exit -F arch=b64 -S splice -k cve_2026_31431_splice

Monitor algif_aead module loading

-a always,exit -F arch=b64 -S init_module -S finit_module -k cve_2026_31431_modload

Detect setuid binary execution by non-root users

-a always,exit -F arch=b64 -S execve -F euid=0 -F auid>=1000 -k cve_2026_31431_suid_exec

Recarregar:```bash
augenrules --load && service auditd restart

Consulta por tentativas de exploração:```bash

Look for AF_ALG socket creation

ausearch -k cve_2026_31431_afalg --start today

Correlate: same PID doing AF_ALG socket + splice

ausearch -k cve_2026_31431_afalg -k cve_2026_31431_splice --start today

### 5.4 Deteção Falco / eBPF

Adicione a `/etc/falco/rules.d/cve-2026-31431.yaml`:```yaml
- rule: CVE-2026-31431 AF_ALG Socket Creation
  desc: Detects unprivileged process creating AF_ALG socket (family 38) — required step for Copy Fail exploit
  condition: >
    syscall.type = socket and
    evt.arg.domain = 38 and
    not user.uid = 0 and
    not proc.name in (known_crypto_daemons)
  output: >
    CVE-2026-31431 exploitation attempt - AF_ALG socket (user=%user.name
    uid=%user.uid pid=%proc.pid cmd=%proc.cmdline)
  priority: CRITICAL
  tags: [cve-2026-31431, lpe, kernel, crypto]

- list: known_crypto_daemons
  items: [strongswan, charon, pluto, openssl]

- rule: CVE-2026-31431 Splice After AF_ALG
  desc: Detects splice() syscall shortly after AF_ALG socket creation — exploitation sequence
  condition: >
    syscall.type = splice and
    not user.uid = 0 and
    evt.elapsed < 5000000000
  output: >
    CVE-2026-31431 splice after AF_ALG socket (user=%user.name pid=%proc.pid)
  priority: CRITICAL
  tags: [cve-2026-31431, lpe]

5.5 Verificação de Integridade do Page Cache

Como o exploit modifica o page cache sem gravar no disco, as ferramentas FIM padrão não o detectam. Esta verificação detecta exploração ativa:```bash #!/bin/bash

Compare in-memory binary against on-disk binary

SETUID_BINS=("/usr/bin/su" "/usr/bin/sudo" "/usr/bin/passwd")

for binary in "${SETUID_BINS[@]}"; do [[ -f "$binary" ]] || continue LIVE_HASH=$(sha256sum "$binary" | awk '{print $1}') echo 3 | sudo tee /proc/sys/vm/drop_caches > /dev/null # flush page cache DISK_HASH=$(sha256sum "$binary" | awk '{print $1}') if [[ "$LIVE_HASH" != "$DISK_HASH" ]]; then echo "CRITICAL: Page cache tampering detected on $binary" echo " Pre-flush: $LIVE_HASH" echo " Post-flush: $DISK_HASH" else echo "OK: $binary page cache matches disk" fi done

> **Nota de produção:** `drop_caches` causa uma queda de desempenho. Execute durante janelas de manutenção ou primeiro em sistemas não críticos.

### 5.6 Indicadores de Comprometimento (IoCs)

| Tipo de IoC | Indicador | Confiança |
|----------|-----------|-----------|
| String (binário/script) | `authencesn(hmac(sha256),cbc(aes))` | Alta |
| Bytes hexadecimais | `78 DA AB 77 F5 71 63 62 64 64` (cabeçalho de payload zlib) | Alta |
| Sequência de syscalls | `socket(38,5,0)` → `bind()` → `splice()` | Alta |
| Rede | Nenhum — puramente local | N/A |
| Arquivo | Sem gravações em disco (furtivo) | — |
| Processo | Processo Python/C de curta duração com socket AF_ALG | Média |
| Cache de páginas | Cache de páginas do binário setuid ≠ hash em disco | Crítica |

### 5.7 Consultas de Detecção SIEM

**Splunk (fonte auditd):**```spl
index=linux_audit sourcetype=auditd action=SYSCALL syscall=socket a0="0x26"
| join pid [
    search index=linux_audit sourcetype=auditd action=SYSCALL syscall=splice
  ]
| where (_time - join_time) < 30
| table _time host user pid cmd a0
| eval severity="CRITICAL"

Elastic KQL:```kql event.action: "SYSCALL" AND process.args: "socket" AND auditd.data.a0: "0x26" AND NOT user.id: "0"

**Microsoft Sentinel (KQL):**```kql
Syslog
| where Facility == "kern" or ProcessName == "audit"
| where SyslogMessage contains "socket" and SyslogMessage contains "a0=0x26"
| extend UserName = extract("uid=([0-9]+)", 1, SyslogMessage)
| where UserName != "0"
| project TimeGenerated, Computer, UserName, SyslogMessage
| order by TimeGenerated desc

6. Correção e Remediação

Execute o script de correção automatizado:```bash chmod +x patch/patch.sh sudo ./patch/patch.sh

### 6.1 Mitigação Imediata (Sem Necessidade de Reinicialização*)```bash
# Blacklist the module permanently
echo "install algif_aead /bin/false" | sudo tee /etc/modprobe.d/disable-algif-aead.conf
echo "install authencesn /bin/false" | sudo tee -a /etc/modprobe.d/disable-algif-aead.conf

# Unload if currently loaded
sudo rmmod algif_aead 2>/dev/null || echo "Not loaded — mitigation active after config"

# Verify
lsmod | grep algif_aead && echo "WARNING: still loaded — reboot needed" || echo "OK: not loaded"

*Se o algif_aead já estiver carregado, é necessário reiniciar o sistema para que a lista negra tenha efeito total.

Efeitos colaterais: Aplicações que usam a interface AEAD do kernel via AF_ALG (incomum — a maioria usa OpenSSL em userspace) podem falhar. TLS padrão, criptografia de disco e ferramentas de VPN geralmente não são afetadas.

6.2 Correção Permanente — Atualização do Kernel

6.3 Clusters Kubernetes```bash

Check all node kernel versions

kubectl get nodes -o wide

Drain → update node kernel → uncordon (one node at a time)

kubectl drain --ignore-daemonsets --delete-emptydir-data

SSH into node and run kernel update

kubectl uncordon

Use node auto-upgraders (Karpenter, Managed Node Groups) ou rotação do pool de nós do cluster, quando disponível.

### 6.4 Verificação Pós-Patch```bash
# Re-run detection script
sudo ./detection/check_vulnerable.sh

# Quick manual verification
uname -r                          # confirm new kernel version
lsmod | grep algif_aead           # should be empty
cat /proc/crypto | grep authencesn  # should return nothing (or still listed but module blacklisted)

7. Ambiente de Laboratório

Um laboratório Docker Alpine mínimo é fornecido para testar ferramentas de detecção com segurança.```bash cd lab/ docker compose up -d docker exec -it cve-2026-31431-lab /bin/sh

Inside container:

/cve-2026-31431/detection/check_vulnerable.sh

> **Importante:** Os contêineres Docker compartilham o kernel do host. O laboratório testa o status de vulnerabilidade **do kernel do seu host**. Os resultados de vulnerabilidade refletem o sistema host real — isso é intencional para uma avaliação realista.

Para testes isolados com uma versão específica de kernel vulnerável, use uma VM dedicada com um kernel fixado. Consulte `lab/README.md` para orientações de configuração da VM.

---

## 8. Referências

| Recurso | Link |
|----------|------|
| Aviso NVD | https://nvd.nist.gov/vuln/detail/CVE-2026-31431 |
| Pesquisa Original | https://copy.fail |
| Artigo Técnico | https://xint.io/blog/copy-fail-linux-distributions |
| PoC Público | https://github.com/theori-io/copy-fail-CVE-2026-31431 |
| Catálogo KEV da CISA | https://www.cisa.gov/known-exploited-vulnerabilities-catalog |
| Correção do Kernel — Commit Revertido | `a664bf3d603d` / `fafe0fa2995a` |
| Commit Vulnerável | `72548b093ee3` |
| Aviso do Microsoft Defender | Blog de Inteligência de Ameaças do Microsoft Defender |

---

## Estrutura do Repositório```
cve-2026-31431/
├── README.md                          ← This document
├── exploit/
│   ├── README.md                      ← Technical exploit breakdown
│   └── poc.py                         ← Public PoC (theori-io, for reference)
├── detection/
│   ├── README.md                      ← Detection guide
│   ├── check_vulnerable.sh            ← Vulnerability & IoC detection script
│   └── yara/
│       ├── cve_2026_31431_base.yar    ← Detects known public PoC
│       └── cve_2026_31431_enhanced.yar ← Detects obfuscated/compiled variants
├── patch/
│   ├── README.md                      ← Remediation guide
│   └── patch.sh                       ← Automated patch/mitigation script
└── lab/
    ├── README.md                      ← Lab setup guide
    ├── Dockerfile                     ← Alpine-based lab container
    └── docker-compose.yml             ← Lab orchestration

Esta pesquisa é fornecida apenas para fins educacionais e de segurança defensiva. Todas as ferramentas são projetadas para ajudar defensores a detectar e corrigir o CVE-2026-31431 em sistemas que estão autorizados a proteger.

Repositório mantido por rippsec

Tamanho da escrita	4 bytes
Controle de offset	Sim — controlado pelo atacante via offset do splice
Alvo	Cache de páginas de qualquer arquivo legível
Marcação de página suja	Nenhuma
Modificação no disco	Nenhuma
Atualização de timestamp	Nenhuma
Entrada no log do kernel	Nenhuma (a menos que auditd esteja configurado)

Exploração para Escalação de Privilégios	T1068	Técnica principal
Abuso do Mecanismo de Controlo de Elevação: Setuid/Setgid	T1548.001	Sequestro de binário Setuid
Sequestro do Fluxo de Execução	T1574	Patch binário em memória
Remoção de Indicadores: Timestomp	T1070.006	Sem timestamps atualizados
Execução Indireta de Comandos	T1202	Binário com patch executa shell

Ubuntu / Debian	`apt-get update && apt-get upgrade linux-image-generic && reboot`
RHEL / CentOS / Rocky	`dnf update kernel && reboot`
Amazon Linux 2	`yum update kernel && reboot`
Amazon Linux 2023	`dnf update kernel && reboot`
SUSE / SLES	`zypper update kernel-default && reboot`
Arch Linux	`pacman -Syu linux && reboot`
Alpine Linux	`apk update && apk upgrade linux-lts && reboot`
Debian	`apt-get update && apt-get upgrade linux-image-amd64 && reboot`

CVE	CVE-2026-31431
Apelido	Copy Fail
CVSS v3.1	7.8 ALTO
Vetor de Ataque	Local
Privilégios Necessários	Baixos
Interação do Usuário	Nenhuma
Componente	`crypto/algif_aead.c` — template `authencesn`
Introduzida	2017 (commit `72548b093ee3`)
Divulgada	2026
Anos Silenciosa	~9 anos
CISA KEV	Sim
PoC Público	Sim (script Python autônomo de 732 bytes)

Mais Populares

cve-2026-31431

CVE-2026-31431 — "Copy Fail": Escalação de Privilégio Local no algif_aead do Kernel Linux