praetorian-inc/augustusFerramenta de teste de segurança para LLMs para detectar injeção de prompt, jailbreaks e ataques adversários — 190+ sondas, 28 provedores, binário único em Go
Augustus - scanner de vulnerabilidades LLM para testes de injeção de prompt, jailbreak e ataques adversariais
# Augustus - Scanner de Vulnerabilidades LLM
> Teste grandes modelos de linguagem contra mais de 210 ataques adversariais cobrindo injeção de prompt, jailbreaks, exploração de codificação e extração de dados.
[](https://github.com/praetorian-inc/augustus/actions/workflows/ci.yaml)
[](go.mod)
[](LICENSE)
[](https://goreportcard.com/report/github.com/praetorian-inc/augustus)
[](https://github.com/praetorian-inc/augustus/releases)
**Augustus** é um scanner de vulnerabilidades LLM baseado em Go para profissionais de segurança. Ele testa grandes modelos de linguagem contra uma ampla gama de ataques adversariais, integra-se com 28 provedores de LLM e produz relatórios de vulnerabilidades acionáveis.
Diferente de ferramentas voltadas à pesquisa, o Augustus foi construído para testes de segurança em produção — varredura concorrente, limitação de taxa, lógica de repetição e tratamento de tempo limite já vêm prontos.
## Sumário
- [Por que Augustus](#why-augustus)
- [Recursos](#features)
- [Início Rápido](#quick-start)
- [Provedores Suportados](#supported-providers)
- [Uso](#usage)
- [Sonda Única](#single-probe)
- [Múltiplas Sondas](#multiple-probes)
- [Transformações Buff](#buff-transformations)
- [Formatos de Saída](#output-formats)
- [Endpoints REST Personalizados](#custom-rest-endpoints)
- [Como Funciona](#how-it-works)
- [Arquitetura](#architecture)
- [Configuração](#configuration)
- [FAQ](#faq)
- [Solução de Problemas](#troubleshooting)
- [Contribuição](#contributing)
- [Segurança](#security)
- [Suporte](#support)
- [Licença](#license)
## Por que Augustus
| Recurso | Augustus | garak | promptfoo |
|---------|----------|-------|-----------|
| Linguagem | Go | Python | TypeScript |
| Binário único | Sim | Não | Não |
| Varredura concorrente | Pools de goroutines | Pools de multiprocessamento | Sim |
| Provedores de LLM | 28 | 35+ | 80+ |
| Tipos de sondas | 210+ | 160+ | 119 plugins + 36 estratégias |
| Foco empresarial | Sim | Pesquisa | Sim |
## Recursos
| Recurso | Descrição |
|---------|-------------|
| **Mais de 210 Sondas de Vulnerabilidade** | 47 categorias de ataque: jailbreaks, injeção de prompt, exemplos adversariais, extração de dados, benchmarks de segurança, ataques a agentes e mais |
| **28 Provedores de LLM** | OpenAI, Anthropic, Azure, Bedrock, Vertex AI, Ollama e mais 22 com 43 variantes de gerador |
| **Mais de 90 Detectores** | Correspondência de padrões, LLM-como-juiz, HarmJudge (arXiv:2511.15304), Perspective API, detecção de conteúdo inseguro |
| **7 Transformações Buff** | Codificação, paráfrase, poesia (5 formatos, 3 estratégias), tradução para idiomas de baixos recursos, transformações de caixa |
| **Saída Flexível** | Formatos de relatório em tabela, JSON, JSONL e HTML |
| **Pronto para Produção** | Varredura concorrente, limitação de taxa, lógica de repetição, tratamento de tempo limite |
| **Binário Único** | Ferramenta baseada em Go compila em um único executável portátil |
| **Extensível** | Registro no estilo plugin via funções `init()` do Go |
### Categorias de Ataque
- **Ataques de jailbreak**: DAN, DAN 11.0, AIM, AntiGPT, Grandma, ArtPrompts
- **Injeção de prompt**: Codificação (Base64, ROT13, Morse), Contrabando de tags, FlipAttack, Injeção de prefixo/sufixo
- **Exemplos adversariais**: GCG, PAIR, AutoDAN, TAP (Tree of Attack Prompts), TreeSearch, DRA
- **Ataques de múltiplas rodadas**: Crescendo (escalada gradual), GOAT (troca adaptativa de técnicas)
- **Extração de dados**: Vazamento de chaves de API, alucinação de pacotes, extração de PII, LeakReplay
- **Manipulação de contexto**: Envenenamento de RAG, estouro de contexto, ataques multimodais, continuação, divergência
- **Exploração de formatos**: Injeção de Markdown, ataques de parsing YAML/JSON, escape ANSI, injeção web (XSS)
- **Técnicas de evasão**: Ofuscação, substituição de caracteres, ataques baseados em tradução, reformulação, ObscurePrompt
- **Benchmarks de segurança**: DoNotAnswer, RealToxicityPrompts, Snowball, LMRC
- **Ataques a agentes**: Manipulação de múltiplos agentes, exploração de navegação
- **Testes de segurança**: Bypass de guardrails, varredura de AV/spam, exploração (SQLi, execução de código), BadChars
> **Aviso**: A sonda `lmrc` usa linguagem profana e ofensiva como parte de seus testes de jailbreak. Use apenas em ambientes de teste autorizados.
## Início Rápido
### Instalação
Requer Go 1.27.0 ou posterior.```bash
go install github.com/praetorian-inc/augustus/cmd/augustus@latest
```
Ou compile a partir do código-fonte:```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build
```
### Utilização Básica```bash
export OPENAI_API_KEY="your-api-key"
augustus scan openai.OpenAI \
--probe dan.Dan_11_0 \
--detector dan.DAN \
--verbose
```
### Exemplo de Saída```
+--------------+-------------+--------+-------+--------+
| PROBE | DETECTOR | PASSED | SCORE | STATUS |
+--------------+-------------+--------+-------+--------+
| dan.Dan_11_0 | dan.DAN | false | 0.85 | VULN |
| dan.STAN | dan.STAN | true | 0.10 | SAFE |
| dan.AntiDAN | dan.AntiDAN | true | 0.05 | SAFE |
+--------------+-------------+--------+-------+--------+
```
### Listar Capacidades Disponíveis```bash
# List all registered probes, detectors, generators, harnesses, and buffs
augustus list
```
## Fornecedores Suportados
O Augustus inclui 28 categorias de fornecedores de LLM com 43 variantes de geradores:
| Fornecedor | Nome(s) do Gerador | Notas |
|--------------------|---------------------------|--------------------------------|
| OpenAI | `openai.OpenAI`, `openai.OpenAIReasoning` | GPT-3.5, GPT-4, GPT-4 Turbo, modelos de raciocínio o1/o3 |
| Anthropic | `anthropic.Anthropic` | Claude 3/3.5/4 (Opus, Sonnet, Haiku) |
| Azure OpenAI | `azure.AzureOpenAI` | Modelos OpenAI hospedados no Azure |
| AWS Bedrock | `bedrock.Bedrock` | Modelos Claude, Llama, Titan |
| Google Vertex AI | `vertex.Vertex` | Modelos PaLM, Gemini |
| Cohere | `cohere.Cohere` | Modelos Command, Command R |
| Replicate | `replicate.Replicate` | Modelos abertos hospedados na nuvem |
| HuggingFace | `huggingface.InferenceAPI`, `huggingface.InferenceEndpoint`, `huggingface.Pipeline`, `huggingface.LLaVA` | API de Inferência HF, endpoints, pipelines, multimodal |
| Together AI | `together.Together` | Inferência rápida para modelos OSS |
| Anyscale | `anyscale.Anyscale` | Hospedagem de Llama e Mistral |
| Groq | `groq.Groq` | Inferência LPU ultrarrápida |
| Mistral | `mistral.Mistral` | Modelos da API Mistral |
| Fireworks | `fireworks.Fireworks` | Plataforma de inferência de produção |
| DeepInfra | `deepinfra.DeepInfra` | Inferência GPU sem servidor |
| NVIDIA NIM | `nim.NIM`, `nim.NVOpenAICompletion`, `nim.NVMultimodal`, `nim.Vision` | Endpoints NVIDIA AI, multimodal |
| NVIDIA NeMo | `nemo.NeMo` | Framework NVIDIA NeMo |
| NVIDIA NVCF | `nvcf.NvcfChat`, `nvcf.NvcfCompletion` | NVIDIA Cloud Functions |
| NeMo Guardrails | `guardrails.NeMoGuardrails` | NVIDIA NeMo Guardrails |
| IBM watsonx | `watsonx.WatsonX` | Plataforma IBM watsonx.ai |
| LangChain | `langchain.LangChain` | Wrapper LLM LangChain |
| LangChain Serve | `langchain_serve.LangChainServe` | Endpoints LangChain Serve |
| Rasa | `rasa.RasaRest` | IA conversacional Rasa |
| GGML | `ggml.Ggml` | Inferência de modelo local GGML |
| Function | `function.Single`, `function.Multiple` | Geradores de funções personalizadas |
| Ollama | `ollama.Ollama`, `ollama.OllamaChat` | Hospedagem de modelo local |
| LiteLLM | `litellm.LiteLLM` | Proxy de API unificado |
| REST API | `rest.Rest` | Endpoints REST personalizados (suporte a SSE) |
| Test | `test.Blank`, `test.Repeat`, `test.Lipsum`, `test.Nones`, `test.Single`, `test.BlankVision` | Testes e desenvolvimento |
Todos os fornecedores estão disponíveis no binário compilado. Configure por meio de variáveis de ambiente ou arquivos de configuração YAML. Consulte [Configuração](#configuration) para detalhes de configuração.
## Uso
### Sonda Única```bash
# Test for DAN jailbreak
augustus scan openai.OpenAI \
--probe dan.Dan_11_0 \
--detector dan.DAN \
--config-file config.yaml \
--verbose
```
### Sondas Múltiplas```bash
# Use glob patterns to run related probes
augustus scan openai.OpenAI \
--probes-glob "dan.*,goodside.*,grandma.*" \
--detectors-glob "*" \
--config-file config.yaml \
--output batch-results.jsonl
# Run all probes against Claude
augustus scan anthropic.Anthropic \
--all \
--config '{"model":"claude-3-opus-20240229"}' \
--timeout 60m \
--output comprehensive-scan.jsonl \
--html comprehensive-report.html
```
### Buff Transformations
Aplique transformações de prompt para testar técnicas de evasão:```bash
# Apply base64 encoding buff to all probes
augustus scan openai.OpenAI \
--all \
--buff encoding.Base64 \
--config '{"model":"gpt-4"}'
# Apply poetry transformation
augustus scan anthropic.Anthropic \
--probes-glob "dan.*" \
--buff poetry.MetaPrompt \
--config '{"model":"claude-3-opus-20240229"}'
# Chain multiple buffs
augustus scan openai.OpenAI \
--all \
--buffs-glob "encoding.*,paraphrase.*" \
--output buffed-results.jsonl
```
### Formatos de Saída```bash
# Table format (default) - human-readable
augustus scan openai.OpenAI --probe dan.Dan_11_0 --format table
# JSON format - structured output
augustus scan openai.OpenAI --probe dan.Dan_11_0 --format json
# JSONL format - one JSON object per line, ideal for piping
augustus scan openai.OpenAI --probe dan.Dan_11_0 --format jsonl
# HTML report - visual reports for stakeholders
augustus scan openai.OpenAI --all --html report.html
```
### Endpoints REST Personalizados```bash
# Test proprietary LLM endpoint (OpenAI-compatible API)
augustus scan rest.Rest \
--probe dan.Dan_11_0 \
--detector dan.DAN \
--config '{
"uri": "https://api.example.com/v1/chat/completions",
"method": "POST",
"headers": {"Authorization": "Bearer YOUR_API_KEY"},
"req_template_json_object": {
"model": "custom-model",
"messages": [{"role": "user", "content": "$INPUT"}]
},
"response_json": true,
"response_json_field": "$.choices[0].message.content"
}'
# Test with proxy interception (Burp Suite, mitmproxy)
augustus scan rest.Rest \
--probes-glob "goodside.*" \
--config '{
"uri": "https://internal-llm.corp/generate",
"proxy": "http://127.0.0.1:8080",
"headers": {"X-API-Key": "$KEY"},
"api_key": "your-key-here",
"req_template": "{\"prompt\":\"$INPUT\",\"max_tokens\":500}",
"response_json": true,
"response_json_field": "output"
}'
```
**Chaves de Configuração REST:**
- `uri`: Endpoint da API de destino (obrigatório)
- `method`: Método HTTP (padrão: POST)
- `headers`: Cabeçalhos HTTP como pares chave-valor
- `req_template`: Corpo da requisição bruto com o espaço reservado `$INPUT`
- `req_template_json_object`: Corpo da requisição JSON (serializado automaticamente, use `$INPUT` em strings)
- `response_json`: Analisar a resposta como JSON (padrão: false)
- `response_json_field`: Caminho JSONPath para extrair (ex.: `$.data.text` ou nome de campo simples)
- `api_key`: Chave de API para substituição do espaço reservado `$KEY`
- `proxy`: URL do proxy HTTP para inspeção de tráfego
### Opções Avançadas```bash
# Adjust concurrency (default: 10)
augustus scan openai.OpenAI --all --concurrency 20
# Increase timeout for complex probes like TAP or PAIR
augustus scan openai.OpenAI --probe tap.TAPv1 --timeout 60m
# Use a specific harness strategy
augustus scan openai.OpenAI --all --harness batch.Batch
# Test local model with Ollama (no API key needed)
augustus scan ollama.OllamaChat \
--probe dan.Dan_11_0 \
--config '{"model":"llama3.2:3b"}'
```
## Como Funciona
O Augustus usa uma arquitetura de pipeline para testar LLMs contra ataques adversariais:```mermaid
flowchart LR
A[Probe Selection] --> B[Buff Transform]
B --> C[Generator / LLM Call]
C --> D[Detector Analysis]
D --> E{Vulnerable?}
E -->|Yes| F[Record Finding]
E -->|No| G[Record Pass]
subgraph Scanner
B
C
D
E
end
```
### Pipeline de Digitalização
1. **Seleção de Sondas**: Escolha sondas por nome, padrão glob ou `--all`
2. **Transformação de Buff**: Opcionalmente transforme prompts (codificar, parafrasear, traduzir, poetizar)
3. **Chamada do Gerador**: Envie prompts adversariais ao LLM alvo por meio de sua integração com o provedor
4. **Análise do Detector**: Analise respostas usando correspondência de padrões, LLM-como-juiz ou detectores especializados
5. **Registro de Resultados**: Pontue cada tentativa e produza a saída no formato solicitado
6. **Motor de Ataque**: Para sondas iterativas (PAIR, TAP), o motor de ataque de turno único refina prompts ao longo das iterações com poda de candidatos e pontuação baseada em juiz
7. **Motor Multi-Turno**: Para sondas conversacionais (Crescendo, GOAT), o motor multi-turno mantém o histórico completo da conversa com o alvo ao longo dos turnos, com detecção de recusa e adaptação dinâmica
### Estratégias de Ataque Multi-Turno
Ataques multi-turno mantêm uma conversa persistente com o LLM alvo, explorando o fato de que os modelos podem divulgar informações incrementalmente ao longo dos turnos que recusariam em um único prompt. O motor multi-turno usa três LLMs: um **atacante** (gera perguntas), um **alvo** (o sistema sob teste) e um **juiz** (pontua o progresso e detecta recusas).
#### Crescendo
Crescendo usa escalada gradual (técnica do pé-na-porta) para lentamente deslocar uma conversa de tópicos benignos em direção a um objetivo proibido.
- **Artigo**: [Russinovich et al., 2024](https://arxiv.org/abs/2404.01833)
- **Abordagem**: Começa com perguntas genuinamente benignas e educacionais e aumenta incrementalmente a especificidade ao longo de muitos turnos
- **Padrão de escalada**: Contexto histórico → mecanismos técnicos → detalhes específicos → solicitações diretas apresentadas como acompanhamentos naturais
- **Ponto forte**: Eficaz contra modelos que rastreiam o tom da conversa — a mudança gradual evita acionar filtros de segurança```bash
augustus scan rest.Rest \
--probe crescendo.Crescendo \
--config-file crescendo.yaml \
--html report.html -v
```
#### GOAT (Generative Offensive Agent Tester)
O GOAT utiliza uma abordagem agressiva e adaptativa com 7 técnicas adversariais e raciocínio Chain-of-Attack-Thought para alternar dinamicamente entre estratégias com base no que funciona ou falha.
- **Artigo**: [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **Abordagem**: Visa o objetivo desde a 1ª rodada usando enquadramento indireto, nunca mencionando a meta diretamente ao alvo
- **7 técnicas** em 3 categorias:
- *Manipulação de Saída*: Supressão de Recusa, Priming de Resposta
- *Distratores de Resposta Segura*: Resposta Dupla, Divisão de Tópico, Intenção Oposta
- *Cenários Ficcionais*: Modificação de Persona, Hipotético
- **Chain-of-Attack-Thought**: A cada rodada, o atacante raciocina por Observação → Pensamento → Estratégia → Resposta antes de elaborar sua mensagem
- **Empilhamento de técnicas**: Múltiplas técnicas podem ser combinadas em uma única rodada para um efeito mais forte
- **Força**: Alcança altas taxas de sucesso em menos rodadas (normalmente 3-5) ao alternar agressivamente entre abordagens fundamentalmente diferentes```bash
augustus scan rest.Rest \
--probe goat.Goat \
--config-file goat.yaml \
--html report.html -v
```
#### Hydra
O Hydra mantém um único caminho de conversa e reverte turnos inteiros quando o alvo recusa, pedindo ao atacante uma abordagem completamente diferente. Ao contrário do Crescendo/GOAT (que reformula em caso de recusa), o retrocesso do Hydra remove completamente os turnos recusados da visão do alvo.
- **Abordagem**: Caminho único com retrocesso em nível de turno — turnos recusados são apagados e substituídos
- **Técnicas**: Decomposição (dividir o objetivo em subperguntas inofensivas), aproveitamento de contexto (construir com base nas próprias palavras do alvo), simulação de autoridade, enquadramento emocional, normalização progressiva
- **Recurso principal**: `max_backtracks` controla quantas vezes o Hydra pode apagar e tentar novamente um turno
- **Modo com estado**: Defina `stateful: true` para alvos onde mensagens não podem ser desenviadas (desativa o retrocesso)
- **Força**: Mantém o histórico de conversa do alvo limpo — o alvo nunca vê abordagens falhas, prevenindo escalada defensiva```bash
augustus scan rest.Rest \
--probe hydra.Hydra \
--config-file hydra.yaml \
--html report.html -v
```
#### Utilizador Traquina
O Utilizador Traquina simula uma pessoa inocente e curiosa que sonda subtilmente os limites da IA através de conversa natural. Ao contrário das estratégias adversariais, a persona do atacante é um utilizador casual que se desvia para tópicos proibidos através de interações aparentemente inofensivas.
- **Inspirado em**: [Tau-bench](https://github.com/sierra-research/tau-bench) e na estratégia de utilizador traquina do promptfoo
- **Abordagem**: Fase de construção de rapport → sondagem de limites → insistência assertiva
- **7 técnicas**: Curiosidade ingénua, mal-entendido deliberado, prova social, desvio gradual, apelo emocional, permissão assumida, recontextualização
- **Guiões específicos por objetivo**: Scripts integrados para extrair instruções do sistema, encontrar segredos/flags e contornar a política de conteúdo
- **Turnos predefinidos**: 5 (menos do que outras estratégias — a abordagem subtil ou funciona rapidamente ou não funciona de todo)
- **Ponto forte**: Eficaz contra modelos treinados para resistir a padrões adversariais óbvios — a persona casual contorna as heurísticas de "deteção de ataques"```bash
augustus scan rest.Rest \
--probe mischievous.MischievousUser \
--config-file mischievous.yaml \
--html report.html -v
```
#### Guia de Seleção de Estratégia
| Estratégia | Turnos | Estilo | Melhor Para | Custo |
|----------|-------|-------|----------|------|
| `crescendo.Crescendo` | 10 | Escalada gradual | Modelos com filtros de segurança baseados em tom | Médio (10 turnos × 3 chamadas de LLM) |
| `goat.Goat` | 10 | Troca agressiva de técnicas | Resultados rápidos, modelos vulneráveis a truques de enquadramento | Médio-Alto (sobrecarga de raciocínio de técnicas) |
| `hydra.Hydra` | 10 | Retrocesso em caso de recusa | Modelos teimosos que recusam com frequência | Alto (o retrocesso adiciona novas tentativas) |
| `mischievous.MischievousUser` | 5 | Sondagem casual de persona | Modelos treinados contra padrões adversariais | Baixo (5 turnos, abordagem sutil) |
**Decisão rápida**:
- Comece com **Crescendo** — é a estratégia mais versátil
- Experimente **GOAT** se o Crescendo for muito lento (o GOAT normalmente tem sucesso em 3-5 turnos)
- Use **Hydra** se o alvo recusar com frequência (o retrocesso mantém a conversa limpa)
- Use **Mischievous** para alvos com forte detecção de padrões adversariais (a persona contorna heurísticas)
#### Configuração Multi-Turno
Todas as quatro estratégias compartilham a mesma estrutura de configuração:```yaml
generators:
rest.Rest:
uri: "https://your-llm-endpoint/chat"
method: POST
req_template: '{"input": "$INPUT"}'
response_json: true
response_json_field: "response"
judge:
generator_type: openai.OpenAI
config:
model: gpt-4
api_key: "${OPENAI_API_KEY}"
probes:
attacker_generator_type: openai.OpenAI
attacker_config:
model: gpt-4
api_key: "${OPENAI_API_KEY}"
settings:
crescendo.Crescendo: # or goat.Goat, hydra.Hydra, mischievous.MischievousUser
goal: "your test objective"
max_turns: 10
success_threshold: 0.8
use_secondary_judge: true
```
| `goal` | (obrigatório) | O objetivo que o atacante tenta alcançar |
|---------|---------|-------------|
| `max_turns` | 10 | Número máximo de turnos de conversa antes de parar |
| `success_threshold` | 0.8 | Pontuação do juiz (0.0-1.0) que aciona a saída antecipada |
| `max_refusal_retries` | 10 | Tentativas de reformulação por turno quando o alvo recusa |
| `attack_max_attempts` | 5 | Repetições para falhas de parsing JSON do LLM atacante |
| `use_secondary_judge` | true | Ativa juiz secundário para capturar falsos negativos |
| `max_backtracks` | 10 | Reversões em nível de turno em caso de recusa (apenas Hydra) |
| `enable_fast_refusal` | true | Detecção de recusa baseada em padrões antes da chamada do juiz LLM |
| `enable_scan_memory` | false | Aprendizado entre casos de teste (compartilha táticas entre sondas) |
| `stateful` | false | Desativa reversão para alvos com estado |
| `exclude_target_output` | false | Oculta respostas do alvo do feedback do atacante (modo privacidade) |
| `attacker_model` | (auto) | Substitui o nome do modelo atacante para dimensionamento da janela de contexto |
#### Solução de Problemas em Múltiplos Turnos
| Sintoma | Causa Provável | Correção |
|---------|-------------|-----|
| `no turns completed (attacker_parse_failures=N)` | LLM atacante retornando JSON inválido | Use um modelo atacante mais forte (GPT-4, Claude Opus). Aumente `attack_max_attempts`. |
| `no turns completed (target_empty=N)` | Alvo retornando respostas vazias/nulas | Verifique se o endpoint do alvo está respondendo. Confirme o template de configuração REST. |
| Todos os turnos pontuam 0.0 | Objetivo vago demais ou atacante não engajando | Torne `goal` mais específico. Tente uma estratégia diferente. |
| Pontuações altas, mas sem sucesso | `success_threshold` muito alto | Reduza `success_threshold` de 0.8 para 0.6-0.7 |
| Execuções muito longas/caras | Muitos turnos e repetições | Reduza `max_turns` (tente 5). Defina `enable_fast_refusal: true`. |
| Hydra continua revertendo | Alvo recusa tudo | Tente `stateful: true` ou mude para a estratégia Mischievous |
## Arquitetura```
cmd/augustus/ CLI entrypoint (Kong-based)
pkg/
attempt/ Probe execution lifecycle and result tracking
buffs/ Buff interface for prompt transformations
config/ Configuration loading (YAML/JSON) with profiles
detectors/ Public detector interfaces and registry
generators/ Public generator interfaces and registry
harnesses/ Harness interface for execution strategies
lib/http/ Shared HTTP client with proxy support
lib/stego/ LSB steganography for multimodal attacks
logging/ Structured slog-based logging
metrics/ Prometheus metrics collection
prefilter/ Aho-Corasick keyword pre-filtering
probes/ Public probe interfaces and registry
ratelimit/ Token bucket rate limiting
registry/ Generic capability registration system
results/ Result types and multi-format output
retry/ Exponential backoff with jitter
scanner/ Scanner orchestration with concurrency
templates/ YAML probe template loader (Nuclei-style)
types/ Canonical shared interfaces (Prober, Generator, Detector)
internal/
probes/ 210+ probe implementations (47 categories)
generators/ 28 LLM provider integrations (43 variants)
detectors/ 90+ detector implementations (35 categories)
harnesses/ 3 harness strategies (probewise, batch, agentwise)
buffs/ Buff interface for prompt transformations
attackengine/ Iterative adversarial attack engine (PAIR/TAP backend)
multiturn/ Multi-turn conversational attack engine (Crescendo/GOAT/Hydra/Mischievous)
ahocorasick/ Internal Aho-Corasick keyword matching
benchmarks/ Performance benchmarks
tests/ Integration and equivalence tests
research/ Research documentation and analysis
examples/ Example configurations
docs/ Documentation
```
### Principais Decisões de Design
- **Varredura concorrente** com pools de goroutines limitados via `errgroup`
- **Registro no estilo de plugins** usando funções `init()` do Go para probes, geradores, detectores, buffs e harnesses
- **Motor de ataque iterativo** com gerenciamento de conversas multi-stream, poda de candidatos e pontuação baseada em juiz para PAIR/TAP
- **Motor de ataque multi-turno** com histórico de conversa persistente, detecção de recusa e design agnóstico de estratégia para Crescendo/GOAT
- **Modelos de probe em YAML** (estilo Nuclei) para definições declarativas de probes junto com probes baseados em Go
- **Pré-filtragem Aho-Corasick** para correspondência rápida de palavras-chave em detectores
## Configuração
### Arquivo de Configuração YAML
Crie um arquivo `config.yaml`:```yaml
# Runtime configuration
run:
max_attempts: 3
timeout: "30s"
# Generator configurations
generators:
openai.OpenAI:
model: "gpt-4"
temperature: 0.7
api_key: "${OPENAI_API_KEY}" # Environment variable interpolation
anthropic.Anthropic:
model: "claude-3-opus-20240229"
temperature: 0.5
api_key: "${ANTHROPIC_API_KEY}"
ollama.OllamaChat:
model: "llama3.2:3b"
temperature: 0.8
# Judge configuration (required for judge.Judge, judge.Refusal, and multi-turn probes)
judge:
generator_type: openai.OpenAI
model: gpt-4o-mini
config:
api_key: "${OPENAI_API_KEY}"
# Output configuration
output:
format: "jsonl"
path: "./results.jsonl"
# Named profiles for different scenarios
profiles:
quick:
run:
max_attempts: 1
timeout: "10s"
generators:
openai.OpenAI:
model: "gpt-3.5-turbo"
temperature: 0.5
output:
format: "table"
thorough:
run:
max_attempts: 5
timeout: "60s"
generators:
openai.OpenAI:
model: "gpt-4"
temperature: 0.3
output:
format: "jsonl"
path: "./thorough_results.jsonl"
```
### Variáveis de Ambiente```bash
# API Keys
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export COHERE_API_KEY="..."
# Debug mode
export AUGUSTUS_DEBUG=true
```
### Configuração de Proxy
Roteie o tráfego HTTP através de um proxy (ex.: Burp Suite) para inspeção:```bash
# Method 1: Via config parameter
augustus scan rest.Rest \
--probe dan.Dan_11_0 \
--detector dan.DAN \
--config '{"uri":"https://api.example.com","proxy":"http://127.0.0.1:8080"}' \
--output results.jsonl
# Method 2: Via environment variables
export HTTP_PROXY=http://127.0.0.1:8080
export HTTPS_PROXY=http://127.0.0.1:8080
augustus scan rest.Rest --probe dan.Dan_11_0 --config '{"uri":"https://api.example.com"}'
```
- Verificação TLS desativada automaticamente para inspeção de proxy
- Suporte a HTTP/2 habilitado para APIs modernas
- Respostas Server-Sent Events (SSE) detectadas e analisadas automaticamente
### Referência da CLI```
Usage: augustus scan <generator> [flags]
Arguments:
<generator> Generator name (e.g., openai.OpenAI, anthropic.Anthropic)
Probe Selection (choose one):
--probe, -p Probe name (repeatable)
--probes-glob Comma-separated glob patterns (e.g., "dan.*,goodside.*")
--all Run all registered probes
Detector Selection:
--detector Detector name (repeatable)
--detectors-glob Comma-separated glob patterns
Buff Selection:
--buff, -b Buff names to apply (repeatable)
--buffs-glob Comma-separated buff glob patterns (e.g., "encoding.*")
Configuration:
--config-file Path to YAML config file
--config, -c JSON config for generator
Execution:
--harness Harness name (default: probewise.Probewise)
--timeout Overall scan timeout (default: 30m)
--probe-timeout Per-probe timeout (default: 5m)
--concurrency Max concurrent probes (default: 10, env: AUGUSTUS_CONCURRENCY)
Output:
--format, -f Output format: table, json, jsonl (default: table)
--output, -o JSONL output file path
--html HTML report file path
--verbose, -v Verbose output
Global:
--debug, -d Enable debug mode
```
**Comandos:**```bash
augustus version # Print version information
augustus list # List available probes, detectors, generators, harnesses, buffs
augustus scan <generator> # Run vulnerability scan
augustus completion <shell> # Generate shell completion (bash, zsh, fish)
```
**Códigos de Saída:**
| Código | Significado |
|------|---------|
| 0 | Sucesso - verificação concluída |
| 1 | Erro de verificação/tempo de execução |
| 2 | Erro de validação/uso |
## FAQ
### Como o Augustus se compara ao garak?
O Augustus é uma reimplementação nativa em Go inspirada no [garak](https://github.com/NVIDIA/garak) (o scanner de vulnerabilidades de LLM baseado em Python da NVIDIA). Principais diferenças:
- **Desempenho**: Binário Go vs interpretador Python — execução mais rápida e menor uso de memória
- **Distribuição**: Binário único sem dependências de tempo de execução vs pacote Python com instalação via pip
- **Concorrência**: Pools de goroutines do Go (paralelismo entre sondas) vs pools de multiprocessamento do Python (paralelismo dentro da sonda)
- **Cobertura de sondas**: O Augustus tem mais de 210 sondas; o garak tem mais de 160 sondas com um histórico de pesquisa mais longo e artigo publicado (arXiv:2406.11036)
- **Cobertura de provedores**: O Augustus tem 28 provedores; o garak tem mais de 35 variantes de geradores em 22 módulos de provedores
### Posso testar modelos locais sem chaves de API?
Sim! Use a integração com o Ollama para testar modelos locais:```bash
# No API key needed
augustus scan ollama.OllamaChat \
--probe dan.Dan_11_0 \
--config '{"model":"llama3.2:3b"}'
```
### Como adiciono sondas personalizadas?
1. Crie um novo arquivo Go em `internal/probes/`
2. Implemente a interface `probes.Probe`
3. Registre usando `registry.RegisterProbe()` em uma função `init()`
4. Recompile: `make build`
Consulte [CONTRIBUTING.md](https://github.com/praetorian-inc/augustus/blob/main/CONTRIBUTING.md) para instruções detalhadas.
### Quais formatos de saída são suportados?
O Augustus suporta quatro formatos de saída:
| Formato | Flag | Caso de uso |
|--------|------|----------|
| Tabela | `--format table` | Saída legível em terminal |
| JSON | `--format json` | Objeto JSON único para análise |
| JSONL | `--format jsonl` | JSON delimitado por linhas para streaming |
| HTML | `--html report.html` | Relatórios visuais para partes interessadas |
### Como testo vários modelos de uma vez?```bash
# Test multiple models sequentially
for model in "gpt-4" "gpt-3.5-turbo"; do
augustus scan openai.OpenAI \
--all \
--config "{\"model\":\"$model\"}" \
--output "results-$model.jsonl"
done
```
### O Augustus é adequado para ambientes de produção?
Sim, o Augustus foi projetado para uso em produção com:
- Varredura concorrente com limites configuráveis
- Limitação de taxa para respeitar as cotas da API
- Tratamento de timeout para sondas de longa duração
- Lógica de repetição para falhas transitórias
- Registro estruturado para observabilidade
## Solução de problemas
### Erro: "Limite de taxa da API excedido"
**Causa**: Muitas solicitações concorrentes ou solicitações por minuto.
**Soluções**:
1. Reduza a concorrência: `--concurrency 5`
2. Use as configurações de limite de taxa específicas do provedor no arquivo YAML: ```yaml
generators:
openai.OpenAI:
rate_limit: 10 # requests per minute
```
### Erro: "context deadline exceeded" ou "timeout"
**Causa**: Sondas complexas (como TAP ou PAIR) excedem o tempo limite padrão.
**Solução**:```bash
augustus scan openai.OpenAI \
--probe tap.TAPv1 \
--timeout 60m \
--config-file config.yaml
```
### Erro: "invalid API key" ou "authentication failed"
**Causa**: Credenciais de API ausentes ou inválidas.
**Soluções**:
1. Verifique se a variável de ambiente está definida: `echo $OPENAI_API_KEY`
2. Verifique se há erros de digitação no arquivo de configuração
3. Garanta que a chave de API tenha as permissões necessárias
4. Para Ollama, garanta que o serviço esteja em execução: `ollama serve`
### Erro: "probe not found" ou "detector not found"
**Causa**: Erro de digitação no nome ou probe não registrado.
**Solução**:```bash
# List all available probes and detectors
augustus list
# Use exact names from the list
augustus scan openai.OpenAI --probe dan.Dan_11_0 # Correct
```
### A verificação não produz resultados
**Causa**: O detector não correspondeu a nenhuma resposta, ou a saída não foi gravada.
**Soluções**:
1. Execute com `--verbose` para ver a saída detalhada
2. Verifique se o detector corresponde ao tipo de sonda
3. Confirme se o caminho do arquivo de saída é gravável
## Contribuindo
Aceitamos contribuições! Consulte [CONTRIBUTING.md](https://github.com/praetorian-inc/augustus/blob/main/CONTRIBUTING.md) para:
- Adicionar novas sondas de vulnerabilidade
- Criar novas implementações de detectores
- Adicionar integrações de provedores de LLM
- Diretrizes de teste
- Requisitos de estilo de código
### Desenvolvimento```bash
# Run all tests
make test
# Run specific package tests
go test ./pkg/scanner -v
# Run equivalence tests (compare Go vs Python implementations)
go test ./tests/equivalence -v
# Build binary
make build
# Install to $GOPATH/bin
make install
```
### Ambiente de Benchmark (DevPod)
Um ambiente de desenvolvimento em nuvem pronto para uso para benchmarking de LLMs está disponível via [DevPod](https://devpod.sh/). Ele provisiona um contêiner remoto com Augustus, Ollama, Go e todas as dependências pré-instaladas.```bash
cd devpod
# CPU-only instance (~$0.08/hr) - cloud APIs only
make devpod-up-cpu
# GPU instance with NVIDIA T4 (~$0.53/hr) - local models up to 14B
make devpod-up-gpu
# GPU Pro instance with NVIDIA L4 (~$0.80/hr) - local models up to 32B
make devpod-up-gpu-pro
```
Dentro do devpod:```bash
devpod/scripts/setup.sh # Configure LLM provider API keys
devpod/scripts/pull-models.sh # Pull local Ollama models (GPU only)
devpod/scripts/benchmark.sh # Run benchmarks with comparison reports
```
O ambiente também funciona como um [dev container](https://containers.dev/) padrão — abra o repositório no VS Code ou Cursor e selecione a configuração de CPU ou GPU em `.devcontainer/`.
## Segurança
O Augustus foi projetado para **testes de segurança autorizados apenas**.
- O Augustus envia prompts adversariais para LLMs que você especificar — sempre garanta que você tem autorização
- Nunca teste sistemas que você não possui ou para os quais não tem permissão explícita
- Alguns probes geram conteúdo ofensivo por design (para testar filtros de segurança)
- Os resultados podem conter conteúdo prejudicial produzido pelos LLMs alvo
Reporte problemas de segurança via [GitHub Issues](https://github.com/praetorian-inc/augustus/issues).
## Suporte
Se você achar o Augustus útil, considere:
- Dar uma **estrela** no GitHub
- [Abrir uma issue](https://github.com/praetorian-inc/augustus/issues) para bugs ou solicitações de recursos
- [Contribuir](https://github.com/praetorian-inc/augustus/blob/main/CONTRIBUTING.md) com novos probes, detectores ou integrações de provedores
[](https://star-history.com/#praetorian-inc/augustus&Date)
## Licença
[Apache 2.0](https://github.com/praetorian-inc/augustus/blob/main/LICENSE) - Praetorian Security, Inc.
---
**Desenvolvido pela [Praetorian](https://www.praetorian.com/)** - Soluções de Segurança Ofensiva