CopyFail Guard

   ______                 ______      _ __   ______                     __
  / ____/___  ____  __  _/ ____/___ _(_) /  / ____/_  ______ __________/ /
 / /   / __ \/ __ \/ / / / /_  / __ `/ / /  / / __/ / / / __ `/ ___/ __  /
/ /___/ /_/ / /_/ / /_/ / __/ / /_/ / / /  / /_/ / /_/ / /_/ / /  / /_/ /
\____/\____/ .___/\__, /_/    \__,_/_/_/   \____/\__,_/\__,_/_/   \__,_/
          /_/    /____/

Avaliação e mitigação rápida e auditável da exposição Linux para CVE-2026-31431 “Copy Fail” enquanto os kernels são corrigidos.

CopyFail Guard é uma ferramenta de operações defensivas para administradores Linux, engenheiros DevSecOps, equipes de plataforma e respondedores de incidentes. Ela ajuda a reduzir a exposição ao problema do Linux algif_aead / AF_ALG ao:

avaliar a exposição com segurança, sem código de exploração
verificar se algif_aead está disponível, carregado, embutido ou já bloqueado
instalar um bloqueio persistente via modprobe.d e descarregar o módulo quando seguro
adicionar uma regra de negação AF_ALG aos perfis seccomp do Docker, Podman e Kubernetes
validar a acessibilidade do AF_ALG sem distribuir código de exploração

Correção definitiva: instale o kernel corrigido do seu fornecedor e reinicie.
Esta ferramenta cobre a lacuna operacional entre a divulgação e a correção completa da frota.

Por que os operadores podem confiar nela

Sem código de exploração: verifica a exposição e a acessibilidade do AF_ALG sem gravações no cache de páginas, splice, alterações no setuid, escalonamento de privilégios ou sondagens destrutivas.
Alteração auditável no host: a mitigação no host escreve um arquivo gerenciado, /etc/modprobe.d/99-copyfail-guard.conf, e a reversão remove apenas esse arquivo.
Seccomp preservando a linha de base: seccomp-patch adiciona uma negação de AF_ALG a um perfil seccomp existente do Docker/Podman/Kubernetes, em vez de substituir sua proteção de tempo de execução.
Pronto para automação: assess --json e códigos de saída documentados suportam varreduras de frota, captura em SIEM e evidências para gerenciamento de mudanças.
Coberto por CI: sintaxe shell, geração de perfil seccomp, saída JSON e testes de fumaça são executados em contêineres de distribuições Linux comuns.

Caminho de 30 segundos

Se você está em um host Linux e precisa de uma resposta rápida:

git clone --depth 1 https://github.com/juliosuas/copyfail-guard.git
cd copyfail-guard
sudo ./bin/copyfail-guard.sh doctor
sudo ./bin/copyfail-guard.sh assess

Se o veredito for exposto e algif_aead for modular:

sudo ./bin/copyfail-guard.sh mitigate --yes
sudo ./bin/copyfail-guard.sh verify

Para instalações repetíveis, fixe uma tag de release:

git clone --branch v0.3.0 --depth 1 https://github.com/juliosuas/copyfail-guard.git

Substitua v0.3.0 pela última release marcada quando novas versões estiverem disponíveis.

Estou afetado?

Execute primeiro a verificação segura de exposição:

sudo ./bin/copyfail-guard.sh assess

Como interpretar o resultado:

Se você executa contêineres não confiáveis, jobs de CI, sandboxes ou cargas de trabalho multi-usuário, teste também se a criação de soquetes AF_ALG está bloqueada dentro desse ambiente de execução:

python3 tools/afalg-socket-test.py

PERMITTED não prova exploração bem-sucedida, mas prova que a API de criptografia do espaço do usuário relevante está acessível. Para operações defensivas, isso é motivo suficiente para aplicar a mitigação enquanto confirma a implantação do kernel corrigido.

Isso prova a vulnerabilidade?

Nenhum proof-of-concept destrutivo está incluído. Isso é uma característica, não uma lacuna.

Um exploit real do Copy Fail precisaria validar o impacto na memória do kernel/cache de páginas ou escalonamento de privilégios. Distribuir isso em um repositório público de mitigação tornaria o projeto menos seguro e menos implantável em produção.

O CopyFail Guard prova o que os operadores podem agir com segurança:

se o componente de risco está disponível, carregado, embutido ou bloqueado
se a criação de soquetes AF_ALG é permitida em um ambiente de execução alvo
se o host tem uma mitigação provisória em vigor
se a ação restante necessária é descarregar, reiniciar, aplicar seccomp ou corrigir o fornecedor

Para o status final da vulnerabilidade, combine esta ferramenta com o inventário de pacotes/avisos do fornecedor e evidências de reinicialização.

