Resumo Técnico: KCOV-DATAFLOW

1. Declaração do Problema

Fuzzers de kernel guiados por cobertura, como o syzkaller, dependem exclusivamente de cobertura de arestas (trace-pc) como seu sinal de feedback. Esta abordagem sofre de um "gap semântico" fundamental: ela identifica quais blocos básicos foram executados, mas não com quais valores. Consequentemente, duas invocações de uma função (por exemplo, copy_from_user() ou vfs_open()) com valores de argumentos diferentes percorrem arestas de fluxo de controle idênticas, embora possuam implicações de segurança vastamente diferentes.

Esta limitação leva à saturação de cobertura em subsistemas de estado (ex: ksmbd, io_uring, binder) onde o comportamento crítico de segurança depende de valores de argumentos em tempo de execução, e não da topologia do fluxo de controle. Alternativas existentes falham em abordar isso em escala:

• Rastreamento dinâmico (ftrace/kprobes): Impõe um alto overhead por função, inadequado para fuzzing contínuo.
• Anotação manual (IJON): Inviável para os mais de 30 milhões de linhas de código do kernel Linux.
• Cobertura sensível ao contexto (Angora, CollAFL): Explode em complexidade com despacho polimórfico.
• DataFlowSanitizer: Incorre em 10–100× de overhead, tornando-o inutilizável para fuzzing de kernel.
• Análise pós-morte (drgn/vmcore): Falha em capturar argumentos de funções Rust sob otimização -O2 devido à elisão de variáveis DWARF.

2. Metodologia: KCOV-DATAFLOW

O artigo apresenta o KCOV-DATAFLOW, um framework de instrumentação baseado em LLVM que estende o KCOV do Linux para capturar tuplas de fluxo de dados (argumentos de função e valores de retorno) em fronteiras de função. O sistema opera sem anotação de nível de código-fonte e é projetado para operação contínua de baixo overhead.

Arquitetura

O sistema consiste em três camadas:

1. Instrumentação em Tempo de Compilação (LLVM Pass):

   • Estende o framework SanitizerCoverage existente.
   • Na entrada e no retorno da função, o pass emite callbacks capturando tuplas estruturadas: <PC, arg_idx, arg_size, ptr, offsets[]>.
   • Decomposição de Estruturas: Decompõe automaticamente tipos compostos (structs/unions) percorrendo metadados DICompositeType do DWARF. Ele gera um array de constantes em tempo de compilação de offsets e tamanhos de campos, permitindo que o tempo de execução extraia valores de campos específicos sem modificação do código-fonte.
   • Suporte a Rust: Fornece dois caminhos:
     • Pós-compilação: Converte o IR do Rust para formato de texto (.ll), aplica o pass e recompila.
     • Nativo: Constrói o rustc contra um LLVM 23 customizado contendo o pass, permitindo instrumentação direta via RFLAGS.

2. Transporte de Runtime do Kernel:

   • Implementa um buffer circular livre de travas (lock-free), por tarefa, armazenado no task_struct.
   • Segurança: Utiliza READ_ONCE/WRITE_ONCE para escritas atômicas. Inclui uma guarda in_task() para rejeitar chamadas de contextos de interrupção, softirq ou NMI, prevenindo problemas de reentrada.
   • Segurança de Memória: Utiliza copy_from_kernel_nofault() para desreferenciar ponteiros de forma segura, lidando graciosamente com memória envenenada pelo KASAN, páginas não mapeadas e valores ERR_PTR sem causar crash.
   • Interface: Expõe uma interface dedicada de debugfs (/sys/kernel/debug/kcov_dataflow) independente do KCOV padrão, garantindo zero interferência na operação normal do syzkaller.

3. Consumidor em Espaço do Usuário:

   • Fuzzers ou analistas mapeiam o buffer via mmap() para leitura zero-copy.
   • Os registros incluem argumentos de entrada e valores de retorno, permitindo a verificação offline de pré/pós-condições.

3. Principais Contribuições

