O compilar desde el código fuente:```bash
git clone https://github.com/praetorian-inc/augustus.git
cd augustus
make build

### Salida de ejemplo```
+--------------+-------------+--------+-------+--------+
| 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   |
+--------------+-------------+--------+-------+--------+

## Proveedores Compatibles

Augustus incluye 28 categorías de proveedores de LLM con 43 variantes de generadores:

| Proveedor          | Nombre(s) del Generador         | Notas                          |
|--------------------|---------------------------|--------------------------------|
| OpenAI             | `openai.OpenAI`, `openai.OpenAIReasoning` | GPT-3.5, GPT-4, GPT-4 Turbo, modelos de razonamiento o1/o3 |
| Anthropic          | `anthropic.Anthropic`     | Claude 3/3.5/4 (Opus, Sonnet, Haiku) |
| Azure OpenAI       | `azure.AzureOpenAI`       | Modelos OpenAI alojados en Azure     |
| AWS Bedrock        | `bedrock.Bedrock`         | Modelos Claude, Llama, Titan    |
| Google Vertex AI   | `vertex.Vertex`           | Modelos PaLM, Gemini            |
| Cohere             | `cohere.Cohere`           | Modelos Command, Command R      |
| Replicate          | `replicate.Replicate`     | Modelos abiertos alojados en la nube       |
| HuggingFace        | `huggingface.InferenceAPI`, `huggingface.InferenceEndpoint`, `huggingface.Pipeline`, `huggingface.LLaVA` | API de inferencia de HF, endpoints, pipelines, multimodal |
| Together AI        | `together.Together`       | Inferencia rápida para modelos OSS  |
| Anyscale           | `anyscale.Anyscale`       | Alojamiento de Llama y Mistral      |
| Groq               | `groq.Groq`               | Inferencia LPU ultrarrápida       |
| Mistral            | `mistral.Mistral`         | Modelos API de Mistral             |
| Fireworks          | `fireworks.Fireworks`     | Plataforma de inferencia en producción  |
| DeepInfra          | `deepinfra.DeepInfra`     | Inferencia GPU sin servidor       |
| NVIDIA NIM         | `nim.NIM`, `nim.NVOpenAICompletion`, `nim.NVMultimodal`, `nim.Vision` | Endpoints de IA de NVIDIA, multimodal |
| NVIDIA NeMo        | `nemo.NeMo`               | Framework NVIDIA NeMo          |
| NVIDIA NVCF        | `nvcf.NvcfChat`, `nvcf.NvcfCompletion` | Funciones en la nube de NVIDIA   |
| NeMo Guardrails    | `guardrails.NeMoGuardrails` | NeMo Guardrails de NVIDIA       |
| IBM watsonx        | `watsonx.WatsonX`         | Plataforma IBM watsonx.ai        |
| LangChain          | `langchain.LangChain`     | Wrapper LLM de LangChain          |
| LangChain Serve    | `langchain_serve.LangChainServe` | Endpoints de LangChain Serve |
| Rasa               | `rasa.RasaRest`           | IA conversacional de Rasa         |
| GGML               | `ggml.Ggml`               | Inferencia de modelos locales GGML     |
| Function           | `function.Single`, `function.Multiple` | Generadores de funciones personalizadas |
| Ollama             | `ollama.Ollama`, `ollama.OllamaChat` | Alojamiento de modelos locales    |
| LiteLLM            | `litellm.LiteLLM`         | Proxy API unificado              |
| REST API           | `rest.Rest`               | Endpoints REST personalizados (soporte SSE) |
| Test               | `test.Blank`, `test.Repeat`, `test.Lipsum`, `test.Nones`, `test.Single`, `test.BlankVision` | Pruebas y desarrollo |

Todos los proveedores están disponibles en el binario compilado. Configure mediante variables de entorno o archivos de configuración YAML. Consulte [Configuración](#configuration) para detalles de configuración.

## Uso

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

### Transformaciones de Buff

Aplicar transformaciones de prompts para probar técnicas de evasión:```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

### Endpoints REST personalizados```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"
  }'

## Cómo funciona

Augustus utiliza una arquitectura de pipeline para probar los LLMs contra ataques 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 utiliza un enfoque agresivo y adaptativo con 7 técnicas adversariales y razonamiento de Cadena de Pensamiento de Ataque para cambiar dinámicamente de estrategia según lo que funciona o falla.