Modelo de resolução

CopyFail Guard é mitigação, não cura. Reduz a exposição e verifica controles provisórios. A correção duradoura continua sendo o kernel corrigido pelo fornecedor mais a reinicialização.

A ferramenta é intencionalmente clonável e executável para resposta a incidentes: nenhum compilador, cabeçalhos de kernel, código de exploração ou gerenciador de pacotes de terceiros é necessário para o fluxo de trabalho principal do host. python3 é necessário para saída --json, seccomp-patch e o teste de soquete AF_ALG não-exploratório.

Início rápido

Clone e execute:

git clone https://github.com/juliosuas/copyfail-guard.git
cd copyfail-guard
chmod +x bin/copyfail-guard.sh

sudo ./bin/copyfail-guard.sh doctor
sudo ./bin/copyfail-guard.sh assess
sudo ./bin/copyfail-guard.sh mitigate --yes
sudo ./bin/copyfail-guard.sh verify

Instalação opcional no sistema:

git clone https://github.com/juliosuas/copyfail-guard.git
cd copyfail-guard
sudo ./scripts/install.sh
sudo copyfail-guard status

O instalador suporta fixar a origem e o destino para implantações controladas:

sudo env COPYFAIL_GUARD_REF=v0.3.0 ./scripts/install.sh

Use a última release marcada para COPYFAIL_GUARD_REF quando novas versões estiverem disponíveis.

Proteção de contêiner / CI:

./bin/copyfail-guard.sh seccomp-patch docker-default.json copyfail-seccomp.json
docker run --security-opt seccomp=./copyfail-seccomp.json IMAGEM

Valide que o AF_ALG está bloqueado dentro de um contêiner protegido:

docker run --rm \
  --security-opt seccomp=./copyfail-seccomp.json \
  -v "$PWD/tools:/tools:ro" \
  python:3.12-alpine \
  python /tools/afalg-socket-test.py

Resultado esperado em ambiente protegido:

BLOCKED: socket(AF_ALG) denied by policy (...)

Veja Exemplos de saída para vereditos esperados, formato JSON e resultados de validação em contêiner.

Por que isso é importante

Copy Fail é uma escalada de privilégio local do kernel Linux no componente algif_aead da API de criptografia do espaço do usuário AF_ALG. Advisories públicos descrevem uma primitiva de gravação no cache de páginas acessível por usuários locais não privilegiados e especialmente perigosa em sistemas com kernel compartilhado: nós Kubernetes, runners CI/CD, hosts multi-inquilino, sandboxes de agentes e máquinas de desenvolvedores.

A correção correta é uma atualização de kernel do fornecedor contendo o revert/correção upstream e uma reinicialização no kernel corrigido. CopyFail Guard é um auxiliar de operações defensivas para a janela antes que essa reinicialização seja concluída em toda a frota.

O que a ferramenta faz

Requisitos de instalação

Comandos principais do host:

Linux
bash
Ferramentas kmod: modinfo, modprobe, lsmod, rmmod onde disponíveis
grep, awk, mktemp, install

Ferramentas opcionais de visibilidade:

lsof ou ss para verificações de consumidores AF_ALG

Correção de perfil seccomp:

python3 é necessário para --json, seccomp-patch e tools/afalg-socket-test.py

Nenhum código de exploração, compilador, cabeçalhos de kernel ou pacotes de terceiros são necessários.

Avaliação segura vs proof-of-concept

CopyFail Guard não inclui um proof-of-concept de exploit. Isso é intencional. Veja Isso prova a vulnerabilidade?.

Em vez disso, assess realiza uma verificação operacional segura:

detecta se algif_aead parece disponível, carregado, embutido ou bloqueado
distingue “mitigado provisoriamente” de “realmente resolvido”
recomenda mitigação do host, seccomp ou correção/reinicialização
retorna códigos de saída para automação de frota

JSON para automação:

sudo ./bin/copyfail-guard.sh assess --json
./bin/copyfail-guard.sh doctor --json

Códigos de saída:

Detalhes da mitigação do host

mitigate escreve:

/etc/modprobe.d/99-copyfail-guard.conf

com:

# Managed by CopyFail Guard for CVE-2026-31431
install algif_aead /bin/false
blacklist algif_aead

Então tenta:

sudo rmmod algif_aead

Se o módulo estiver em uso no momento, rmmod pode falhar. Nesse caso, o bloqueio persistente permanece instalado; pare os consumidores AF_ALG ou reinicie após aplicar a mitigação.

O script se recusa a sobrescrever um link simbólico no caminho do modprobe gerenciado e escreve o arquivo atomicamente com permissões seguras.

Proteção de contêiner e CI

