Oder aus dem Quellcode erstellen:```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build

### Beispiel Ausgabe```
+--------------+-------------+--------+-------+--------+
| 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   |
+--------------+-------------+--------+-------+--------+

## Unterstützte Anbieter

Augustus umfasst 28 LLM-Anbieterkategorien mit 43 Generatorvarianten:

| Anbieter           | Generator-Name(n)         | Anmerkungen                          |
|--------------------|---------------------------|--------------------------------------|
| OpenAI             | `openai.OpenAI`, `openai.OpenAIReasoning` | GPT-3.5, GPT-4, GPT-4 Turbo, o1/o3 Reasoning-Modelle |
| Anthropic          | `anthropic.Anthropic`     | Claude 3/3.5/4 (Opus, Sonnet, Haiku) |
| Azure OpenAI       | `azure.AzureOpenAI`       | Azure-gehostete OpenAI-Modelle       |
| AWS Bedrock        | `bedrock.Bedrock`         | Claude, Llama, Titan-Modelle         |
| Google Vertex AI   | `vertex.Vertex`           | PaLM, Gemini-Modelle                 |
| Cohere             | `cohere.Cohere`           | Command, Command R-Modelle           |
| Replicate          | `replicate.Replicate`     | Cloud-gehostete offene Modelle       |
| HuggingFace        | `huggingface.InferenceAPI`, `huggingface.InferenceEndpoint`, `huggingface.Pipeline`, `huggingface.LLaVA` | HF Inference API, Endpoints, Pipelines, multimodal |
| Together AI        | `together.Together`       | Schnelle Inferenz für OSS-Modelle    |
| Anyscale           | `anyscale.Anyscale`       | Llama- und Mistral-Hosting           |
| Groq               | `groq.Groq`               | Ultra-schnelle LPU-Inferenz          |
| Mistral            | `mistral.Mistral`         | Mistral-API-Modelle                  |
| Fireworks          | `fireworks.Fireworks`     | Produktions-Inferenz-Plattform       |
| DeepInfra          | `deepinfra.DeepInfra`     | Serverlose GPU-Inferenz              |
| NVIDIA NIM         | `nim.NIM`, `nim.NVOpenAICompletion`, `nim.NVMultimodal`, `nim.Vision` | NVIDIA KI-Endpunkte, multimodal |
| NVIDIA NeMo        | `nemo.NeMo`               | NVIDIA NeMo-Framework                |
| NVIDIA NVCF        | `nvcf.NvcfChat`, `nvcf.NvcfCompletion` | NVIDIA Cloud-Funktionen           |
| NeMo Guardrails    | `guardrails.NeMoGuardrails` | NVIDIA NeMo Guardrails             |
| IBM watsonx        | `watsonx.WatsonX`         | IBM watsonx.ai-Plattform             |
| LangChain          | `langchain.LangChain`     | LangChain LLM-Wrapper                |
| LangChain Serve    | `langchain_serve.LangChainServe` | LangChain Serve-Endpunkte        |
| Rasa               | `rasa.RasaRest`           | Rasa Conversational AI               |
| GGML               | `ggml.Ggml`               | GGML lokale Modell-Inferenz          |
| Function           | `function.Single`, `function.Multiple` | Benutzerdefinierte Funktionsgeneratoren |
| Ollama             | `ollama.Ollama`, `ollama.OllamaChat` | Lokales Modell-Hosting          |
| LiteLLM            | `litellm.LiteLLM`         | Einheitlicher API-Proxy              |
| REST API           | `rest.Rest`               | Benutzerdefinierte REST-Endpunkte (SSE-Unterstützung) |
| Test               | `test.Blank`, `test.Repeat`, `test.Lipsum`, `test.Nones`, `test.Single`, `test.BlankVision` | Testen und Entwicklung |

