या स्रोत से बनाएँ:```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build

### उदाहरण आउटपुट```
+--------------+-------------+--------+-------+--------+
| 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   |
+--------------+-------------+--------+-------+--------+

## समर्थित प्रदाता

Augustus में 43 जनरेटर वेरिएंट के साथ 28 LLM प्रदाता श्रेणियाँ शामिल हैं:

| प्रदाता           | जनरेटर नाम         | नोट्स                          |
|--------------------|---------------------------|--------------------------------|
| OpenAI             | `openai.OpenAI`, `openai.OpenAIReasoning` | GPT-3.5, GPT-4, GPT-4 Turbo, o1/o3 reasoning मॉडल |
| Anthropic          | `anthropic.Anthropic`     | Claude 3/3.5/4 (Opus, Sonnet, Haiku) |
| Azure OpenAI       | `azure.AzureOpenAI`       | Azure-होस्टेड OpenAI मॉडल     |
| AWS Bedrock        | `bedrock.Bedrock`         | Claude, Llama, Titan मॉडल    |
| Google Vertex AI   | `vertex.Vertex`           | PaLM, Gemini मॉडल            |
| Cohere             | `cohere.Cohere`           | Command, Command R मॉडल      |
| Replicate          | `replicate.Replicate`     | क्लाउड-होस्टेड ओपन मॉडल       |
| HuggingFace        | `huggingface.InferenceAPI`, `huggingface.InferenceEndpoint`, `huggingface.Pipeline`, `huggingface.LLaVA` | HF Inference API, एंडपॉइंट, पाइपलाइन, मल्टीमॉडल |
| Together AI        | `together.Together`       | OSS मॉडल के लिए तेज़ inference  |
| Anyscale           | `anyscale.Anyscale`       | Llama और Mistral होस्टिंग      |
| Groq               | `groq.Groq`               | अल्ट्रा-फास्ट LPU inference       |
| Mistral            | `mistral.Mistral`         | Mistral API मॉडल             |
| Fireworks          | `fireworks.Fireworks`     | प्रोडक्शन inference प्लेटफ़ॉर्म  |
| DeepInfra          | `deepinfra.DeepInfra`     | सर्वरलेस GPU inference       |
| NVIDIA NIM         | `nim.NIM`, `nim.NVOpenAICompletion`, `nim.NVMultimodal`, `nim.Vision` | NVIDIA AI एंडपॉइंट, मल्टीमॉडल |
| NVIDIA NeMo        | `nemo.NeMo`               | NVIDIA NeMo फ्रेमवर्क          |
| NVIDIA NVCF        | `nvcf.NvcfChat`, `nvcf.NvcfCompletion` | NVIDIA क्लाउड फ़ंक्शन   |
| NeMo Guardrails    | `guardrails.NeMoGuardrails` | NVIDIA NeMo Guardrails       |
| IBM watsonx        | `watsonx.WatsonX`         | IBM watsonx.ai प्लेटफ़ॉर्म        |
| LangChain          | `langchain.LangChain`     | LangChain LLM रैपर          |
| LangChain Serve    | `langchain_serve.LangChainServe` | LangChain Serve एंडपॉइंट |
| Rasa               | `rasa.RasaRest`           | Rasa संवादात्मक AI         |
| GGML               | `ggml.Ggml`               | GGML लोकल मॉडल inference     |
| Function           | `function.Single`, `function.Multiple` | कस्टम फ़ंक्शन जनरेटर |
| Ollama             | `ollama.Ollama`, `ollama.OllamaChat` | लोकल मॉडल होस्टिंग    |
| LiteLLM            | `litellm.LiteLLM`         | यूनिफाइड API प्रॉक्सी              |
| REST API           | `rest.Rest`               | कस्टम REST एंडपॉइंट (SSE समर्थन) |
| Test               | `test.Blank`, `test.Repeat`, `test.Lipsum`, `test.Nones`, `test.Single`, `test.BlankVision` | परीक्षण और विकास |

सभी प्रदाता संकलित बाइनरी में उपलब्ध हैं। पर्यावरण चर या YAML कॉन्फ़िगरेशन फ़ाइलों के माध्यम से कॉन्फ़िगर करें। सेटअप विवरण के लिए [कॉन्फ़िगरेशन](#configuration) देखें।

## उपयोग

### एकल प्रोब```bash
# Test for DAN jailbreak
augustus scan openai.OpenAI \
  --probe dan.Dan_11_0 \
  --detector dan.DAN \
  --config-file config.yaml \
  --verbose

### बफ़ ट्रांसफ़ॉर्मेशन

एवेज़न तकनीकों का परीक्षण करने के लिए प्रॉम्प्ट ट्रांसफ़ॉर्मेशन लागू करें:```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

### कस्टम REST एंडपॉइंट्स```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"
  }'

