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

### Ejemplo de Salida```
+--------------+-------------+--------+-------+--------+
| 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 de 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 de la API de Mistral             |
| Fireworks          | `fireworks.Fireworks`     | Plataforma de inferencia de 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` | NVIDIA Cloud Functions   |
| NeMo Guardrails    | `guardrails.NeMoGuardrails` | NVIDIA NeMo Guardrails       |
| IBM watsonx        | `watsonx.WatsonX`         | Plataforma IBM watsonx.ai        |
| LangChain          | `langchain.LangChain`     | Envoltorio 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 local    |
| LiteLLM            | `litellm.LiteLLM`         | Proxy de 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. Configúrelos mediante variables de entorno o archivos de configuración YAML. Consulte [Configuración](#configuration) para obtener 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

Aplica 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

### Puntos finales 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"
  }'

## How It Works

Augustus utiliza una arquitectura de pipeline para probar 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 (Agente Ofensivo Generativo)

GOAT utiliza un enfoque agresivo y adaptativo con 7 técnicas adversariales y razonamiento de Cadena-de-Ataque-Pensamiento para cambiar dinámicamente de estrategia según lo que funciona o falla.

- **Artículo**: [Pavlova et al., 2024](https://arxiv.org/abs/2410.01606)
- **Enfoque**: Apunta al objetivo desde el turno 1 utilizando un encuadre indirecto, nunca menciona la meta directamente al objetivo
- **7 técnicas** en 3 categorías:
  - *Manipulación de Salida*: Supresión de Negativas, Preparación de Respuesta
  - *Distractores de Respuesta Segura*: Doble Respuesta, División de Temas, Intención Opuesta
  - *Escenarios Ficticios*: Modificación de Persona, Hipotético
- **Cadena-de-Ataque-Pensamiento**: En cada turno el atacante razona a través de Observación → Pensamiento → Estrategia → Respuesta antes de elaborar su mensaje
- **Apilamiento de técnicas**: Múltiples técnicas pueden combinarse en un solo turno para un efecto más fuerte
- **Fortaleza**: Logra altas tasas de éxito en menos turnos (típicamente 3-5) al cambiar 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 sondea sutilmente los límites de la IA mediante una conversación natural. A diferencia de las estrategias adversariales, la persona atacante es un usuario casual que se desvía hacia temas prohibidos a través de una interacción aparentemente inocente.

- **Inspirado en**: [Tau-bench](https://github.com/sierra-research/tau-bench) y la estrategia de usuario travieso de promptfoo
- **Enfoque**: Fase de creación de rapport → sondeo de límites → empuje asertivo
- **7 técnicas**: Curiosidad ingenua, malentendido deliberado, prueba social, deriva gradual, apelación emocional, permiso asumido, recontextualización
- **Libretos específicos por objetivo**: 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ápido o no funciona en absoluto)
- **Fortaleza**: Efectivo contra modelos entrenados para resistir patrones adversariales obvios — la persona casual evita las heurísticas de "detección de ataques"```bash
augustus scan rest.Rest \
  --probe mischievous.MischievousUser \
  --config-file mischievous.yaml \
  --html report.html -v

| Configuración | Valor por defecto | 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 activa la 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 análisis JSON del LLM atacante |
| `use_secondary_judge` | true | Habilita un juez secundario para detectar falsos negativos |
| `max_backtracks` | 10 | Retrocesos a nivel de turno ante negativas (solo Hydra) |
| `enable_fast_refusal` | true | Detección de negativas basada en patrones antes de la llamada al juez LLM |
| `enable_scan_memory` | false | Aprendizaje entre casos de prueba (comparte tácticas entre sondas) |
| `stateful` | false | Desactiva el retroceso para objetivos con estado |
| `exclude_target_output` | false | Oculta las respuestas del objetivo de la retroalimentación del atacante (modo privacidad) |
| `attacker_model` | (automático) | Sobrescribe el nombre del modelo atacante para dimensionar la ventana de contexto |

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

| Síntoma | Causa probable | Solución |
|---------|-------------|-----|
| `no turns completed (attacker_parse_failures=N)` | El LLM atacante devuelve JSON no válido | Usa un modelo atacante más potente (GPT-4, Claude Opus). Aumenta `attack_max_attempts`. |
| `no turns completed (target_empty=N)` | El objetivo devuelve respuestas vacías/nulas | Comprueba que el endpoint del objetivo responde. Verifica la plantilla de configuración REST. |
| Todos los turnos puntúan 0.0 | El objetivo es demasiado vago o el atacante no interactúa | Haz que `goal` sea más específico. Prueba una estrategia diferente. |
| Puntuaciones altas pero sin éxito | `success_threshold` demasiado alto | Baja `success_threshold` de 0.8 a 0.6-0.7 |
| Las ejecuciones duran demasiado / son costosas | Demasiados turnos y reintentos | Reduce `max_turns` (prueba con 5). Establece `enable_fast_refusal: true`. |
| Hydra sigue retrocediendo | El objetivo rechaza todo | Prueba con `stateful: true` o cambia a la 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

- Verificación TLS deshabilitada automáticamente para inspección de proxy
- Soporte HTTP/2 habilitado para APIs modernas
- Respuestas Server-Sent Events (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/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 de Python: ejecución más rápida y menor uso de memoria
- **Distribución**: un solo binario sin dependencias de ejecución vs paquete de Python con instalación mediante 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 historial de investigación más extenso 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í! Usa la integración de 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 la API
- Manejo de tiempos de espera para sondas de larga duración
- Lógica de reintentos para fallos transitorios
- Registro estructurado para la observabilidad

## Solución de problemas

### Error: "API rate limit exceeded"

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

**Soluciones**:
1. Reduzca la concurrencia: `--concurrency 5`
2. Utilice la configuración de límite de velocidad específica del proveedor en el archivo de configuración YAML:   ```yaml
   generators:
     openai.OpenAI:
       rate_limit: 10  # requests per minute

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

**Causa**: Faltan credenciales de API o son inválidas.

**Soluciones**:
1. Verifica que la variable de entorno esté configurada: `echo $OPENAI_API_KEY`
2. Revisa si hay errores tipográficos en el archivo de configuración
3. Asegúrate de que la clave de API tenga los permisos necesarios
4. Para Ollama, asegúrate 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 la sonda no está 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 referencia (DevPod)

Un entorno de desarrollo en la nube listo para usar para evaluar LLMs está disponible 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 **únicamente 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
- Algunas sondas 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 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/main/CONTRIBUTING.md) con nuevas sondas, detectores o integraciones de proveedores

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

## Licencia

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

---

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