Or build from source:

```bash
git clone https://github.com/example/repo.git
cd repo
make build

### Utilisation de base```bash
export OPENAI_API_KEY="your-api-key"
augustus scan openai.OpenAI \
  --probe dan.Dan_11_0 \
  --detector dan.DAN \
  --verbose

### Liste des capacités disponibles```bash
# List all registered probes, detectors, generators, harnesses, and buffs
augustus list

### Sondes multiples```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

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

**Clés de configuration REST :**
- `uri` : Point de terminaison de l’API cible (obligatoire)
- `method` : Méthode HTTP (par défaut : POST)
- `headers` : En-têtes HTTP sous forme de paires clé-valeur
- `req_template` : Corps de requête brut avec l’espace réservé `$INPUT`
- `req_template_json_object` : Corps de requête JSON (sérialisé automatiquement, utilisez `$INPUT` dans les chaînes)
- `response_json` : Analyser la réponse en JSON (par défaut : false)
- `response_json_field` : Chemin JSONPath à extraire (par exemple, `$.data.text` ou un simple nom de champ)
- `api_key` : Clé API pour la substitution de l’espace réservé `$KEY`
- `proxy` : URL du proxy HTTP pour l’inspection du trafic

### Options avancées```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"}'

subgraph Scanner
    B
    C
    D
    E
end

### Pipeline de Scan

1. **Sélection des sondes** : Choisir les sondes par nom, motif glob, ou `--all`
2. **Transformation des prompts** : Transformer optionnellement les prompts (encodage, reformulation, traduction, poétisation)
3. **Appel au générateur** : Envoyer les prompts adversariaux au LLM cible via son intégration de fournisseur
4. **Analyse par le détecteur** : Analyser les réponses à l'aide de correspondance de motifs, de LLM-en-tant-que-juge, ou de détecteurs spécialisés
5. **Enregistrement des résultats** : Noter chaque tentative et produire la sortie dans le format demandé
6. **Moteur d'attaque** : Pour les sondes itératives (PAIR, TAP), le moteur d'attaque à tour unique affine les prompts au fil des itérations avec élagage des candidats et notation basée sur un juge
7. **Moteur multi-tours** : Pour les sondes conversationnelles (Crescendo, GOAT), le moteur multi-tours conserve l'historique complet de la conversation avec la cible à chaque tour, avec détection des refus et adaptation dynamique

### Stratégies d'attaque multi-tours

Les attaques multi-tours maintiennent une conversation persistante avec le LLM cible, exploitant le fait que les modèles peuvent divulguer des informations progressivement au fil des tours qu'ils refuseraient dans un prompt unique. Le moteur multi-tours utilise trois LLM : un **attaquant** (génère les questions), une **cible** (le système testé), et un **juge** (note la progression et détecte les refus).

#### Crescendo

Crescendo utilise une escalade graduelle (technique du pied-dans-la-porte) pour faire passer progressivement une conversation de sujets bénins vers un objectif interdit.