## यह कैसे काम करता है

Augustus प्रतिकूल हमलों के विरुद्ध LLM का परीक्षण करने के लिए पाइपलाइन आर्किटेक्चर का उपयोग करता है:```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 (जनरेटिव ऑफेंसिव एजेंट टेस्टर)

GOAT 7 आक्रामक तकनीकों और Chain-of-Attack-Thought तर्क के साथ एक आक्रामक, अनुकूली दृष्टिकोण का उपयोग करता है, ताकि जो काम करता है या विफल होता है उसके आधार पर गतिशील रूप से रणनीतियाँ बदल सके।

- **पेपर**: [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **दृष्टिकोण**: टर्न 1 से ही अप्रत्यक्ष फ्रेमिंग का उपयोग करके उद्देश्य को लक्षित करता है, लक्ष्य को कभी भी सीधे लक्ष्य का उल्लेख नहीं करता
- **3 श्रेणियों में 7 तकनीकें**:
  - *आउटपुट मैनिपुलेशन*: रिफ्यूज़ल सप्रेशन, रिस्पॉन्स प्राइमिंग
  - *सेफ रिस्पॉन्स डिस्ट्रैक्टर्स*: डुअल रिस्पॉन्स, टॉपिक स्प्लिटिंग, अपोज़िट इंटेंट
  - *फिक्शनल सिनेरियोज़*: पर्सोना मॉडिफिकेशन, हाइपोथेटिकल
- **Chain-of-Attack-Thought**: प्रत्येक टर्न में हमलावर अपना संदेश तैयार करने से पहले Observation → Thought → Strategy → Response के माध्यम से तर्क करता है
- **तकनीक स्टैकिंग**: मजबूत प्रभाव के लिए एक ही टर्न में कई तकनीकों को जोड़ा जा सकता है
- **ताकत**: मौलिक रूप से भिन्न दृष्टिकोणों के बीच आक्रामक रूप से स्विच करके कम टर्न (आमतौर पर 3-5) में उच्च सफलता दर प्राप्त करता है```bash
augustus scan rest.Rest \
  --probe goat.Goat \
  --config-file goat.yaml \
  --html report.html -v

#### शरारती उपयोगकर्ता

शरारती उपयोगकर्ता एक मासूम, जिज्ञासु व्यक्ति का अनुकरण करता है जो स्वाभाविक बातचीत के माध्यम से सूक्ष्मता से AI की सीमाओं का परीक्षण करता है। प्रतिकूल रणनीतियों के विपरीत, यह हमलावर व्यक्तित्व एक सामान्य उपयोगकर्ता है जो प्रतीत होने वाले मासूम जुड़ाव के माध्यम से प्रतिबंधित विषयों की ओर बढ़ता है।

