Nano-analyzer

Um scanner de vulnerabilidades de dia zero minimalista, alimentado por LLM, da AISLE.

Protótipo de pesquisa para fins de demonstração. Este é um harness simples de arquivo único que é capaz de detectar vulnerabilidades reais de dia zero. Note que é um protótipo, tendencioso para bugs de segurança de memória em C/C++, e produzirá falsos positivos. Estamos compartilhando-o como está, no espírito da pesquisa aberta — espere arestas afiadas.

O que faz

O Nano-analyzer é um scanner Python simples de arquivo único que envia código fonte através de um pipeline de LLM de três estágios:

1. Geração de contexto — um modelo escreve um briefing de segurança sobre o arquivo: o que ele faz, por onde fluem dados não confiáveis, quais buffers existem e seu tamanho.
2. Escaneamento de vulnerabilidades — o mesmo modelo, alimentado com o contexto, caça bugs de dia zero função por função e gera descobertas estruturadas.
3. Triagem cética — cada descoberta é desafiada em várias rodadas por um revisor cético que pode grep no código base para verificar (ou refutar) defesas. Um árbitro dá a palavra final.

Os resultados são salvos como arquivos Markdown e JSON para revisão humana.

Limitações atuais

Este é um protótipo v0.1. Por favor, tenha em mente o seguinte:

• Viés para C/C++. Os prompts, exemplos few-shot e heurísticas são fortemente ajustados para vulnerabilidades de segurança de memória em C/C++ (estouros de buffer, desreferências de ponteiro nulo, estouros de inteiro, confusão de tipos). Ele escaneará outras linguagens, mas é muito menos eficaz nelas.
• Falsos positivos. Mesmo com triagem em várias rodadas, espere descobertas que não se sustentam em uma inspeção mais próxima. Sempre verifique manualmente.
• Falsos negativos. O scanner pode perder classes inteiras de vulnerabilidades — bugs de lógica, condições de corrida, problemas criptográficos, bypass de autenticação, etc. Uma varredura limpa não significa que o código está seguro.
• Análise de arquivo único. Cada arquivo é escaneado independentemente. Vulnerabilidades entre arquivos que dependem de interações entre unidades de compilação provavelmente serão perdidas.
• Dependente de LLM. Os resultados variam com o modelo usado. Modelos diferentes encontrarão coisas diferentes e alucinarão falsos positivos diferentes.

Configuração

Requisitos

• Python 3.8+
• Uma chave de API OpenAI (para modelos OpenAI) ou uma chave de API OpenRouter (para outros provedores)
• Opcional: ripgrep (rg) para buscas grep na triagem
• Opcional: Google codesearch (csearch/cindex) para grep mais rápido em repositórios grandes

Instalar

git clone https://github.com/weareaisle/nano-analyzer.git
cd nano-analyzer
# Nenhuma instalação de dependência necessária. Execute diretamente:
python3 scan.py --help

Chaves de API

Defina sua chave de API como uma variável de ambiente:

# Para modelos OpenAI (nomes de modelo sem barra, ex.: "gpt-5.4-nano"):
export OPENAI_API_KEY=sk-...

# Para modelos OpenRouter (nomes de modelo com barra, ex.: "qwen/qwen3-32b"):
export OPENROUTER_API_KEY=sk-or-...

O scanner determina qual chave usar com base no nome do modelo: se contiver uma '/', roteia através do OpenRouter; caso contrário, usa a API OpenAI diretamente.

Uso

Escaneamento básico

# Escanear um único arquivo
python3 scan.py ./path/to/file.c

# Escanear um diretório recursivamente
python3 scan.py ./path/to/src/

Opções comuns

# Usar um modelo diferente
python3 scan.py ./src --model gpt-5.4

# Controlar paralelismo
python3 scan.py ./src --parallel 30

# Apontar o grep da triagem para a raiz completa do repositório (útil ao escanear um subdiretório)
python3 scan.py ./lib/crypto/ --repo-dir ./

# Exibir apenas descobertas de alta confiança
python3 scan.py ./src --min-confidence 0.7

# Mais rodadas de triagem para maior precisão (padrão: 5)
python3 scan.py ./src --triage-rounds 7

Todas as flags

Saída

Os resultados são salvos em ~/nano-analyzer-results/<timestamp>/ (ou --output-dir):

<timestamp>/
├── summary.json              # resumo da varredura legível por máquina
├── summary.md                # resumo da varredura legível por humanos
├── <filename>.md             # saída bruta do scanner por arquivo
├── <filename>.context.md     # briefing de contexto por arquivo
├── <filename>.json           # dados completos do resultado por arquivo
├── triages/                  # raciocínio detalhado da triagem
│   └── T0001_<file>_<title>.md
├── findings/                 # descobertas que sobreviveram à triagem
│   └── VULN-001_<file>.md
├── triage.json               # todos os veredictos da triagem
└── triage_survivors.md       # resumo das descobertas validadas

Como a triagem funciona

Quando uma varredura encontra um problema de severidade média ou superior, o pipeline de triagem é acionado:

1. Um revisor cético examina a descoberta contra o código real e pode grep no código base para verificar ou refutar defesas reivindicadas.
2. Isso se repete por várias rodadas (padrão: 5), com cada revisor vendo argumentos anteriores e sendo incentivado a encontrar novas evidências em vez de reexaminar pontos antigos.
3. Um árbitro final lê todas as rodadas e faz uma chamada VÁLIDO/INVÁLIDO.
4. A pontuação de confiança (ex.: 80% [VVIVV→V]) reflete a fração de rodadas que disseram VÁLIDO.

As descobertas que sobrevivem à triagem são escritas no diretório findings/ com cadeias completas de raciocínio.

Aviso Legal

Esta ferramenta é um protótipo de pesquisa. Não substitui auditorias de segurança profissionais, revisão manual de código ou ferramentas estabelecidas de análise estática. Não confie nela como sua única avaliação de segurança. Use por sua conta e risco.

Licença

Apache License 2.0