Alle Anbieter sind in der kompilierten Binärdatei verfügbar. Konfigurieren Sie über Umgebungsvariablen oder YAML-Konfigurationsdateien. Siehe [Konfiguration](#configuration) für Einrichtungsdetails.

## Nutzung

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

### Buff Transformations

Wenden Sie Prompt-Transformationen an, um Umgehungstechniken zu testen:```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

### Benutzerdefinierte REST-Endpunkte```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"
  }'

## Funktionsweise

Augustus verwendet eine Pipeline-Architektur, um LLMs gegen adversarial Angriffe zu testen:```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 verwendet einen aggressiven, adaptiven Ansatz mit 7 adversarialen Techniken und Chain-of-Attack-Thought-Reasoning, um dynamisch zwischen Strategien zu wechseln, basierend darauf, was funktioniert oder fehlschlägt.

- **Paper**: [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **Ansatz**: Verfolgt das Ziel ab Zug 1 mittels indirekter Rahmung, erwähnt das Ziel nie direkt gegenüber dem Ziel
- **7 Techniken** in 3 Kategorien:
  - *Output Manipulation*: Refusal Suppression, Response Priming
  - *Safe Response Distractors*: Dual Response, Topic Splitting, Opposite Intent
  - *Fictional Scenarios*: Persona Modification, Hypothetical
- **Chain-of-Attack-Thought**: In jedem Zug denkt der Angreifer durch Observation → Thought → Strategy → Response, bevor er seine Nachricht formuliert
- **Technik-Stapelung**: Mehrere Techniken können in einem einzigen Zug kombiniert werden, um eine stärkere Wirkung zu erzielen
- **Stärke**: Erzielt hohe Erfolgsraten in weniger Zügen (typischerweise 3-5), indem es aggressiv zwischen grundlegend verschiedenen Ansätzen wechselt```bash
augustus scan rest.Rest \
  --probe goat.Goat \
  --config-file goat.yaml \
  --html report.html -v

#### Schelmischer Benutzer

Der schelmische Benutzer simuliert eine harmlose, neugierige Person, die subtil die Grenzen der KI durch natürliche Konversation auslotet. Im Gegensatz zu adversarialen Strategien ist die Angreifer-Persona ein beiläufiger Benutzer, der durch scheinbar harmlose Interaktion in Richtung verbotener Themen abdriftet.

