Oppure compila dal sorgente:```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build

### Esempio di Output```
+--------------+-------------+--------+-------+--------+
| 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   |
+--------------+-------------+--------+-------+--------+

## Provider Supportati

Augustus include 28 categorie di provider LLM con 43 varianti di generatori:

| Provider           | Nomi dei Generator(i)         | Note                          |
|--------------------|---------------------------|--------------------------------|
| OpenAI             | `openai.OpenAI`, `openai.OpenAIReasoning` | GPT-3.5, GPT-4, GPT-4 Turbo, modelli di reasoning o1/o3 |
| Anthropic          | `anthropic.Anthropic`     | Claude 3/3.5/4 (Opus, Sonnet, Haiku) |
| Azure OpenAI       | `azure.AzureOpenAI`       | Modelli OpenAI ospitati su Azure     |
| AWS Bedrock        | `bedrock.Bedrock`         | Modelli Claude, Llama, Titan    |
| Google Vertex AI   | `vertex.Vertex`           | Modelli PaLM, Gemini            |
| Cohere             | `cohere.Cohere`           | Modelli Command, Command R      |
| Replicate          | `replicate.Replicate`     | Modelli open ospitati su cloud       |
| HuggingFace        | `huggingface.InferenceAPI`, `huggingface.InferenceEndpoint`, `huggingface.Pipeline`, `huggingface.LLaVA` | API di inferenza HF, endpoint, pipeline, multimodale |
| Together AI        | `together.Together`       | Inferenza veloce per modelli OSS  |
| Anyscale           | `anyscale.Anyscale`       | Hosting di Llama e Mistral      |
| Groq               | `groq.Groq`               | Inferenza LPU ultraveloce       |
| Mistral            | `mistral.Mistral`         | Modelli API Mistral             |
| Fireworks          | `fireworks.Fireworks`     | Piattaforma di inferenza di produzione  |
| DeepInfra          | `deepinfra.DeepInfra`     | Inferenza GPU serverless       |
| NVIDIA NIM         | `nim.NIM`, `nim.NVOpenAICompletion`, `nim.NVMultimodal`, `nim.Vision` | Endpoint AI NVIDIA, multimodale |
| 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`         | Piattaforma IBM watsonx.ai        |
| LangChain          | `langchain.LangChain`     | Wrapper LLM LangChain          |
| LangChain Serve    | `langchain_serve.LangChainServe` | Endpoint LangChain Serve |
| Rasa               | `rasa.RasaRest`           | AI conversazionale Rasa         |
| GGML               | `ggml.Ggml`               | Inferenza di modelli locali GGML     |
| Function           | `function.Single`, `function.Multiple` | Generatori di funzioni personalizzate |
| Ollama             | `ollama.Ollama`, `ollama.OllamaChat` | Hosting di modelli locali    |
| LiteLLM            | `litellm.LiteLLM`         | Proxy API unificato              |
| REST API           | `rest.Rest`               | Endpoint REST personalizzati (supporto SSE) |
| Test               | `test.Blank`, `test.Repeat`, `test.Lipsum`, `test.Nones`, `test.Single`, `test.BlankVision` | Test e sviluppo |

Tutti i provider sono disponibili nel binario compilato. Configura tramite variabili d'ambiente o file di configurazione YAML. Consulta [Configurazione](#configuration) per i dettagli di configurazione.

## Utilizzo

### Sonda Singola```bash
# Test for DAN jailbreak
augustus scan openai.OpenAI \
  --probe dan.Dan_11_0 \
  --detector dan.DAN \
  --config-file config.yaml \
  --verbose

### Trasformazioni Buff

Applica trasformazioni dei prompt per testare tecniche di evasione:```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

### Endpoint REST personalizzati```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"
  }'

## Come Funziona

Augustus utilizza un'architettura a pipeline per testare gli LLM contro attacchi avversari:```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)

GOAT utilizza un approccio aggressivo e adattivo con 7 tecniche avversariali e il ragionamento Chain-of-Attack-Thought per cambiare dinamicamente strategia in base a ciò che funziona o fallisce.