- **प्रेरणा**: [Tau-bench](https://github.com/sierra-research/tau-bench) और promptfoo की शरारती-उपयोगकर्ता रणनीति
- **दृष्टिकोण**: संबंध-निर्माण चरण → सीमा परीक्षण → मुखर दबाव
- **7 तकनीकें**: भोली जिज्ञासा, जानबूझकर गलतफहमी, सामाजिक प्रमाण, क्रमिक बहाव, भावनात्मक अपील, मान ली गई अनुमति, पुनर्संदर्भीकरण
- **लक्ष्य-विशिष्ट प्लेबुक**: सिस्टम निर्देश निकालने, रहस्य/फ्लैग खोजने, और सामग्री नीति को बायपास करने के लिए अंतर्निहित स्क्रिप्ट
- **डिफ़ॉल्ट टर्न**: 5 (अन्य रणनीतियों से कम — सूक्ष्म दृष्टिकोण या तो जल्दी काम करता है या बिल्कुल नहीं)
- **ताकत**: स्पष्ट प्रतिकूल पैटर्न का विरोध करने के लिए प्रशिक्षित मॉडलों के खिलाफ प्रभावी — आकस्मिक व्यक्तित्व "हमले का पता लगाने" वाले ह्यूरिस्टिक्स को बायपास करता है```bash
augustus scan rest.Rest \
  --probe mischievous.MischievousUser \
  --config-file mischievous.yaml \
  --html report.html -v

| `goal` | (आवश्यक) | वह उद्देश्य जिसे हमलावर हासिल करने का प्रयास करता है |
|---------|---------|-------------|
| `max_turns` | 10 | रुकने से पहले अधिकतम वार्तालाप चरणों की संख्या |
| `success_threshold` | 0.8 | जज स्कोर (0.0-1.0) जो जल्दी बाहर निकलने को ट्रिगर करता है |
| `max_refusal_retries` | 10 | प्रति चरण पुनः-वाक्यांश प्रयास जब लक्ष्य मना कर देता है |
| `attack_max_attempts` | 5 | हमलावर LLM JSON पार्सिंग विफलताओं के लिए पुनः प्रयास |
| `use_secondary_judge` | true | गलत नकारात्मक पकड़ने के लिए द्वितीयक जज सक्षम करें |
| `max_backtracks` | 10 | मना करने पर चरण-स्तरीय रोलबैक (केवल Hydra) |
| `enable_fast_refusal` | true | LLM जज कॉल से पहले पैटर्न-आधारित मना करने का पता लगाना |
| `enable_scan_memory` | false | क्रॉस-टेस्ट-केस सीखना (प्रोब्स के बीच रणनीतियाँ साझा करता है) |
| `stateful` | false | स्टेटफुल लक्ष्यों के लिए बैकट्रैकिंग अक्षम करें |
| `exclude_target_output` | false | हमलावर फीडबैक से लक्ष्य प्रतिक्रियाएँ छिपाएँ (गोपनीयता मोड) |
| `attacker_model` | (स्वचालित) | संदर्भ विंडो आकार के लिए हमलावर मॉडल नाम ओवरराइड करें |

#### मल्टी-टर्न समस्या निवारण

| लक्षण | संभावित कारण | समाधान |
|---------|-------------|-----|
| `no turns completed (attacker_parse_failures=N)` | हमलावर LLM अमान्य JSON लौटा रहा है | एक मजबूत हमलावर मॉडल (GPT-4, Claude Opus) का उपयोग करें। `attack_max_attempts` बढ़ाएँ। |
| `no turns completed (target_empty=N)` | लक्ष्य खाली/null प्रतिक्रियाएँ लौटा रहा है | जाँचें कि लक्ष्य एंडपॉइंट प्रतिक्रिया दे रहा है। REST कॉन्फ़िग टेम्पलेट सत्यापित करें। |
| सभी चरण 0.0 स्कोर करते हैं | लक्ष्य बहुत अस्पष्ट है या हमलावर संलग्न नहीं हो रहा है | `goal` को अधिक विशिष्ट बनाएँ। अलग रणनीति आज़माएँ। |
| उच्च स्कोर लेकिन कोई सफलता नहीं | `success_threshold` बहुत अधिक है | `success_threshold` को 0.8 से घटाकर 0.6-0.7 करें |
| रन बहुत लंबे/महंगे हैं | बहुत अधिक चरण और पुनः प्रयास | `max_turns` घटाएँ (5 आज़माएँ)। `enable_fast_refusal: true` सेट करें। |
| Hydra बार-बार बैकट्रैक करता रहता है | लक्ष्य सब कुछ मना कर देता है | `stateful: true` आज़माएँ या 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

### पर्यावरण चर```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 सत्यापन स्वचालित रूप से अक्षम किया गया
- आधुनिक APIs के लिए HTTP/2 समर्थन सक्षम
- सर्वर-प्रेषित इवेंट (SSE) प्रतिक्रियाएँ स्वचालित रूप से पहचानी और पार्स की जाती हैं

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

**एग्ज़िट कोड:**

| कोड | अर्थ |
|------|---------|
| 0 | सफल - स्कैन पूर्ण हुआ |
| 1 | स्कैन/रनटाइम त्रुटि |
| 2 | सत्यापन/उपयोग त्रुटि |

## FAQ

### Augustus की तुलना garak से कैसे की जाती है?

Augustus एक Go-नेटिव पुनःकार्यान्वयन है जो [garak](https://github.com/NVIDIA/garak) (NVIDIA का Python-आधारित LLM भेद्यता स्कैनर) से प्रेरित है। मुख्य अंतर:
- **प्रदर्शन**: Go बाइनरी बनाम Python इंटरप्रेटर — तेज़ निष्पादन और कम मेमोरी उपयोग
- **वितरण**: बिना किसी रनटाइम निर्भरता के एकल बाइनरी बनाम pip install वाला Python पैकेज
- **समवर्तीता**: Go goroutine पूल (क्रॉस-प्रोब समानांतरता) बनाम Python multiprocessing पूल (इंट्रा-प्रोब समानांतरता)
- **प्रोब कवरेज**: Augustus में 210+ प्रोब हैं; garak में 160+ प्रोब हैं जिनकी लंबी शोध वंशावली और प्रकाशित पेपर (arXiv:2406.11036) है
- **प्रदाता कवरेज**: Augustus में 28 प्रदाता हैं; garak में 22 प्रदाता मॉड्यूल में 35+ जनरेटर वेरिएंट हैं

### क्या मैं API कुंजियों के बिना स्थानीय मॉडल का परीक्षण कर सकता हूँ?

हाँ! स्थानीय मॉडल परीक्षण के लिए Ollama एकीकरण का उपयोग करें:```bash
# No API key needed
augustus scan ollama.OllamaChat \
  --probe dan.Dan_11_0 \
  --config '{"model":"llama3.2:3b"}'

### क्या Augustus उत्पादन वातावरण के लिए उपयुक्त है?

हाँ, Augustus निम्नलिखित सुविधाओं के साथ उत्पादन उपयोग के लिए डिज़ाइन किया गया है:
- कॉन्फ़िगर करने योग्य सीमाओं के साथ समवर्ती स्कैनिंग
- API कोटा का सम्मान करने के लिए दर सीमित करना
- लंबे समय तक चलने वाले प्रोब के लिए टाइमआउट हैंडलिंग
- क्षणिक विफलताओं के लिए पुनः प्रयास तर्क
- अवलोकन क्षमता के लिए संरचित लॉगिंग

## समस्या निवारण

### त्रुटि: "API दर सीमा पार हो गई"

**कारण**: बहुत अधिक समवर्ती अनुरोध या प्रति मिनट अनुरोध।

**समाधान**:
1. समवर्तीता कम करें: `--concurrency 5`
2. YAML कॉन्फ़िग में प्रदाता-विशिष्ट दर सीमा सेटिंग्स का उपयोग करें:   ```yaml
   generators:
     openai.OpenAI:
       rate_limit: 10  # requests per minute

### त्रुटि: "invalid API key" या "authentication failed"

**कारण**: API क्रेडेंशियल गायब या अमान्य हैं।

**समाधान**:
1. सत्यापित करें कि पर्यावरण चर सेट है: `echo $OPENAI_API_KEY`
2. कॉन्फ़िग फ़ाइल में टाइपो की जाँच करें
3. सुनिश्चित करें कि API key के पास आवश्यक अनुमतियाँ हैं
4. Ollama के लिए, सुनिश्चित करें कि सेवा चल रही है: `ollama serve`

### त्रुटि: "probe not found" या "detector not found"

**कारण**: नाम में टाइपो या probe पंजीकृत नहीं है।

**समाधान**:```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

### बेंचमार्क वातावरण (DevPod)

LLM की बेंचमार्किंग के लिए एक तैयार-से-उपयोग क्लाउड डेवलपमेंट वातावरण [DevPod](https://devpod.sh/) के माध्यम से उपलब्ध है। यह Augustus, Ollama, Go, और सभी निर्भरताओं के साथ पहले से इंस्टॉल एक रिमोट कंटेनर प्रदान करता है।```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

यह वातावरण एक मानक [dev container](https://containers.dev/) के रूप में भी काम करता है — रिपॉजिटरी को VS Code या Cursor में खोलें और `.devcontainer/` से CPU या GPU कॉन्फ़िगरेशन चुनें।

## सुरक्षा

Augustus केवल **अधिकृत सुरक्षा परीक्षण** के लिए डिज़ाइन किया गया है।

- Augustus आपके द्वारा निर्दिष्ट LLMs को adversarial प्रॉम्प्ट भेजता है — हमेशा सुनिश्चित करें कि आपके पास प्राधिकरण है
- उन सिस्टमों का परीक्षण कभी न करें जिनके आप मालिक नहीं हैं या जिनके परीक्षण की स्पष्ट अनुमति आपके पास नहीं है
- कुछ प्रोब जानबूझकर आपत्तिजनक सामग्री उत्पन्न करते हैं (सुरक्षा फ़िल्टर के परीक्षण के लिए)
- परिणामों में लक्ष्य LLMs द्वारा उत्पन्न हानिकारक सामग्री हो सकती है

सुरक्षा संबंधी मुद्दों की रिपोर्ट [GitHub Issues](https://github.com/praetorian-inc/augustus/issues) के माध्यम से करें।

## सहायता

यदि आपको Augustus उपयोगी लगता है, तो कृपया विचार करें:

- GitHub पर इसे **स्टार** देना
- बग या फीचर अनुरोधों के लिए [एक issue खोलना](https://github.com/praetorian-inc/augustus/issues)
- नए प्रोब, डिटेक्टर, या प्रदाता एकीकरण में [योगदान देना](https://github.com/praetorian-inc/augustus/blob/main/CONTRIBUTING.md)

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

## लाइसेंस

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

---

**[Praetorian](https://www.praetorian.com/) द्वारा निर्मित** - Offensive Security Solutions