Para cargas de trabalho não confiáveis, bloqueie a criação de soquetes AF_ALG com seccomp mesmo enquanto corrige hosts.

Caminho recomendado: corrija sua linha de base seccomp existente em vez de substituí-la:

./bin/copyfail-guard.sh seccomp-patch docker-default.json copyfail-seccomp.json

Use com Docker:

docker run --security-opt seccomp=./copyfail-seccomp.json IMAGEM

Use com Podman:

podman run --security-opt seccomp=./copyfail-seccomp.json IMAGEM

Caminho apenas para emergência se você não tiver um perfil de linha de base:

./bin/copyfail-guard.sh seccomp-docker ./copyfail-afalg-seccomp.json

O perfil de emergência gerado bloqueia AF_ALG, mas permite chamadas de sistema. Trate-o como uma solução temporária direcionada, não como substituto da proteção seccomp padrão normal do Docker.

Para Kubernetes, coloque o perfil sob a raiz seccomp do kubelet, comumente:

/var/lib/kubelet/seccomp/profiles/copyfail-seccomp.json

Então referencie-o com:

securityContext:
  seccompProfile:
    type: Localhost
    localhostProfile: profiles/copyfail-seccomp.json

Veja examples/kubernetes-seccomp-pod.yaml.

Validação segura

Este projeto inclui um teste de acessibilidade AF_ALG não-exploratório:

python3 tools/afalg-socket-test.py

Ele apenas tenta criar e fechar um soquete AF_ALG. Não vincula operações de criptografia, chama splice, toca em binários setuid, corrompe cache de páginas ou tenta escalonar privilégios.

Resultados:

BLOCKED significa que a política negou AF_ALG para esse processo.
PERMITTED significa que a criação de soquete AF_ALG ainda é permitida para esse processo.
UNSUPPORTED significa que AF_ALG não está disponível nesse ambiente de execução.

Validação da comunidade

CopyFail Guard precisa de relatórios de compatibilidade do mundo real de hosts Linux, ambientes de execução de contêiner, runners CI e nós Kubernetes. Se você puder testá-lo com segurança, abra um issue de Relatório de compatibilidade com saída sanitizada de doctor, assess --json, verify ou o teste de soquete AF_ALG.

Relatórios úteis ajudam a responder:

quais combinações de distro/kernel/ambiente de execução são fáceis de mitigar
onde algif_aead está embutido e requer apenas correção/reinicialização
quais linhas de base seccomp precisam de notas específicas de ambiente de execução
se a documentação é clara o suficiente para uso em resposta a incidentes

Veja Guia de validação da comunidade.

Comandos

copyfail-guard assess                 Avaliação segura de exposição, sem tentativa de exploit
copyfail-guard status                 Inspecionar indicadores de exposição do host
copyfail-guard doctor                 Verificar dependências e prontidão do ambiente de execução
copyfail-guard mitigate               Desabilitar algif_aead persistentemente e descarregá-lo
copyfail-guard verify                 Verificar se a mitigação do host está ativa
copyfail-guard rollback               Remover a mitigação modprobe do CopyFail Guard
copyfail-guard seccomp-docker [FILE]  Gerar perfil de negação AF_ALG de emergência
copyfail-guard seccomp-patch BASE OUT Corrigir perfil seccomp existente com segurança
copyfail-guard k8s-example            Imprimir exemplo seccomp do Kubernetes

Flags podem ser colocadas antes ou depois do comando:

--dry-run      Mostrar mudanças planejadas sem escrever arquivos ou descarregar módulos
--yes          Confirmação não interativa
--no-logo      Desabilitar banner ASCII
--json         Emitir JSON para comandos suportados: assess, doctor

O que não deve quebrar

Em configurações típicas, desabilitar algif_aead não deve afetar:

LUKS / dm-crypt
SSH
OpenSSL, GnuTLS, builds padrão do NSS
kTLS / TLS no kernel
IPsec / XFRM
consumidores normais de criptografia no kernel

Pode afetar aplicações explicitamente configuradas para usar o engine AF_ALG ou aplicações que criam soquetes AF_ALG diretamente. Verifique primeiro:

sudo lsof | grep AF_ALG || true
ss -xa | grep -i alg || true

Documentação do operador

Maturidade do projeto

Escopo atual: avaliação defensiva, mitigação do host para algif_aead modular, proteção seccomp para cargas de trabalho não confiáveis e reversão.
Usuário suportado: operadores confortáveis com proteção de host Linux e contêiner.
Estilo de release: releases marcadas, entradas no changelog, testes de fumaça no GitHub Actions e templates de issue para relatórios reproduzíveis.
Sinal da comunidade: relatórios de compatibilidade são o sinal de confiança mais forte; evidências de campo podem se tornar documentação, testes e exemplos.
Promessa de estabilidade: evitar comportamento de exploit, manter escritas no host restritas, documentar semântica de código de saída e preservar linhas de base seccomp existentes.

