Snapchange

Fuzzing leve de um snapshot de memória usando KVM

O Snapchange oferece a capacidade de carregar um despejo de memória bruto e o estado dos registradores em uma máquina virtual (VM) KVM para execução. Em um ponto da execução, essa VM pode ser redefinida para seu estado inicial redefinindo as páginas sujas encontradas pelo KVM ou páginas sujas manualmente por um fuzzer.

Links rápidos:

• O Cookbook fornece exemplos de utilitários de linha de comando fuzz, trace, coverage, minimize e project
• Obtendo um snapshot com QEMU
• Arquitetura
• Ciclo de vida do fuzzer

Tutoriais

• Tutorial 1 - Uso básico
• Tutorial 2 - LibTIFF com ASAN
• Tutorial 3 - FFmpeg com mutador personalizado
• Tutorial 4 - Fuzzer de syscalls
• Tutorial 5 - Redqueen

Aspirações

• Reproduzir um snapshot de memória física e estado de registradores usando KVM
• Execução paralela em múltiplos núcleos
• Fornecer um conjunto de recursos de introspecção para a VM convidada
• Estado de cobertura em tempo real via cobertura por breakpoints
• Métricas de desempenho em tempo real dos componentes do fuzzer
• Fornecer utilitários de fuzzing como rastreamento de depuração passo a passo, minimização de casos de teste e cobertura de casos de teste
• Abstração de entrada para permitir estratégias personalizadas de mutação e geração

Exemplo:

Crie um fuzzer de alvo a partir do modelo de fuzzer

$ cp -r -L fuzzer_template your_new_fuzzer

Modifique your_new_fuzzer/create_snapshot.sh para obter um snapshot do seu alvo

Atualize src/fuzzer.rs para injetar dados mutados na VM convidada

#[derive(Default)]
pub struct TemplateFuzzer;

impl Fuzzer for TemplateFuzzer {
    // The type of Input being fuzzed. Used to know how to generate and mutate useful inputs.
    type Input = Vec<u8>;
    // The starting address of the snapshot
    const START_ADDRESS: u64 = 0x402363;
    // The maximum length of mutated input to generate
    const MAX_INPUT_LENGTH: usize = 100;

    fn set_input(&mut self, input: &Self::Input, fuzzvm: &mut FuzzVm<Self>) -> Result<()> {
        // Write the mutated input into the data buffer in the guest VM
        fuzzvm.write_bytes_dirty(VirtAddr(0x402004), CR3, &input)?;
        Ok(())
    }

    fn reset_breakpoints(&self) -> Option<&[BreakpointLookup]> {
        Some(&[
            // Reset when the VM hits example1!main+0x123
            BreakpointLookup::SymbolOffset("example1!main", 0x123)
        ])
    }
}

Comece o fuzzing com 16 núcleos

$ cargo run -r -- fuzz -c 16

Implementação

Breve uso dos termos para este README:

• Hypervisor: O código agnóstico de alvo que executa o snapshot no KVM
• Fuzzer: O código específico do alvo usado para modificar e monitorar o convidado para um caso de fuzzing específico do alvo

O hypervisor começa mapeando o arquivo de memória física para cada núcleo solicitado. Dessa forma, cada núcleo tem sua própria cópia exclusiva da memória. O hypervisor então cria a VM convidada do KVM e fornece a ela essa memória de apoio. O estado dos registradores dessa VM convidada é então inicializado com o estado de registradores fornecido e a execução da VM convidada é iniciada. O hypervisor aguarda até que a VM convidada saia. Cada saída é tratada pelo hypervisor e algumas são passadas ao fuzzer para mutação, modificação ou introspecção específicas do alvo. Se o manipulador da saída indicar que a VM convidada deve ser redefinida, o hypervisor sai do loop de execução, redefine a VM convidada para o estado original do snapshot e reinicia o loop de execução novamente.

A cobertura do convidado é gerada usando breakpoints de cobertura. Um arquivo separado com uma lista de endereços para breakpoint pode ser fornecido ao hypervisor. Se qualquer um desses endereços for atingido, o endereço será adicionado ao banco de dados de cobertura e a instrução para esse endereço será restaurada. Dessa forma, o breakpoint não será acionado novamente.

Diretório do projeto

O Snapchange utiliza diretórios de projeto específicos do alvo para configuração. Este diretório é onde arquivos e diretórios de entrada e saída são colocados. As seguintes extensões/diretórios de arquivo são usados como entradas:

• .physmem - O arquivo que contém o arquivo de memória física bruta
• Arquivo de registradores (um dos seguintes)
  • .regs - Arquivo JSON de registradores contendo o estado dos registradores
  • .qemuregs - Saída de info registers do qemu

A lista completa de arquivos e seus usos no diretório do projeto pode ser encontrada aqui

Rastreamento de depuração

Um exemplo completo do rastreamento de depuração passo a passo pode ser encontrado aqui.

ITERATION 604 0x00007ffff7ecb0d5 0x11115000 | libc-2.31.so!__GI___getpid+0x5 (0x7ffff7ecb0d5)              
    syscall 
    [0f, 05]
ITERATION 605 0xffffffff83a00000 0x11115000 | entry_SYSCALL_64+0x0 (0xffffffff83a00000)                    
    swapgs 
    [0f, 01, f8]
ITERATION 606 0xffffffff83a00003 0x11115000 | entry_SYSCALL_64+0x3 (0xffffffff83a00003)                    
    mov qword ptr gs:[0xa014], rsp 
    [None:0x0+0xa014=0xa014]] 
    RSP:0x7fffffffeb78 -> example1!main+0x19 (0x55555555514e)-> 0xff8458b48f44589
    [65, 48, 89, 24, 25, 14, a0, 00, 00]
ITERATION 607 0xffffffff83a0000c 0x11115000 | entry_SYSCALL_64+0xc (0xffffffff83a0000c)                    
    nop 
    [66, 90]
ITERATION 608 0xffffffff83a0000e 0x11115000 | entry_SYSCALL_64+0xe (0xffffffff83a0000e)                    
    mov rsp, cr3 
    RSP:0x7fffffffeb78 -> example1!main+0x19 (0x55555555514e) -> 0xff8458b48f44589
    CR3:0x11115000
    [0f, 20, dc]

Snapshots

Informações sobre como obter um snapshot via VirtualBox ou QEMU estão abaixo:

• VirtualBox
• QEMU

Os exemplos incluem um script make_example.sh (como o exemplo 1) que cria um snapshot completo do zero. Esses exemplos podem ser usados como modelo para outros alvos para snapshots reproduzíveis.

Documentação e clippy

make all
cargo doc --open

Por onde começar a ler?

O HACKING fornece alguns locais de nível mais alto na base de código para começar a entender o sistema.

Segurança