Ou construire à partir des sources :```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build

### Exemple de sortie```
+--------------+-------------+--------+-------+--------+
| 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   |
+--------------+-------------+--------+-------+--------+

## Fournisseurs pris en charge

Augustus inclut 28 catégories de fournisseurs LLM avec 43 variantes de générateurs :

| Fournisseur       | Nom(s) du générateur         | Notes                          |
|-------------------|------------------------------|--------------------------------|
| OpenAI            | `openai.OpenAI`, `openai.OpenAIReasoning` | Modèles GPT-3.5, GPT-4, GPT-4 Turbo, o1/o3 de raisonnement |
| Anthropic         | `anthropic.Anthropic`        | Claude 3/3.5/4 (Opus, Sonnet, Haiku) |
| Azure OpenAI      | `azure.AzureOpenAI`          | Modèles OpenAI hébergés sur Azure |
| AWS Bedrock       | `bedrock.Bedrock`            | Modèles Claude, Llama, Titan |
| Google Vertex AI  | `vertex.Vertex`              | Modèles PaLM, Gemini |
| Cohere            | `cohere.Cohere`              | Modèles Command, Command R |
| Replicate         | `replicate.Replicate`        | Modèles open source hébergés dans le cloud |
| HuggingFace       | `huggingface.InferenceAPI`, `huggingface.InferenceEndpoint`, `huggingface.Pipeline`, `huggingface.LLaVA` | API HF Inference, endpoints, pipelines, multimodal |
| Together AI       | `together.Together`          | Inférence rapide pour modèles OSS |
| Anyscale          | `anyscale.Anyscale`          | Hébergement Llama et Mistral |
| Groq              | `groq.Groq`                  | Inférence LPU ultra-rapide |
| Mistral           | `mistral.Mistral`            | Modèles API Mistral |
| Fireworks         | `fireworks.Fireworks`        | Plateforme d'inférence de production |
| DeepInfra         | `deepinfra.DeepInfra`        | Inférence GPU sans serveur |
| NVIDIA NIM        | `nim.NIM`, `nim.NVOpenAICompletion`, `nim.NVMultimodal`, `nim.Vision` | Endpoints IA NVIDIA, multimodal |
| NVIDIA NeMo       | `nemo.NeMo`                  | Framework NVIDIA NeMo |
| NVIDIA NVCF       | `nvcf.NvcfChat`, `nvcf.NvcfCompletion` | Fonctions cloud NVIDIA |
| NeMo Guardrails   | `guardrails.NeMoGuardrails`  | NVIDIA NeMo Guardrails |
| IBM watsonx       | `watsonx.WatsonX`            | Plateforme IBM watsonx.ai |
| LangChain         | `langchain.LangChain`        | Wrapper LLM LangChain |
| LangChain Serve   | `langchain_serve.LangChainServe` | Endpoints LangChain Serve |
| Rasa              | `rasa.RasaRest`              | IA conversationnelle Rasa |
| GGML              | `ggml.Ggml`                  | Inférence de modèles locaux GGML |
| Function          | `function.Single`, `function.Multiple` | Générateurs de fonctions personnalisés |
| Ollama            | `ollama.Ollama`, `ollama.OllamaChat` | Hébergement local de modèles |
| LiteLLM           | `litellm.LiteLLM`            | Proxy API unifié |
| REST API          | `rest.Rest`                  | Endpoints REST personnalisés (support SSE) |
| Test              | `test.Blank`, `test.Repeat`, `test.Lipsum`, `test.Nones`, `test.Single`, `test.BlankVision` | Tests et développement |

Tous les fournisseurs sont disponibles dans le binaire compilé. Configurez via des variables d'environnement ou des fichiers de configuration YAML. Voir [Configuration](#configuration) pour les détails de configuration.

## Utilisation

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

### Buff Transformations

Appliquer des transformations de prompt pour tester les techniques d'évasion :```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

### Points de terminaison REST personnalisés```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"
  }'

## Comment ça marche

Augustus utilise une architecture en pipeline pour tester les LLM contre des attaques adversariales :```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 utilise une approche agressive et adaptative avec 7 techniques adverses et un raisonnement de type Chaîne-de-Pensée-d'Attaque pour changer dynamiquement de stratégie selon ce qui fonctionne ou échoue.

- **Article** : [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **Approche** : Vise l'objectif dès le premier tour en utilisant un cadrage indirect, sans jamais mentionner directement le but à la cible
- **7 techniques** réparties en 3 catégories :
  - *Manipulation de la sortie* : Refusal Suppression, Response Priming
  - *Distracteurs de réponse sûre* : Dual Response, Topic Splitting, Opposite Intent
  - *Scénarios fictifs* : Persona Modification, Hypothétique
- **Chaîne-de-Pensée-d'Attaque** : À chaque tour, l'attaquant raisonne via Observation → Pensée → Stratégie → Réponse avant de générer son message
- **Empilement de techniques** : Plusieurs techniques peuvent être combinées en un seul tour pour un effet plus fort
- **Force** : Atteint des taux de succès élevés en peu de tours (généralement 3-5) en basculant agressivement entre des approches fondamentalement différentes```bash
augustus scan rest.Rest \
  --probe goat.Goat \
  --config-file goat.yaml \
  --html report.html -v