- **Paper**: [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **Enfoque**: Apunta al objetivo desde el turno 1 usando un marco indirecto, nunca menciona la meta directamente al objetivo
- **7 técnicas** en 3 categorías:
  - *Manipulación de Salida*: Supresión de Rechazo, Preparación de Respuesta
  - *Distractores de Respuesta Segura*: Respuesta Dual, División de Tema, Intención Opuesta
  - *Escenarios Ficcionales*: Modificación de Personalidad, Hipotético
- **Cadena de Pensamiento de Ataque**: Cada turno el atacante razona a través de Observación → Pensamiento → Estrategia → Respuesta antes de elaborar su mensaje
- **Apilamiento de técnicas**: Se pueden combinar múltiples técnicas en un solo turno para un efecto más fuerte
- **Fortaleza**: Logra altas tasas de éxito en menos turnos (típicamente 3-5) cambiando agresivamente entre enfoques fundamentalmente diferentes```bash
augustus scan rest.Rest \
  --probe goat.Goat \
  --config-file goat.yaml \
  --html report.html -v

#### Usuario Travieso

El Usuario Travieso simula a una persona inocente y curiosa que sonda sutilmente los límites de la IA a través de una conversación natural. A diferencia de las estrategias adversariales, la persona atacante es un usuario casual que deriva hacia temas prohibidos mediante un compromiso aparentemente inocente.

- **Inspirado por**: [Tau-bench](https://github.com/sierra-research/tau-bench) y la estrategia de usuario travieso de promptfoo
- **Enfoque**: Fase de construcción de rapport → sondeo de límites → presión asertiva
- **7 técnicas**: Curiosidad ingenua, malentendido deliberado, prueba social, deriva gradual, apelación emocional, permiso asumido, recontextualización
- **Guiones específicos para objetivos**: Scripts integrados para extraer instrucciones del sistema, encontrar secretos/banderas y eludir la política de contenido
- **Turnos predeterminados**: 5 (menos que otras estrategias — el enfoque sutil funciona rápidamente o no funciona en absoluto)
- **Fortaleza**: Eficaz contra modelos entrenados para resistir patrones adversariales evidentes — la persona casual elude las heurísticas de "detección de ataques"```bash
augustus scan rest.Rest \
  --probe mischievous.MischievousUser \
  --config-file mischievous.yaml \
  --html report.html -v

| Setting | Predeterminado | Descripción |
|---------|---------|-------------|
| `goal` | (obligatorio) | El objetivo que el atacante intenta lograr |
| `max_turns` | 10 | Máximo de turnos de conversación antes de detenerse |
| `success_threshold` | 0.8 | Puntuación del juez (0.0-1.0) que provoca una salida anticipada |
| `max_refusal_retries` | 10 | Intentos de reformulación por turno cuando el objetivo se niega |
| `attack_max_attempts` | 5 | Reintentos por fallos de parseo JSON del LLM atacante |
| `use_secondary_judge` | true | Habilitar juez secundario para detectar falsos negativos |
| `max_backtracks` | 10 | Retrocesos a nivel de turno en caso de negativa (solo Hydra) |
| `enable_fast_refusal` | true | Detección de rechazo basada en patrones antes de llamar al juez LLM |
| `enable_scan_memory` | false | Aprendizaje entre casos de prueba (comparte tácticas entre sondas) |
| `stateful` | false | Deshabilitar retroceso para objetivos con estado |
| `exclude_target_output` | false | Ocultar respuestas del objetivo de la retroalimentación del atacante (modo privacidad) |
| `attacker_model` | (automático) | Sobrescribir el nombre del modelo atacante para el tamaño de la ventana de contexto |

#### Solución de problemas de múltiples turnos

| Síntoma | Causa probable | Solución |
|---------|----------------|----------|
| `no turns completed (attacker_parse_failures=N)` | El LLM atacante devuelve JSON inválido | Usar un modelo atacante más fuerte (GPT-4, Claude Opus). Aumentar `attack_max_attempts`. |
| `no turns completed (target_empty=N)` | El objetivo devuelve respuestas vacías/nulas | Verificar que el endpoint del objetivo responda. Comprobar la plantilla de configuración REST. |
| All turns score 0.0 | Objetivo demasiado vago o atacante no se involucra | Hacer `goal` más específico. Probar estrategia diferente. |
| High scores but no success | `success_threshold` demasiado alto | Reducir `success_threshold` de 0.8 a 0.6-0.7 |
| Runs too long / expensive | Demasiados turnos y reintentos | Reducir `max_turns` (probar 5). Establecer `enable_fast_refusal: true`. |
| Hydra keeps backtracking | El objetivo rechaza todo | Probar `stateful: true` o cambiar a estrategia Mischievous |

## Arquitectura```
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 de Entorno```bash
# API Keys
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export COHERE_API_KEY="..."

# Debug mode
export AUGUSTUS_DEBUG=true

- La verificación TLS se desactiva automáticamente para inspección de proxy
- Soporte HTTP/2 habilitado para APIs modernas
- Respuestas de Eventos Enviados por el Servidor (SSE) detectadas y analizadas automáticamente

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

**Códigos de salida:**

| Código | Significado |
|--------|-------------|
| 0 | Éxito - escaneo completado |
| 1 | Error de escaneo/tiempo de ejecución |
| 2 | Error de validación/uso |

## Preguntas frecuentes

### ¿Cómo se compara Augustus con garak?

Augustus es una reimplementación nativa en Go inspirada en [garak](https://github.com/NVIDIA/garak) (el escáner de vulnerabilidades de LLM basado en Python de NVIDIA). Diferencias clave:
- **Rendimiento**: Binario Go vs intérprete Python — ejecución más rápida y menor uso de memoria
- **Distribución**: Binario único sin dependencias de tiempo de ejecución vs paquete Python con instalación pip
- **Concurrencia**: Grupos de goroutines de Go (paralelismo entre sondas) vs grupos de multiprocesamiento de Python (paralelismo dentro de la sonda)
- **Cobertura de sondas**: Augustus tiene más de 210 sondas; garak tiene más de 160 sondas con un pedigrí de investigación más largo y un artículo publicado (arXiv:2406.11036)
- **Cobertura de proveedores**: Augustus tiene 28 proveedores; garak tiene más de 35 variantes de generadores en 22 módulos de proveedores

### ¿Puedo probar modelos locales sin claves de API?

¡Sí! Utiliza la integración con Ollama para probar modelos locales:```bash
# No API key needed
augustus scan ollama.OllamaChat \
  --probe dan.Dan_11_0 \
  --config '{"model":"llama3.2:3b"}'

### ¿Es Augustus adecuado para entornos de producción?

Sí, Augustus está diseñado para uso en producción con:
- Escaneo concurrente con límites configurables
- Limitación de velocidad para respetar las cuotas de API
- Manejo de tiempos de espera para sondas de larga duración
- Lógica de reintento para fallos transitorios
- Registro estructurado para observabilidad

## Solución de problemas

### Error: "API rate limit exceeded"

**Causa**: Demasiadas solicitudes concurrentes o solicitudes por minuto.

**Soluciones**:
1. Reducir concurrencia: `--concurrency 5`
2. Usar ajustes de límite de velocidad específicos del proveedor en la configuración YAML:   ```yaml
   generators:
     openai.OpenAI:
       rate_limit: 10  # requests per minute

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

**Causa**: Credenciales de API faltantes o inválidas.

**Soluciones**:
1. Verificar que la variable de entorno esté configurada: `echo $OPENAI_API_KEY`
2. Revisar errores tipográficos en el archivo de configuración
3. Asegurarse de que la clave API tenga los permisos necesarios
4. Para Ollama, asegurarse de que el servicio esté en ejecución: `ollama serve`

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

**Causa**: Error tipográfico en el nombre o sonda no registrada.

**Solución**:```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

### Entorno de Benchmark (DevPod)

Hay disponible un entorno de desarrollo en la nube listo para usar para evaluar LLMs a través de [DevPod](https://devpod.sh/). Aprovisiona un contenedor remoto con Augustus, Ollama, Go y todas las dependencias preinstaladas.```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

El entorno también funciona como un [contenedor de desarrollo](https://containers.dev/) estándar — abre el repositorio en VS Code o Cursor y selecciona la configuración de CPU o GPU desde `.devcontainer/`.

## Seguridad

Augustus está diseñado **solo para pruebas de seguridad autorizadas**.

- Augustus envía prompts adversariales a los LLMs que especifiques: asegúrate siempre de tener autorización
- Nunca pruebes sistemas que no poseas o para los que no tengas permiso explícito
- Algunos probes generan contenido ofensivo por diseño (para probar filtros de seguridad)
- Los resultados pueden contener contenido dañino producido por los LLMs objetivo

Reporta problemas de seguridad a través de [GitHub Issues](https://github.com/praetorian-inc/augustus/issues).

## Soporte

Si encuentras útil a Augustus, considera:

- Darle una **estrella** en GitHub
- [Abrir un issue](https://github.com/praetorian-inc/augustus/issues) para errores o solicitudes de funciones
- [Contribuir](https://github.com/praetorian-inc/augustus/blob/HEAD/CONTRIBUTING.md) con nuevos probes, detectores o integraciones de proveedores

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

## Licencia

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

---

**Construido por [Praetorian](https://www.praetorian.com/)** - Soluciones de Seguridad Ofensiva