- **Paper**: [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **Approccio**: Punta all'obiettivo fin dal turno 1 usando un framing indiretto, non menziona mai l'obiettivo direttamente al target
- **7 tecniche** in 3 categorie:
  - *Output Manipulation*: Refusal Suppression, Response Priming
  - *Safe Response Distractors*: Dual Response, Topic Splitting, Opposite Intent
  - *Fictional Scenarios*: Persona Modification, Hypothetical
- **Chain-of-Attack-Thought**: A ogni turno l'attaccante ragiona attraverso Observation → Thought → Strategy → Response prima di formulare il suo messaggio
- **Combinazione di tecniche**: Più tecniche possono essere combinate in un singolo turno per un effetto più forte
- **Punto di forza**: Raggiunge alti tassi di successo in meno turni (tipicamente 3-5) passando aggressivamente tra approcci fondamentalmente diversi```bash
augustus scan rest.Rest \
  --probe goat.Goat \
  --config-file goat.yaml \
  --html report.html -v

#### Utente Malizioso

L'Utente Malizioso simula una persona innocente e curiosa che sonda sottilmente i limiti dell'IA attraverso una conversazione naturale. A differenza delle strategie avversariali, la persona dell'attaccante è un utente occasionale che si sposta verso argomenti proibiti tramite un coinvolgimento apparentemente innocente.

- **Ispirato da**: [Tau-bench](https://github.com/sierra-research/tau-bench) e dalla strategia dell'utente malizioso di promptfoo
- **Approccio**: Fase di costruzione del rapporto → sondaggio dei limiti → spinta assertiva
- **7 tecniche**: Curiosità ingenua, fraintendimento deliberato, prova sociale, deriva graduale, appello emotivo, permesso presunto, ricontestualizzazione
- **Playbook specifici per obiettivo**: Script integrati per estrarre istruzioni di sistema, trovare segreti/flag e bypassare la policy sui contenuti
- **Turni predefiniti**: 5 (meno rispetto ad altre strategie — l'approccio sottile funziona rapidamente o per niente)
- **Punto di forza**: Efficace contro modelli addestrati a resistere a pattern avversariali evidenti — la persona casuale aggira le euristiche di "rilevamento degli attacchi"```bash
augustus scan rest.Rest \
  --probe mischievous.MischievousUser \
  --config-file mischievous.yaml \
  --html report.html -v

| Setting | Default | Descrizione |
|---------|---------|-------------|
| `goal` | (obbligatorio) | L'obiettivo che l'attaccante cerca di raggiungere |
| `max_turns` | 10 | Numero massimo di turni di conversazione prima dell'arresto |
| `success_threshold` | 0.8 | Punteggio del giudice (0.0-1.0) che attiva l'uscita anticipata |
| `max_refusal_retries` | 10 | Tentativi di riformulazione per turno quando il target rifiuta |
| `attack_max_attempts` | 5 | Nuovi tentativi per errori di parsing JSON dell'LLM attaccante |
| `use_secondary_judge` | true | Abilita il giudice secondario per rilevare falsi negativi |
| `max_backtracks` | 10 | Rollback a livello di turno in caso di rifiuto (solo Hydra) |
| `enable_fast_refusal` | true | Rilevamento del rifiuto basato su pattern prima della chiamata al giudice LLM |
| `enable_scan_memory` | false | Apprendimento tra casi di test (condivide tattiche tra i probe) |
| `stateful` | false | Disabilita il backtracking per target con stato |
| `exclude_target_output` | false | Nasconde le risposte del target dal feedback dell'attaccante (modalità privacy) |
| `attacker_model` | (auto) | Sovrascrive il nome del modello attaccante per il dimensionamento della finestra di contesto |

#### Risoluzione dei Problemi Multi-Turno

| Sintomo | Causa Probabile | Soluzione |
|---------|-------------|-----|
| `no turns completed (attacker_parse_failures=N)` | L'LLM attaccante restituisce JSON non valido | Usa un modello attaccante più potente (GPT-4, Claude Opus). Aumenta `attack_max_attempts`. |
| `no turns completed (target_empty=N)` | Il target restituisce risposte vuote/null | Verifica che l'endpoint del target risponda. Controlla il template di configurazione REST. |
| Tutti i turni ottengono punteggio 0.0 | Obiettivo troppo vago o attaccante non coinvolto | Rendi `goal` più specifico. Prova una strategia diversa. |
| Punteggi alti ma nessun successo | `success_threshold` troppo alto | Abbassa `success_threshold` da 0.8 a 0.6-0.7 |
| Esecuzioni troppo lunghe/costose | Troppi turni e nuovi tentativi | Riduci `max_turns` (prova 5). Imposta `enable_fast_refusal: true`. |
| Hydra continua a fare backtracking | Il target rifiuta tutto | Prova `stateful: true` o passa alla strategia Mischievous |

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

### Variabili d'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 TLS automaticamente disabilitata per l'ispezione del proxy
- Supporto HTTP/2 abilitato per API moderne
- Risposte Server-Sent Events (SSE) rilevate e analizzate automaticamente

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

**Codici di uscita:**

| Codice | Significato |
|------|---------|
| 0 | Successo - scansione completata |
| 1 | Errore di scansione/runtime |
| 2 | Errore di validazione/utilizzo |

## FAQ

### Come si confronta Augustus con garak?

Augustus è una reimplementazione nativa in Go ispirata a [garak](https://github.com/NVIDIA/garak) (lo scanner di vulnerabilità LLM basato su Python di NVIDIA). Differenze principali:
- **Prestazioni**: binario Go vs interprete Python — esecuzione più rapida e minore utilizzo di memoria
- **Distribuzione**: singolo binario senza dipendenze runtime vs pacchetto Python con installazione tramite pip
- **Concorrenza**: pool di goroutine Go (parallelismo tra probe) vs pool di multiprocessing Python (parallelismo all'interno dei probe)
- **Copertura dei probe**: Augustus ha oltre 210 probe; garak ha oltre 160 probe con un pedigree di ricerca più lungo e un articolo pubblicato (arXiv:2406.11036)
- **Copertura dei provider**: Augustus ha 28 provider; garak ha oltre 35 varianti di generatori su 22 moduli provider

### Posso testare modelli locali senza chiavi API?

Sì! Usa l'integrazione Ollama per il test di modelli locali:```bash
# No API key needed
augustus scan ollama.OllamaChat \
  --probe dan.Dan_11_0 \
  --config '{"model":"llama3.2:3b"}'

### Augustus è adatto per ambienti di produzione?

Sì, Augustus è progettato per l'uso in produzione con:
- Scansione concorrente con limiti configurabili
- Limitazione della velocità per rispettare le quote API
- Gestione dei timeout per probe di lunga durata
- Logica di retry per guasti transitori
- Logging strutturato per l'osservabilità

## Risoluzione dei problemi

### Errore: "Limite di velocità API superato"

**Causa**: Troppe richieste concorrenti o troppe richieste al minuto.

**Soluzioni**:
1. Riduci la concorrenza: `--concurrency 5`
2. Utilizza le impostazioni di limitazione della velocità specifiche del provider nella configurazione YAML:   ```yaml
   generators:
     openai.OpenAI:
       rate_limit: 10  # requests per minute

### Errore: "invalid API key" o "authentication failed"

**Causa**: Credenziali API mancanti o non valide.

**Soluzioni**:
1. Verifica che la variabile d'ambiente sia impostata: `echo $OPENAI_API_KEY`
2. Controlla eventuali errori di battitura nel file di configurazione
3. Assicurati che la chiave API abbia i permessi richiesti
4. Per Ollama, assicurati che il servizio sia in esecuzione: `ollama serve`

### Errore: "probe not found" o "detector not found"

**Causa**: Errore di battitura nel nome o probe non registrato.

**Soluzione**:```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 di Benchmark (DevPod)

Un ambiente di sviluppo cloud pronto all'uso per il benchmarking degli LLM è disponibile tramite [DevPod](https://devpod.sh/). Esso fornisce un container remoto con Augustus, Ollama, Go e tutte le dipendenze preinstallate.```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

L'ambiente funziona anche come un [dev container](https://containers.dev/) standard: apri il repository in VS Code o Cursor e seleziona la configurazione CPU o GPU da `.devcontainer/`.

## Sicurezza

Augustus è progettato **esclusivamente per test di sicurezza autorizzati**.

- Augustus invia prompt avversari agli LLM che specifichi: assicurati sempre di avere l'autorizzazione
- Non testare mai sistemi che non possiedi o per cui non hai un permesso esplicito
- Alcune sonde generano contenuti offensivi di proposito (per testare i filtri di sicurezza)
- I risultati possono contenere contenuti dannosi prodotti dagli LLM target

Segnala problemi di sicurezza tramite [GitHub Issues](https://github.com/praetorian-inc/augustus/issues).

## Supporto

Se trovi Augustus utile, considera:

- Dargli una **stella** su GitHub
- [Aprire un issue](https://github.com/praetorian-inc/augustus/issues) per bug o richieste di funzionalità
- [Contribuire](https://github.com/praetorian-inc/augustus/blob/main/CONTRIBUTING.md) con nuove sonde, rilevatori o integrazioni di provider

[![Star History Chart](https://api.star-history.com/svg?repos=praetorian-inc/augustus&type=Date)](https://star-history.com/#praetorian-inc/augustus&Date)

## Licenza

[Apache 2.0](https://github.com/praetorian-inc/augustus/blob/main/LICENSE) - Praetorian Security, Inc.

---

**Creato da [Praetorian](https://www.praetorian.com/)** - Soluzioni di Sicurezza Offensiva