- **Inspiriert von**: [Tau-bench](https://github.com/sierra-research/tau-bench) und promptfoo's mischievous-user-Strategie
- **Ansatz**: Rapportaufbau-Phase → Grenzabtastung → durchsetzungsstarkes Vorstoßen
- **7 Techniken**: Naive Neugier, bewusstes Missverständnis, sozialer Beweis, allmähliches Abgleiten, emotionale Ansprache, angenommene Erlaubnis, Rekontextualisierung
- **Zielspezifische Handbücher**: Eingebaute Skripte zum Extrahieren von Systemanweisungen, Finden von Geheimnissen/Flags und Umgehen der Inhaltsrichtlinie
- **Standardanzahl Züge**: 5 (weniger als andere Strategien — der subtile Ansatz funktioniert entweder schnell oder gar nicht)
- **Stärke**: Wirksam gegen Modelle, die darauf trainiert sind, offensichtliche adversarialen Mustern zu widerstehen — die lässige Persona umgeht Heuristiken zur "Angriffserkennung"```bash
augustus scan rest.Rest \
  --probe mischievous.MischievousUser \
  --config-file mischievous.yaml \
  --html report.html -v

| Einstellung | Standard | Beschreibung |
|---------|---------|-------------|
| `goal` | (required) | Das Ziel, das der Angreifer erreichen möchte |
| `max_turns` | 10 | Maximale Anzahl an Gesprächsrunden vor dem Stoppen |
| `success_threshold` | 0.8 | Bewertungswert (0.0-1.0), der einen vorzeitigen Ausstieg auslöst |
| `max_refusal_retries` | 10 | Umformulierungsversuche pro Runde, wenn das Ziel ablehnt |
| `attack_max_attempts` | 5 | Wiederholungsversuche bei JSON-Parsing-Fehlern des Angreifer-LLM |
| `use_secondary_judge` | true | Sekundären Bewerter aktivieren, um falsch negative Ergebnisse zu erkennen |
| `max_backtracks` | 10 | Rücksetzungen auf Rundenebene bei Ablehnung (nur Hydra) |
| `enable_fast_refusal` | true | Musterbasierte Erkennung von Ablehnungen vor dem Aufruf des LLM-Bewerters |
| `enable_scan_memory` | false | Lernübergreifend über Testfälle (teilt Taktiken zwischen Sonden) |
| `stateful` | false | Rücksetzungen für zustandsbehaftete Ziele deaktivieren |
| `exclude_target_output` | false | Zielantworten aus dem Feedback des Angreifers ausblenden (Datenschutzmodus) |
| `attacker_model` | (auto) | Modellnamen des Angreifers überschreiben für die Größenanpassung des Kontextfensters |

#### Fehlerbehebung bei mehreren Runden

| Symptom | Wahrscheinliche Ursache | Behebung |
|---------|-------------|-----|
| `no turns completed (attacker_parse_failures=N)` | Angreifer-LLM gibt ungültiges JSON zurück | Verwenden Sie ein stärkeres Angreifer-Modell (GPT-4, Claude Opus). Erhöhen Sie `attack_max_attempts`. |
| `no turns completed (target_empty=N)` | Ziel gibt leere/Null-Antworten zurück | Überprüfen Sie, ob der Ziel-Endpunkt antwortet. Überprüfen Sie die REST-Konfigurationsvorlage. |
| All turns score 0.0 | Ziel zu vage oder Angreifer nicht engagiert | Machen Sie das `goal` spezifischer. Versuchen Sie eine andere Strategie. |
| High scores but no success | `success_threshold` zu hoch | Senken Sie `success_threshold` von 0.8 auf 0.6-0.7 |
| Runs too long / expensive | Zu viele Runden und Wiederholungen | Reduzieren Sie `max_turns` (versuchen Sie 5). Setzen Sie `enable_fast_refusal: true`. |
| Hydra keeps backtracking | Ziel lehnt alles ab | Versuchen Sie `stateful: true` oder wechseln Sie zur Mischievous-Strategie |

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

### Umgebungsvariablen```bash
# API Keys
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export COHERE_API_KEY="..."

# Debug mode
export AUGUSTUS_DEBUG=true

- TLS-Verifizierung automatisch deaktiviert für Proxy-Inspektion
- HTTP/2-Unterstützung aktiviert für moderne APIs
- Server-Sent Events (SSE)-Antworten automatisch erkannt und geparst

### CLI-Referenz```
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

**Exit-Codes:**

| Code | Bedeutung |
|------|---------|
| 0 | Erfolg - Scan abgeschlossen |
| 1 | Scan-/Laufzeitfehler |
| 2 | Validierungs-/Nutzungsfehler |

## FAQ

### Wie schneidet Augustus im Vergleich zu garak ab?

Augustus ist eine in Go native implementierte Neuauflage, inspiriert von [garak](https://github.com/NVIDIA/garak) (NVIDIAs Python-basiertem LLM-Schwachstellenscanner). Hauptunterschiede:
- **Leistung**: Go-Binärdatei vs. Python-Interpreter — schnellere Ausführung und geringerer Speicherverbrauch
- **Verteilung**: Einzelne Binärdatei ohne Laufzeitabhängigkeiten vs. Python-Paket mit pip-Installation
- **Nebenläufigkeit**: Go-Goroutine-Pools (Parallelität zwischen Probes) vs. Python-Multiprocessing-Pools (Parallelität innerhalb von Probes)
- **Probe-Abdeckung**: Augustus hat über 210 Probes; garak hat über 160 Probes mit einer längeren Forschungshistorie und veröffentlichtem Paper (arXiv:2406.11036)
- **Provider-Abdeckung**: Augustus hat 28 Provider; garak hat über 35 Generator-Varianten in 22 Provider-Modulen

### Kann ich lokale Modelle ohne API-Schlüssel testen?

Ja! Nutzen Sie die Ollama-Integration für lokale Modelltests:```bash
# No API key needed
augustus scan ollama.OllamaChat \
  --probe dan.Dan_11_0 \
  --config '{"model":"llama3.2:3b"}'

### Ist Augustus für Produktionsumgebungen geeignet?

Ja, Augustus ist für den Produktionseinsatz konzipiert mit:
- Gleichzeitiges Scannen mit konfigurierbaren Grenzen
- Ratenbegrenzung zur Einhaltung von API-Kontingenten
- Timeout-Behandlung für langlebige Sonden
- Wiederholungslogik für vorübergehende Fehler
- Strukturiertes Logging für Beobachtbarkeit

## Fehlerbehebung

### Fehler: "API rate limit exceeded"

**Ursache**: Zu viele gleichzeitige Anfragen oder Anfragen pro Minute.

**Lösungen**:
1. Nebenläufigkeit reduzieren: `--concurrency 5`
2. Anbieterspezifische Ratenbegrenzungseinstellungen in der YAML-Konfiguration verwenden:   ```yaml
   generators:
     openai.OpenAI:
       rate_limit: 10  # requests per minute

### Fehler: "ungültiger API-Schlüssel" oder "Authentifizierung fehlgeschlagen"

**Ursache**: Fehlende oder ungültige API-Anmeldedaten.

**Lösungen**:
1. Überprüfen Sie, ob die Umgebungsvariable gesetzt ist: `echo $OPENAI_API_KEY`
2. Überprüfen Sie die Konfigurationsdatei auf Tippfehler
3. Stellen Sie sicher, dass der API-Schlüssel die erforderlichen Berechtigungen hat
4. Für Ollama stellen Sie sicher, dass der Dienst läuft: `ollama serve`

### Fehler: "Sonde nicht gefunden" oder "Detektor nicht gefunden"

**Ursache**: Tippfehler im Namen oder Sonde nicht registriert.

**Lösung**:```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

### Benchmark-Umgebung (DevPod)

Eine einsatzbereite Cloud-Entwicklungsumgebung zum Benchmarking von LLMs ist über [DevPod](https://devpod.sh/) verfügbar. Es stellt einen Remote-Container mit Augustus, Ollama, Go und allen vorinstallierten Abhängigkeiten bereit.```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

Die Umgebung funktioniert auch als standardmäßiger [Dev-Container](https://containers.dev/) — öffnen Sie das Repo in VS Code oder Cursor und wählen Sie die CPU- oder GPU-Konfiguration aus `.devcontainer/`.

## Security

Augustus ist nur für **autorisierte Sicherheitstests** konzipiert.

- Augustus sendet gegnerische Eingabeaufforderungen an von Ihnen angegebene LLMs – stellen Sie stets sicher, dass Sie dazu autorisiert sind
- Testen Sie niemals Systeme, die Sie nicht besitzen oder für die Sie keine ausdrückliche Erlaubnis haben
- Einige Sonden erzeugen absichtlich anstößige Inhalte (zum Testen von Sicherheitsfiltern)
- Ergebnisse können schädliche Inhalte enthalten, die von Ziel-LLMs erzeugt wurden

Melden Sie Sicherheitsprobleme über [GitHub Issues](https://github.com/praetorian-inc/augustus/issues).

## Support

Wenn Sie Augustus nützlich finden, ziehen Sie bitte Folgendes in Betracht:

- Geben Sie ihm einen **Stern** auf GitHub
- [Eröffnen Sie ein Issue](https://github.com/praetorian-inc/augustus/issues) für Fehler oder Feature-Anfragen
- [Tragen Sie](https://github.com/praetorian-inc/augustus/blob/HEAD/CONTRIBUTING.md) neue Sonden, Detektoren oder Provider-Integrationen bei

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

## License

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

---

**Entwickelt von [Praetorian](https://www.praetorian.com/)** - Offensive Security Solutions