#### Utilisateur Malicieux

L'Utilisateur Malicieux simule une personne innocente et curieuse qui sonde subtilement les limites de l'IA à travers une conversation naturelle. Contrairement aux stratégies adversariales, le personnage attaquant est un utilisateur occasionnel qui dérive vers des sujets interdits par un engagement apparemment innocent.

- **Inspiré par** : [Tau-bench](https://github.com/sierra-research/tau-bench) et la stratégie 'utilisateur malicieux' de promptfoo
- **Approche** : Phase de création de lien → sondage des limites → poussée assertive
- **7 techniques** : Curiosité naïve, malentendu délibéré, preuve sociale, dérive progressive, appel émotionnel, permission présumée, recontextualisation
- **Manuels spécifiques aux objectifs** : Scripts intégrés pour extraire les instructions système, trouver des secrets/flags et contourner la politique de contenu
- **Nombre de tours par défaut** : 5 (moins que d'autres stratégies — l'approche subtile fonctionne soit rapidement, soit pas du tout)
- **Force** : Efficace contre les modèles entraînés à résister aux motifs adversariales évidents — le personnage occasionnel contourne les heuristiques de 'détection d'attaque'```bash
augustus scan rest.Rest \
  --probe mischievous.MischievousUser \
  --config-file mischievous.yaml \
  --html report.html -v

| Paramètre | Défaut | Description |
|---------|---------|-------------|
| `goal` | (requis) | L'objectif que l'attaquant cherche à atteindre |
| `max_turns` | 10 | Nombre maximum de tours de conversation avant arrêt |
| `success_threshold` | 0.8 | Score du juge (0.0-1.0) déclenchant une sortie anticipée |
| `max_refusal_retries` | 10 | Tentatives de reformulation par tour lorsque la cible refuse |
| `attack_max_attempts` | 5 | Nouvelles tentatives en cas d'échec d'analyse JSON du LLM attaquant |
| `use_secondary_judge` | true | Active le juge secondaire pour détecter les faux négatifs |
| `max_backtracks` | 10 | Retours en arrière au niveau du tour en cas de refus (Hydra uniquement) |
| `enable_fast_refusal` | true | Détection de refus basée sur des motifs avant l'appel au juge LLM |
| `enable_scan_memory` | false | Apprentissage inter-cas de test (partage des tactiques entre sondes) |
| `stateful` | false | Désactive le retour en arrière pour les cibles avec état |
| `exclude_target_output` | false | Cache les réponses de la cible dans le retour à l'attaquant (mode privé) |
| `attacker_model` | (auto) | Remplace le nom du modèle attaquant pour le dimensionnement de la fenêtre de contexte |

#### Dépannage multi-tours

| Symptôme | Cause probable | Correctif |
|---------|-------------|-----|
| `no turns completed (attacker_parse_failures=N)` | Le LLM attaquant renvoie un JSON invalide | Utilisez un modèle attaquant plus puissant (GPT-4, Claude Opus). Augmentez `attack_max_attempts`. |
| `no turns completed (target_empty=N)` | La cible renvoie des réponses vides/nulles | Vérifiez que le point d'accès cible répond. Vérifiez le modèle de configuration REST. |
| Tous les tours obtiennent un score de 0.0 | Objectif trop vague ou attaquant pas assez engageant | Rendez `goal` plus spécifique. Essayez une stratégie différente. |
| Scores élevés mais pas de réussite | `success_threshold` trop élevé | Abaissez `success_threshold` de 0.8 à 0.6-0.7 |
| Exécutions trop longues / coûteuses | Trop de tours et de tentatives | Réduisez `max_turns` (essayez 5). Définissez `enable_fast_refusal: true`. |
| Hydra continue de faire des retours arrière | La cible refuse tout | Essayez `stateful: true` ou passez à la stratégie Mischievous |```
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

### Variables d'environnement```bash
# API Keys
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export COHERE_API_KEY="..."

# Debug mode
export AUGUSTUS_DEBUG=true

- Vérification TLS automatiquement désactivée pour l'inspection proxy
- Prise en charge HTTP/2 activée pour les API modernes
- Réponses Server-Sent Events (SSE) automatiquement détectées et analysées

### Référence 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

**Codes de sortie :**

| Code | Signification |
|------|---------|
| 0 | Succès - analyse terminée |
| 1 | Erreur d'analyse/exécution |
| 2 | Erreur de validation/utilisation |

## FAQ

### Comment Augustus se compare-t-il à garak ?

Augustus est une réimplémentation native en Go inspirée par [garak](https://github.com/NVIDIA/garak) (le scanner de vulnérabilités LLM basé sur Python de NVIDIA). Différences clés :
- **Performance** : Binaire Go vs interpréteur Python — exécution plus rapide et utilisation mémoire réduite
- **Distribution** : Binaire unique sans dépendances d'exécution vs paquet Python avec pip install
- **Concurrence** : Pools de goroutines Go (parallélisme inter-sonde) vs pools multiprocessing Python (parallélisme intra-sonde)
- **Couverture des sondes** : Augustus a plus de 210 sondes ; garak a plus de 160 sondes avec un historique de recherche plus long et un article publié (arXiv:2406.11036)
- **Couverture des fournisseurs** : Augustus a 28 fournisseurs ; garak a plus de 35 variantes de générateurs réparties sur 22 modules fournisseurs

### Puis-je tester des modèles locaux sans clés API ?

Oui ! Utilisez l'intégration Ollama pour tester des modèles locaux :```bash
# No API key needed
augustus scan ollama.OllamaChat \
  --probe dan.Dan_11_0 \
  --config '{"model":"llama3.2:3b"}'

### Augusto est-il adapté aux environnements de production ?

Oui, Augusto est conçu pour une utilisation en production avec :
- Analyse concurrente avec limites configurables
- Limitation de débit pour respecter les quotas API
- Gestion des délais d'attente pour les sondes longues
- Logique de nouvelle tentative pour les échecs transitoires
- Journaux structurés pour l'observabilité

## Dépannage

### Erreur : "API rate limit exceeded"

**Cause** : Trop de requêtes simultanées ou de requêtes par minute.

**Solutions** :
1. Réduire la concurrence : `--concurrency 5`
2. Utiliser les paramètres de limitation de débit spécifiques au fournisseur dans la configuration YAML :   ```yaml
   generators:
     openai.OpenAI:
       rate_limit: 10  # requests per minute

### Error: "clé API invalide" ou "échec d'authentification"

**Cause** : identifiants API manquants ou invalides.

**Solutions** :
1. Vérifier que la variable d'environnement est définie : `echo $OPENAI_API_KEY`
2. Vérifier les fautes de frappe dans le fichier de configuration
3. S'assurer que la clé API a les permissions requises
4. Pour Ollama, s'assurer que le service est en cours d'exécution : `ollama serve`

### Error: "sonde non trouvée" ou "détecteur non trouvé"

**Cause** : faute de frappe dans le nom ou sonde non enregistrée.

**Solution** :```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

### Environnement de benchmark (DevPod)

Un environnement de développement cloud prêt à l'emploi pour le benchmark des LLMs est disponible via [DevPod](https://devpod.sh/). Il provisionne un conteneur distant avec Augustus, Ollama, Go et toutes les dépendances pré-installées.```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'environnement fonctionne également comme un [dev container](https://containers.dev/) standard — ouvrez le dépôt dans VS Code ou Cursor et sélectionnez la configuration CPU ou GPU depuis `.devcontainer/`.

## Sécurité

Augustus est conçu pour **les tests de sécurité autorisés uniquement**.

- Augustus envoie des prompts adverses aux LLM que vous spécifiez - assurez-vous toujours d'avoir l'autorisation
- Ne testez jamais des systèmes que vous ne possédez pas ou pour lesquels vous n'avez pas d'autorisation explicite
- Certaines sondes génèrent du contenu offensant intentionnellement (pour tester les filtres de sécurité)
- Les résultats peuvent contenir du contenu nuisible produit par les LLM cibles

Signalez les problèmes de sécurité via [GitHub Issues](https://github.com/praetorian-inc/augustus/issues).

## Support

Si vous trouvez Augustus utile, veuillez considérer :

- Lui donner une **étoile** sur GitHub
- [Ouvrir un ticket](https://github.com/praetorian-inc/augustus/issues) pour les bugs ou demandes de fonctionnalités
- [Contribuer](https://github.com/praetorian-inc/augustus/blob/HEAD/CONTRIBUTING.md) de nouvelles sondes, détecteurs ou intégrations de fournisseurs

[![Star History Chart](https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg)](https://star-history.com/#praetorian-inc/augustus&Date)

## Licence

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

---

**Construit par [Praetorian](https://www.praetorian.com/)** - Solutions de sécurité offensive