Limitações

CopyFail Guard não:

corrige seu kernel
prova se sua compilação exata do kernel é explorável
distribui código de exploit
protege contra usuários root já comprometidos
substitui EDR, inventário de frota, advisories do fornecedor ou planejamento de reinicialização

A mitigação do módulo do host funciona para algif_aead modular. Se algif_aead estiver embutido no seu kernel, modprobe.d e rmmod não podem desabilitá-lo; correção/reinicialização é obrigatória e seccomp deve ser usado para cargas de trabalho não confiáveis enquanto corrige.

Seccomp protege apenas cargas de trabalho iniciadas com o perfil. Contêineres ou pods em execução existentes devem ser reiniciados com o perfil protegido.

Reversão

sudo ./bin/copyfail-guard.sh rollback --yes

A reversão remove apenas o arquivo gerenciado por esta ferramenta. Não recarrega o módulo. Reinicie ou manualmente modprobe algif_aead apenas se você explicitamente precisar dele e tiver aceitado o risco ou corrigido o kernel.

FAQ

Isso substitui a correção?

Não. Corrigir e reiniciar continuam sendo a correção definitiva.

Isso testa exploração?

Não. O projeto evita intencionalmente comportamento de exploit. tools/afalg-socket-test.py apenas verifica se a criação de soquete AF_ALG está acessível.

Por que bloquear AF_ALG em contêineres mesmo após a mitigação do host?

Defesa em profundidade. Cargas de trabalho de contêiner e CI são lugares comuns onde código não confiável é executado em um kernel compartilhado. Seccomp torna o primeiro passo dessa classe de ataque inacessível para essa carga de trabalho.

Por que corrigir um perfil seccomp existente em vez de gerar um novo?

Porque os perfis padrão dos ambientes de execução contêm muitas decisões de proteção. Substituí-los por um perfil mínimo de emergência pode remover acidentalmente proteções. seccomp-patch mantém sua linha de base e adiciona a negação AF_ALG.

Posso usar isso em uma frota?

Sim. Comece com doctor e assess --json, prepare a mitigação em uma pequena amostra Linux, depois implemente a mitigação do host e as alterações de perfil seccomp separadamente. Veja Guia de implantação em frota.

Referências

Autor

Criado por Julio César Suástegui Calderón.

Engenharia de segurança, sistemas Linux e automação defensiva prática.

Licença

MIT

`EXPOSED_*`	`algif_aead` / AF_ALG parece acessível ou carregável	Mitigue agora, depois corrija e reinicie
`PARTIALLY_MITIGATED_*`	Um bloqueio existe, mas o módulo carregado ou o estado de reinicialização ainda importa	Reinicie ou descarregue com segurança, depois verifique
`INTERIM_MITIGATED_*`	Mitigação local está ativa	Mantenha-a, mas ainda corrija e reinicie
`LOW_OBVIOUS_EXPOSURE_*`	Verificações locais não encontraram exposição óbvia a `algif_aead`	Confirme o status do patch do fornecedor de qualquer forma

Avaliação segura	`assess`	Fornecer um veredito de exposição não-exploratório, próximas ações e código de saída amigável para automação
Verificação de dependências	`doctor`	Verificar ferramentas obrigatórias/opcionais e explicar limitações de tempo de execução
Inspeção do host	`status`	Mostrar SO/kernel, disponibilidade do módulo, estado carregado, aviso de módulo embutido, bloqueio modprobe e consumidores óbvios de AF_ALG
Mitigação do host	`mitigate`	Escrever `/etc/modprobe.d/99-copyfail-guard.conf` e tentar descarregar `algif_aead`
Verificação	`verify`	Falhar claramente se o módulo estiver carregado, embutido ou não bloqueado
Reversão	`rollback`	Remover apenas o arquivo modprobe gerenciado pelo CopyFail Guard
Contêineres	`seccomp-patch`	Corrigir um perfil seccomp existente para negar `socket(AF_ALG, ...)` preservando o uso normal de soquetes
Perfil de emergência	`seccomp-docker`	Gerar um perfil de negação AF_ALG direcionado para uso emergencial
Kubernetes	`k8s-example`	Imprimir um exemplo de pod seccomp Localhost

`0`	Baixa exposição óbvia pelas verificações locais
`1`	Mitigação provisória ativa, correção/reinicialização ainda necessária
`10`	Exposto/mitigação disponível
`11`	Parcialmente mitigado; reinicialização ou descarregamento necessário
`12`	Caminho de módulo embutido; correção/reinicialização obrigatória
`20`	Estado de avaliação desconhecido

copyfail-guard

Mais Populares