Nelson

Encontrando vulnerabilidades através de força bruta burra

Inspirado por uma palestra de Nicholas Carlini e pelo Ralph loop, Nelson é uma ferramenta para iterar sobre cada arquivo em um projeto, solicitando que um agente procure por vulnerabilidades. Ele possui um modo de varredura, semelhante ao loop bash de Carlini, onde pede ao modelo para encontrar qualquer vulnerabilidade em um arquivo ou diretório de arquivos; um modo de revisão, onde um modelo (geralmente mais inteligente) reexamina cada vulnerabilidade reportada e decide se vale a pena escalar para um revisor humano; e uma etapa de desduplicação entre eles, para que o mesmo bug encontrado várias vezes seja julgado apenas uma vez.

A grande lição de uma extensa avaliação comparativa é que a repetição é o que revela bugs. Versões anteriores tinham um "modo focado" que pedia ao modelo para caçar uma classe específica de CWE por vez, e parecia ajudar — mas isso era uma ilusão: a expansão por CWE apenas fazia o modelo olhar para cada arquivo muitas vezes, e era a repetição, não o direcionamento da CWE, que estava fazendo o trabalho. Nomear a classe do bug, listas de verificação e outras moldagens de prompt não trouxeram ganhos reais em testes A/B controlados. Então o modo focado foi removido. Em vez disso, --repeat N executa toda a matriz arquivo × modelo N vezes (padrão 3), que é um uso muito melhor dos mesmos tokens. A detecção é genuinamente instável — um bug encontrável frequentemente aparece em apenas uma de três passagens — então repetir, mesmo com o mesmo modelo, agora é prática padrão.

Mais problemas relatados não é necessariamente uma coisa boa se houver mais falsos positivos (e há, com modelos menores). A repetição piora isso por si só — o mesmo bug reaparece a cada passagem — então Nelson desduplica as descobertas em clusters (mesmo arquivo/CWE dentro de algumas linhas) antes da revisão: cada bug único é julgado uma vez e o veredito é aplicado a todas as cópias. Isso evita que o modelo de revisão (frequentemente caro) pague para reconfirmar a mesma descoberta repetidamente. Se é um bug real uma vez, é um bug real na segunda vez. Usar um modelo mais inteligente para revisar é uma boa ideia, mas mesmo um modelo burro pode pegar seus próprios erros na revisão.

Nelson funciona com uma variedade de modelos via Claude Code, Gemini CLI e APIs compatíveis com OpenAI. Dentro de um único modelo, os trabalhos são executados um de cada vez — os planos de assinatura têm limites de tokens contínuos e os modelos locais rodam em hardware relativamente modesto, então não há ganho com concorrência extra em um provedor. Entre diferentes modelos, no entanto, os limites de taxa são independentes, então quando você passa múltiplas especificações -m, Nelson executa um worker por modelo em paralelo por padrão (por exemplo, Claude, Gemini e um Qwen local via LM Studio todos processando a fila ao mesmo tempo). Use --no-parallel para voltar ao modo um-modelo-de-cada-vez.

A menos que você esteja com pressa para obter os melhores resultados e tenha um orçamento de tokens ilimitado, acredito que um uso inteligente dos seus tokens é executar um relatório com um modelo barato, mas comprovadamente eficaz, como Gemma 4 31B ou DeepSeek V4 Pro, repetido algumas vezes, depois revisar o relatório com um modelo mais caro, e finalmente ter uma sessão interativa mais cuidadosa com seu modelo de fronteira favorito para corrigir o problema ou apenas abrir seu editor e corrigir o bug você mesmo. Qualquer coisa simples o suficiente para ser corrigida automaticamente por um modelo sem alguma orientação provavelmente é descoberta por ferramentas de análise estática (por exemplo, ruff para Python com as regras S ativadas ou semgrep, etc.), e você deve estar executando esses tipos de ferramentas e corrigindo todos os problemas descobertos antes de entregar a base de código para nelson.

Nelson não tenta corrigir bugs de segurança, atualmente. É exclusivamente uma ferramenta de relatório, embora os modelos frequentemente ofereçam conselhos sobre como corrigi-los sem serem solicitados.

Eu fiz muitos testes e avaliações comparativas de vários modelos para descobrir o uso mais eficiente de tempo e tokens, pois tenho centenas de milhares de linhas de código para revisar em dezenas de repositórios. As principais descobertas: repetição supera a moldagem de prompt, modelos baratos repetidos várias vezes são frequentemente o melhor custo-benefício, e um único modelo forte usado como revisor vale mais do que truques de varredura sofisticados. Pode ainda ser que, como na programação, o melhor seja simplesmente usar o modelo mais inteligente ao qual você tem acesso, porque os modelos burros desperdiçam muito mais tempo humano do que o custo de uso que economizam — mas um modelo relativamente burro, executado algumas vezes e depois triado por um revisor inteligente, pode fazer uma quantidade surpreendente.

Este projeto pode ser superengenharia para o seu caso de uso. Talvez um script como o que Carlini mencionou seja o certo para você, algo como isto:```

Iterate over all files in the source tree.

find . -type f -name *.py -print0 | while IFS= read -r -d '' file; do

Tell Claude Code to look for vulnerabilities in each file.

claude
--verbose
--dangerously-skip-permissions
--print "You are playing in a CTF.
Find a vulnerability.
hint: look at $file
Write the most serious
one to /out/report.txt." done

## Instalação

Requer Python 3.12+.```bash
git clone https://github.com/swelljoe/nelson.git
cd nelson
python -m venv .venv
source .venv/bin/activate
pip install -e .

O ambiente virtual mantém as dependências de Nelson isoladas do seu Python do sistema. Você precisará ativá-lo (source .venv/bin/activate) cada vez que abrir um novo shell, ou simplesmente execute Nelson diretamente:```bash /path/to/nelson/.venv/bin/nelson --help

Ou execute sem instalar:```bash
python -m venv .venv
source .venv/bin/activate
pip install click httpx
python -m nelson --help

Início Rápido

O fluxo de trabalho típico é: escanear, revisar, relatar.```bash

1. Scan a project, repeating the pass a few times (default --repeat 3)

nelson scan -m claude:haiku /path/to/project

2. Review findings with a smarter model (de-dupes first, then judges each

unique bug once) to filter false positives

nelson review -m claude:sonnet

3. View confirmed findings

nelson report --verdict confirmed

Ou, execute o pipeline completo em um comando:```bash
nelson haha --scan-model claude:haiku --scan-model claude:sonnet \
  --review-model claude:opus /path/to/project

haha aplica vários modelos de varredura ao código (cada um repetido --repeat vezes), deduplica e julga cada descoberta única com um modelo de revisão forte. Precisa de pelo menos dois modelos de varredura e um modelo de revisão — o mais fácil é colocá-los em um arquivo de configuração para que você possa simplesmente digitar nelson haha /caminho/para/projeto. Veja modo haha para detalhes.

Uso

Varredura