Nelson

Trovare vulnerabilità tramite forza bruta stupida

Ispirato da un intervento di Nicholas Carlini e dal Ralph loop, Nelson è uno strumento che itera su ogni file in un progetto, chiedendo a un agente di cercare vulnerabilità. Ha una modalità di scansione, simile al bash loop di Carlini, in cui chiede al modello di trovare qualsiasi vulnerabilità in un file o in una directory di file; una modalità di revisione, in cui un modello (solitamente più intelligente) riesamina ogni vulnerabilità segnalata e decide se vale la pena segnalarla a un revisore umano; e un passaggio di deduplicazione intermedio, in modo che lo stesso bug trovato più volte venga giudicato una sola volta.

La grande lezione emersa da ampi benchmark è che la ripetizione è ciò che fa emergere i bug. Le versioni precedenti avevano una "modalità focalizzata" che chiedeva al modello di cercare una specifica classe CWE alla volta, e sembrava utile — ma era un'illusione: l'espansione per CWE costringeva semplicemente il modello a guardare ogni file molte volte, ed era la ripetizione, non il targeting della CWE, a fare il lavoro. Nominare la classe di bug, usare checklist e altre modifiche del prompt non hanno dato alcun reale miglioramento in test A/B controllati. Quindi la modalità focalizzata è stata rimossa. Invece, --repeat N esegue l'intera matrice file × modello N volte (default 3), che è un uso molto migliore degli stessi token. Il rilevamento è davvero incostante — un bug scopribile spesso appare in solo uno dei tre passaggi — quindi ripetere, anche con lo stesso modello, è ora una pratica standard.

Un maggior numero di problemi segnalati non è necessariamente una buona cosa se ci sono più falsi positivi (e ce ne sono, con modelli più piccoli). La ripetizione peggiora la situazione di per sé — lo stesso bug riappare ad ogni passaggio — quindi Nelson deduplica i risultati in cluster (stesso file/CWE entro poche righe) prima della revisione: ogni bug unico viene giudicato una volta e il verdetto viene applicato a ogni copia. Questo impedisce al modello di revisione (spesso costoso) di pagare per riconfermare lo stesso risultato più e più volte. Se è un bug reale una volta, è un bug reale anche la seconda volta. Usare un modello più intelligente per la revisione è una buona idea, ma anche un modello stupido può cogliere i propri errori in fase di revisione.

Nelson funziona con una varietà di modelli tramite Claude Code, Gemini CLI e API compatibili con OpenAI. All'interno di un singolo modello, i lavori vengono eseguiti uno alla volta — i piani di abbonamento hanno limiti di token rolling e i modelli locali girano su hardware relativamente modesto, quindi non c'è vantaggio da una concorrenza extra su un unico fornitore. Attraverso diversi modelli, invece, i limiti di velocità sono indipendenti, quindi quando passi più specifiche -m, Nelson esegue di default un worker per modello in parallelo (ad es. Claude, Gemini e un Qwen locale tramite LM Studio che processano tutti la coda contemporaneamente). Usa --no-parallel per tornare a un modello alla volta.

A meno che tu non abbia fretta di ottenere i migliori risultati e abbia un budget di token illimitato, credo che un uso intelligente dei tuoi token sia eseguire un report con un modello economico ma comprovato, come Gemma 4 31B o DeepSeek V4 Pro, ripetuto alcune volte, poi revisionare il report con un modello più costoso, e infine avere una sessione interattiva più attenta con il tuo modello frontier preferito per correggere il problema o semplicemente aprire il tuo editor e sistemare il bug da solo. Qualsiasi cosa abbastanza semplice da essere corretta automaticamente da un modello senza un po' di supervisione è probabilmente scopribile tramite strumenti di analisi statica (es. ruff per Python con le regole S abilitate o semgrep, ecc.), e dovresti eseguire quel tipo di strumenti e correggere tutti i problemi scoperti prima di passare il codebase a nelson.

Nelson non cerca di correggere i bug di sicurezza, al momento. È esclusivamente uno strumento di segnalazione, anche se i modelli spesso offrono consigli su come risolverli senza essere sollecitati.

Ho fatto molti test e benchmarking di vari modelli per capire l'uso più efficiente di tempo e token, dato che ho centinaia di migliaia di righe di codice da revisionare in dozzine di repository. I risultati principali: la ripetizione batte le modifiche del prompt, i modelli economici ripetuti più volte sono spesso il miglior rapporto qualità-prezzo, e un singolo modello forte usato come revisore vale più di trucchi di scansione fantasiosi. Potrebbe ancora risultare che, come per la programmazione, sia meglio usare semplicemente il modello più intelligente a cui hai accesso, perché i modelli stupidi sprecano molto più tempo umano di quanto risparmino in costi di utilizzo — ma un modello relativamente stupido, eseguito alcune volte e poi valutato da un revisore intelligente, può fare una quantità sorprendente.

Questo progetto potrebbe essere sovraingegnerizzato per il tuo caso d'uso. Forse uno script come quello di cui parlava Carlini è quello che fa per te, qualcosa del genere:```

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

## Installazione

Richiede 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 .

L'ambiente virtuale mantiene le dipendenze di Nelson isolate dal tuo Python di sistema. Dovrai attivarlo (source .venv/bin/activate) ogni volta che apri una nuova shell, o eseguire Nelson direttamente:```bash /path/to/nelson/.venv/bin/nelson --help

Oppure eseguire senza installare:```bash
python -m venv .venv
source .venv/bin/activate
pip install click httpx
python -m nelson --help

Avvio rapido

Il flusso di lavoro tipico è: scansiona, revisiona, segnala.```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

Oppure, esegui l'intera pipeline con un comando:```bash
nelson haha --scan-model claude:haiku --scan-model claude:sonnet \
  --review-model claude:opus /path/to/project

haha lancia diversi modelli di scansione sul codice (ciascuno ripetuto --repeat volte), deduplica e giudica ogni reperto unico con un singolo potente modello di revisione. Richiede almeno due modelli di scansione e un modello di revisione — il modo più semplice è metterli in un file di configurazione in modo da poter digitare semplicemente nelson haha /path/to/project. Vedi modalità haha per i dettagli.

Utilizzo

Scansione