Ou compile a partir do código-fonte:```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build

### 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   |
+--------------+-------------+--------+-------+--------+

## 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

### 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

### 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"
  }'

## 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

#### 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

#### 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

| `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

### 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

- 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

**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"}'

### 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: "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

### 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

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

[![Star History Chart](https://api.star-history.com/svg?repos=praetorian-inc/augustus&type=Date)](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