- **Article** : [Russinovich et al., 2024](https://arxiv.org/abs/2404.01833)
- **Approche** : Commence par des questions réellement bénignes et éducatives, puis augmente progressivement la spécificité sur de nombreux tours
- **Schéma d'escalade** : Contexte historique → mécanismes techniques → détails spécifiques → demandes directes formulées comme des suivis naturels
- **Atout** : Efficace contre les modèles qui suivent le ton de la conversation — le changement graduel évite de déclencher les filtres de sécurité```bash
augustus scan rest.Rest \
  --probe crescendo.Crescendo \
  --config-file crescendo.yaml \
  --html report.html -v

#### Hydra

Hydra maintient un chemin de conversation unique et annule entièrement les tours lorsque la cible refuse, demandant à l'attaquant une approche complètement différente. Contrairement à Crescendo/GOAT (qui reformulent en cas de refus), le retour en arrière d'Hydra supprime complètement les tours refusés de la vue de la cible.

- **Approche** : Chemin unique avec retour en arrière au niveau du tour — les tours refusés sont effacés et remplacés
- **Techniques** : Décomposition (diviser l'objectif en sous-questions innocentes), exploitation du contexte (s'appuyer sur les propres mots de la cible), simulation d'autorité, cadrage émotionnel, normalisation progressive
- **Caractéristique clé** : `max_backtracks` contrôle combien de fois Hydra peut effacer et réessayer un tour
- **Mode avec état** : Définissez `stateful: true` pour les cibles où les messages ne peuvent pas être retirés (désactive le retour en arrière)
- **Atout** : Garde l'historique de conversation de la cible propre — la cible ne voit jamais les approches échouées, empêchant l'escalade défensive```bash
augustus scan rest.Rest \
  --probe hydra.Hydra \
  --config-file hydra.yaml \
  --html report.html -v

#### Guide de sélection des stratégies

| Stratégie | Tours | Style | Idéal pour | Coût |
|----------|-------|-------|----------|------|
| `crescendo.Crescendo` | 10 | Escalade progressive | Modèles avec filtres de sécurité basés sur le suivi du ton | Moyen (10 tours × 3 appels LLM) |
| `goat.Goat` | 10 | Changement de technique agressif | Résultats rapides, modèles vulnérables aux astuces de cadrage | Moyen-Élevé (surcharge de raisonnement technique) |
| `hydra.Hydra` | 10 | Retour en arrière en cas de refus | Modèles obstinés qui refusent fréquemment | Élevé (le retour en arrière ajoute des tentatives) |
| `mischievous.MischievousUser` | 5 | Sondage de personnalité décontracté | Modèles entraînés contre les schémas adversariaux | Faible (5 tours, approche subtile) |

**Décision rapide** :
- Commencez par **Crescendo** — c'est la stratégie la plus polyvalente
- Essayez **GOAT** si Crescendo est trop lent (GOAT réussit généralement en 3 à 5 tours)
- Utilisez **Hydra** si la cible refuse fréquemment (le retour en arrière garde la conversation propre)
- Utilisez **Mischievous** pour les cibles dotées d'une forte détection de schémas adversariaux (la personnalité contourne les heuristiques)

#### Configuration multi-tours

Les quatre stratégies partagent la même structure de configuration :```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

### Décisions de conception clés

- **Analyse concurrente** avec des pools de goroutines bornés via `errgroup`
- **Enregistrement de type plugin** utilisant les fonctions `init()` de Go pour les sondes, générateurs, détecteurs, buffs et harnais
- **Moteur d’attaque itératif** avec gestion de conversations multi-flux, élagage de candidats et notation basée sur un juge pour PAIR/TAP
- **Moteur d’attaque multi-tours** avec historique de conversation persistant, détection de refus, conception agnostique à la stratégie pour Crescendo/GOAT
- **Modèles de sondes YAML** (style Nuclei) pour des définitions déclaratives de sondes aux côtés des sondes basées sur Go
- **Pré-filtrage Aho-Corasick** pour une correspondance rapide de mots-clés dans les détecteurs

## Configuration

### Fichier de configuration YAML

Créez un fichier `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"

### Configuration du proxy

Acheminez le trafic HTTP via un proxy (par exemple, Burp Suite) pour inspection :```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"}'

**Commandes :**```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)

### Comment ajouter des sondes personnalisées ?

1. Créez un nouveau fichier Go dans `internal/probes/`
2. Implémentez l'interface `probes.Probe`
3. Enregistrez-la à l'aide de `registry.RegisterProbe()` dans une fonction `init()`
4. Recompilez : `make build`

Consultez [CONTRIBUTING.md](https://github.com/praetorian-inc/augustus/blob/main/CONTRIBUTING.md) pour des instructions détaillées.

### Quels formats de sortie sont pris en charge ?

Augustus prend en charge quatre formats de sortie :

| Format | Option | Cas d'utilisation |
|--------|--------|-------------------|
| Table | `--format table` | Sortie terminal lisible par un humain |
| JSON | `--format json` | Objet JSON unique pour l'analyse |
| JSONL | `--format jsonl` | JSON délimité par des lignes pour le streaming |
| HTML | `--html report.html` | Rapports visuels pour les parties prenantes |

### Comment tester plusieurs modèles à la fois ?```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

### Erreur : « clé API invalide » ou « échec de l’authentification »

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

**Solutions** :
1. Vérifiez que la variable d’environnement est définie : `echo $OPENAI_API_KEY`
2. Recherchez les fautes de frappe dans le fichier de configuration
3. Assurez-vous que la clé API dispose des autorisations requises
4. Pour Ollama, assurez-vous que le service est en cours d’exécution : `ollama serve`

### Erreur : « sonde introuvable » ou « détecteur introuvable »

**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 référence (DevPod)

Un environnement de développement cloud prêt à l'emploi pour l'évaluation comparative des LLM 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 [conteneur de développement](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 invites adversariales 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 par conception (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, pensez à :

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

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

## Licence

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

---

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