• Extensão do LLVM SanitizerCoverage: Um pass de compilador que captura argumentos de função e valores de retorno com expansão automática de campos de struct via metadados DICompositeType, exigindo zero anotação de código-fonte.
• Transporte Livre de Travas por Tarefa: Um mecanismo residente no kernel que opera com segurança em contexto de processo com rejeição explícita de interrupção, evitando interferência com a infraestrutura existente de KCOV ou syzkaller.
• Instrumentação Rust: Os primeiros métodos de runtime para capturar argumentos de função Rust sob otimização -O2, abordando a falha de análise de drgn e vmcore em código Rust otimizado.
• Validação Empírica: Demonstrado em cinco classes de vulnerabilidades (OOB, UAF, Double-Free, cadeias profundas e módulos Rust) mostrando que o contexto de fluxo de dados de fronteira fornece informações indisponíveis através de qualquer combinação de ferramentas existentes (cobertura + sanitizers + debuggers pós-morte).

4. Resultados e Avaliação

O sistema foi avaliado no Linux-next 7.1.0-rc6 com KASAN e Rust habilitados, rodando em um ambiente QEMU/KVM.

• Corretude: A ferramenta capturou corretamente os valores de pré-corrupção (ENTRY) e pós-corrupção (RET) para todos os casos de teste, correspondendo ao ground truth do printk. Capturou com sucesso violações de contrato FFI de Rust e expansões de campos de struct.
• Ganho de Informação: Diferente do KASAN (que reporta o endereço da violação, mas não o argumento específico) ou do drgn (que falha em Rust otimizado), o KCOV-DATAFLOW identifica o argumento e o campo exatos responsáveis pela corrupção, mesmo em módulos Rust.
• Overhead de Desempenho:
  • Custo por chamada: ~27 ns por callback individual.
  • Overhead de Gravação: +8,3% de latência quando a gravação está ativa.
  • Instrumentação Global (Sem Gravação): Quando todos os objetos do kernel são instrumentados mas a gravação está desativada, a latência de syscall aumenta em +133% e o tempo de boot em +71%. A seção .data aumenta em 44% devido aos arrays de offset por função.
  • Comparação: O overhead situa-se na faixa de um único sanitizer (ex: KASAN) e é significativamente menor que o KMSAN. Os autores observam que a instrumentação global é adequada para sessões direcionadas, enquanto a instrumentação por módulo é recomendada para fuzzing contínuo.

5. Significância e Alegações

O artigo afirma que o KCOV-DATAFLOW preenche o gap semântico entre o fuzzing guiado por cobertura e a análise de fluxo de dados para kernels de SO. Sua significância reside em:

1. Quebrar a Saturação de Cobertura: Ao fornecer feedback consciente de valores, ele permite que os fuzzers distingam entre caminhos de execução que diferem apenas em valores de argumentos, permitindo a orientação de mutação para transições de estado dependentes de valor que a cobertura de aresta perde.
2. Análise de Causa Raiz Determinística: Fornece aos analistas de segurança registros determinísticos de argumentos para triagem sem o overhead de printk ou kprobes e, crucialmente, funciona em módulos de kernel Rust onde outras ferramentas falham.
3. Verificação de Contrato em Tempo de Execução: Permite uma nova forma de "auditoria originada em runtime", onde os registros capturados são usados para verificar contratos de pré/pós-condição (ex: consistência de campo de struct) contra especificações formais. Isso permite a detecção de bugs "silenciosos" (erros de lógica sem crash) que a análise estática e os sanitizers perdem.
4. Reprodutibilidade: O sistema gera artefatos determinísticos (tuplas de PC, args, ret) que permitem que qualquer parte reproduza e verifique independentemente as descobertas de segurança, mudando o fluxo de trabalho de revisão de código especulativa para análise baseada em evidências.

Os autores enfatizam que, embora a ferramenta forneça evidências de potenciais violações (ex: valores fora de limites ou quebras de contrato), a determinação final de se um comportamento constitui um bug requer julgamento humano e confirmação do mantenedor, conforme demonstrado pela retratação de rótulos iniciais de severidade em descobertas específicas de Binder após revisão dos mantenedores.