fpicker

fpicker é um conjunto de fuzzing baseado em Frida que oferece uma variedade de modos de fuzzing para fuzzing em processo, como um modo AFL++ ou um modo de rastreamento passivo. Deve funcionar em todas as plataformas suportadas pelo Frida.

• Instruções de Instalação
• Construção e Execução
• Criação de um Harness de Fuzzing
• Modos e Configuração

Algumas informações de contexto e os pensamentos e ideias por trás do fpicker podem ser encontrados em um post de blog que escrevi.

Fpicker é baseado em esforços anteriores em ToothPicker, que foi desenvolvido durante minha dissertação de mestrado. A maior parte do fpicker foi desenvolvida durante o horário de trabalho no meu empregador (ERNW).

Requisitos e Instalação

Requisitos para executar o fpicker:

• frida_compile para compilar o script do harness em um único arquivo JS
• O frida-core-devkit para a respectiva plataforma encontrado em Frida releases no GitHub.
  • Dependendo da plataforma que você deseja segmentar, armazene a biblioteca como libfrida-core-ios.a, libfrida-core-macos.a ou libfrida-core-linux.a.
  • O mesmo vale para os arquivos de cabeçalho (frida-core.h). Armazene-os como frida-core-linux.h ou frida-core-ios.h dependendo da plataforma.
  • O Makefile foi construído desta forma para que você possa compilar para diferentes sistemas no mesmo sistema (por exemplo, seu sistema host e o telefone).
  • Se você preferir usar uma versão específica, ajuste o Makefile de acordo.
  • Para atualizar para a versão mais recente, basta executar update_frida_version.sh antes de compilar.

Requerido apenas ao executar no modo AFL++:

• AFL++
  • no macOS:
    • Compile com CFLAGS="-DUSEMMAP=1".
  • no iOS:
    • Compile com CFLAGS="-DUSEMMAP=1 -DTARGET_OS_IOS".

Construção e Execução

O Fpicker pode ser compilado para macOS, iOS ou Linux. O Makefile atualmente suporta apenas a compilação para iOS no macOS, mas deve ser totalmente possível compilar o fpicker usando um toolchain do iOS no Linux.

Dependendo do alvo desejado, execute:

make fpicker-macos
make fpicker-ios
make fpicker-linux

para compilar o fpicker.

Após compilar o fpicker, o harness de fuzzing precisa ser compilado em seguida:

Veja a pasta de exemplos para diferentes casos de fuzzing de exemplo. A abordagem geral é a seguinte:

• Crie um harness personalizado para o alvo (por exemplo, examples/test/test.js) (veja aqui para mais informações sobre harnesses)
• Compile o harness personalizado usando o frida-compile frida-compile test.js -o harness.js

Agora o fpicker pode começar a fazer fuzzing. O comando exato depende muito da configuração e da montagem. A seguir, alguns casos de exemplo são fornecidos. Eles correspondem principalmente aos exemplos na pasta de exemplos.

• Execute o fpicker como proxy AFL++ anexando a um processo alvo fuzzing uma função específica em processo:

afl-fuzz -i examples/test-network/in -o ./examples/test-network/out -- \\
    ./fpicker --fuzzer-mode afl -e attach -p test-network -f ./examples/test-network/harness.js

• Execute o fpicker no modo autônomo anexando a um servidor e executando um programa cliente para enviar a entrada de fuzzing:

./fpicker --fuzzer-mode standalone -e attach -p server-process -f harness.js --input-mode cmd \\
    --command "./client-send @@" -i indir -o outdir

• Execute o fpicker no modo autônomo anexando a um servidor, fuzzing em processo com um comando mutator personalizado:

./fpicker --fuzzer-mode active --communication-mode shm -e attach -p server-process -f harness.js \\
    -i indir -o outdir --standalone-mutator cmd --mutator-command "radamsa"

• Execute o fpicker no modo passivo anexando a um servidor coletando cobertura e payloads:

./fpicker --fuzzer-mode passive --communication-mode send -e attach -p server-process -o outdir -f harness.js

• Execute o fpicker no modo autônomo anexando a um processo em execução em um dispositivo remoto, fuzzing em processo com um comando mutator personalizado:

./fpicker --fuzzer-mode active -e attach -p test -D remote -o examples/test/out/ -i examples/test/in/ \\
    -f fuzzer-agent.js --standalone-mutator cmd --mutator-command "radamsa"

Criação de um Harness de Fuzzing

Cada alvo requer seu próprio harness de fuzzing. A parte mais importante deste harness é definir a função de entrada do Stalker do Frida, que efetivamente determina em que ponto a instrumentação é inserida. No modo in-process isso é simples. A função geralmente seria a que é chamada em cada iteração de fuzzing. No entanto, poderia ser uma diferente.

Uma implementação mínima de harness (no modo command) poderia ser esta:

// Import the fuzzer base class
const Fuzzer = require("harness/fuzzer.js");

// The custom fuzzer needs to subclass the Fuzzer class to work properly
class TestFuzzer extends Fuzzer.Fuzzer {
    constructor() {
        // The constructor needs to specify the address of the targeted function and a NativeFunction
        // object that can later be called by the fuzzer.

        const FUZZ_FUNCTION_ADDR = Module.getExportByName(null, "FUZZ_FUNCTION");
        const FUZZ_FUNCTION = new NativeFunction(
            FUZZ_FUNCTION_ADDR,
            "void", ["pointer", "int64"], {
        });

        super("test", FUZZ_FUNCTION_ADDR, FUZZ_FUNCTION);
    }
}

const f = new TestFuzzer();
exports.fuzzer = f;

Este harness configura a instrumentação para seguir a função FUZZ_FUNCTION. A instrumentação começará quando esta função for inserida e para quando a função retornar. Esta função deve ser escolhida cuidadosamente, pois é cara e quanto mais partes (potencialmente não importantes) do processo forem instrumentadas, mais lento o fuzzer fica. Claro, isso é uma consideração entre velocidade e cobertura pretendida. Além disso, o fuzzer atualmente suporta apenas funções que são inseridas apenas uma vez durante uma iteração de fuzzing, ou seja, a função não deve ser chamada mais de uma vez durante um caso de fuzzing, caso contrário as informações de cobertura podem se tornar não confiáveis.

Quando o modo in-process é usado, outra função é necessária no script do fuzzer. O método fuzz. Ele será chamado em cada iteração. Será chamado com dois parâmetros, um ponteiro para um buffer e o comprimento do buffer. Nossa função alvo exemplar recebe dois parâmetros, um ponteiro para um buffer e seu comprimento. Assim, podemos simplesmente passar os parâmetros que recebemos no método fuzz.

fuzz(payload, len) {
    this.target_function(payload, parseInt(len));
}