Augustus - Escáner de vulnerabilidades LLM para inyección de prompts, jailbreak y pruebas de ataques adversariales

Augustus - Escáner de Vulnerabilidades LLM

Pruebe modelos de lenguaje grandes contra más de 210 ataques adversariales que cubren inyección de prompts, jailbreaks, explotaciones de codificación y extracción de datos.

Augustus es un escáner de vulnerabilidades LLM basado en Go para profesionales de seguridad. Prueba modelos de lenguaje grandes contra una amplia gama de ataques adversariales, se integra con 28 proveedores de LLM y produce informes de vulnerabilidades procesables.

A diferencia de las herramientas orientadas a la investigación, Augustus está diseñado para pruebas de seguridad en producción: escaneo concurrente, limitación de velocidad, lógica de reintentos y manejo de tiempos de espera vienen incluidos.

Por qué Augustus

Características

Categorías de Ataque

Ataques de jailbreak: DAN, DAN 11.0, AIM, AntiGPT, Grandma, ArtPrompts
Inyección de prompts: Codificación (Base64, ROT13, Morse), Contrabando de etiquetas, FlipAttack, Inyección de prefijo/sufijo
Ejemplos adversariales: GCG, PAIR, AutoDAN, TAP (Tree of Attack Prompts), TreeSearch, DRA
Ataques multi-turno: Crescendo (escalada gradual), GOAT (cambio adaptativo de técnicas)
Extracción de datos: Filtración de claves API, Alucinación de paquetes, Extracción de PII, LeakReplay
Manipulación de contexto: Envenenamiento de RAG, Desbordamiento de contexto, Ataques multimodales, Continuación, Divergencia
Explotaciones de formato: Inyección de Markdown, Ataques de análisis YAML/JSON, Escape ANSI, Inyección web (XSS)
Técnicas de evasión: Ofuscación, Sustitución de caracteres, Ataques basados en traducción, Reformulación, ObscurePrompt
Puntos de referencia de seguridad: DoNotAnswer, RealToxicityPrompts, Snowball, LMRC
Ataques de agentes: Manipulación multiagente, Explotaciones de navegación
Pruebas de seguridad: Evasión de guardarraíles, Escaneo de AV/spam, Explotación (SQLi, ejecución de código), BadChars

Advertencia: La sonda lmrc utiliza lenguaje obsceno y ofensivo como parte de sus pruebas de jailbreak. Úsela solo en entornos de prueba autorizados.

Inicio Rápido

Instalación

Requiere Go 1.25.3 o superior.```bash go install github.com/praetorian-inc/augustus/cmd/augustus@latest

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

Uso básico```bash

export OPENAI_API_KEY="your-api-key" augustus scan openai.OpenAI
--probe dan.Dan_11_0
--detector dan.DAN
--verbose

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

Listar capacidades disponibles```bash

List all registered probes, detectors, generators, harnesses, and buffs

augustus list

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

Múltiples Sondas```bash

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

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

Formatos de Salida```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

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

Claves de configuración REST:

uri: Endpoint de la API de destino (requerido)
method: Método HTTP (por defecto: POST)
headers: Cabeceras HTTP como pares clave-valor
req_template: Cuerpo de solicitud en bruto con marcador $INPUT
req_template_json_object: Cuerpo de solicitud JSON (auto-serializado, use $INPUT en cadenas)
response_json: Analizar respuesta como JSON (por defecto: false)
response_json_field: JSONPath a extraer (p. ej., $.data.text o nombre de campo simple)
api_key: Clave API para la sustitución del marcador $KEY
proxy: URL del proxy HTTP para inspección de tráfico

Opciones Avanzadas```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"}'

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

Scan Pipeline

Selección de Sondas: Elija sondas por nombre, patrón glob o --all
Transformación de Buff: Opcionalmente, transforme prompts (codificar, parafrasear, traducir, poetizar)
Llamada al Generador: Envíe prompts adversariales al LLM objetivo a través de su integración de proveedor
Análisis del Detector: Analice las respuestas utilizando coincidencia de patrones, LLM como juez o detectores especializados
Registro de Resultados: Puntúe cada intento y produzca la salida en el formato solicitado
Motor de Ataque: Para sondas iterativas (PAIR, TAP), el motor de ataque de un solo turno refina los prompts a través de iteraciones con poda de candidatos y puntuación basada en juez
Motor Multiturno: Para sondas conversacionales (Crescendo, GOAT), el motor multiturno mantiene el historial completo de la conversación con el objetivo a través de los turnos, con detección de rechazo y adaptación dinámica

Estrategias de Ataque Multiturno

Los ataques multiturno mantienen una conversación persistente con el LLM objetivo, explotando el hecho de que los modelos pueden divulgar información incrementalmente a través de los turnos que rechazarían en un solo prompt. El motor multiturno utiliza tres LLMs: un atacante (genera preguntas), un objetivo (el sistema bajo prueba) y un juez (puntúa el progreso y detecta rechazos).

Crescendo

Crescendo utiliza una escalada gradual (técnica del pie en la puerta) para lentamente desplazar una conversación desde temas benignos hacia un objetivo prohibido.

Artículo: Russinovich et al., 2024
Enfoque: Comienza con preguntas genuinamente benignas y educativas, e incrementa gradualmente la especificidad a lo largo de muchos turnos
Patrón de escalada: Contexto histórico → mecanismos técnicos → detalles específicos → solicitudes directas enmarcadas como seguimientos naturales
Fortaleza: Efectivo contra modelos que rastrean el tono de la conversación — el cambio gradual evita activar los filtros de seguridad```bash augustus scan rest.Rest
--probe crescendo.Crescendo
--config-file crescendo.yaml
--html report.html -v

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

Hydra

Hydra mantiene una única ruta de conversación y revierte turnos completos cuando el objetivo se niega, pidiendo al atacante un enfoque completamente diferente. A diferencia de Crescendo/GOAT (que reformulan tras una negativa), la reversión de Hydra elimina por completo los turnos rechazados de la vista del objetivo.

Enfoque: Ruta única con reversión a nivel de turno — los turnos rechazados se borran y reemplazan
Técnicas: Descomposición (dividir el objetivo en subpreguntas inocentes), aprovechamiento del contexto (basarse en las propias palabras del objetivo), simulación de autoridad, encuadre emocional, normalización progresiva
Característica clave: max_backtracks controla cuántas veces Hydra puede borrar y reintentar un turno
Modo con estado: Establecer stateful: true para objetivos donde los mensajes no se pueden deshacer (desactiva la reversión)
Fortaleza: Mantiene limpio el historial de conversación del objetivo — el objetivo nunca ve los intentos fallidos, evitando la escalada defensiva```bash augustus scan rest.Rest
--probe hydra.Hydra
--config-file hydra.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

Guía de selección de estrategias

Decisión rápida:

Comienza con Crescendo — es la estrategia más versátil
Prueba GOAT si Crescendo es demasiado lento (GOAT suele tener éxito en 3-5 turnos)
Usa Hydra si el objetivo rechaza con frecuencia (el retroceso mantiene limpia la conversación)
Usa Mischievous para objetivos con fuerte detección de patrones adversariales (la persona evita las heurísticas)

Configuración de múltiples turnos

Las cuatro estrategias comparten la misma estructura de configuración:```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

| 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

Decisiones Clave de Diseño

Escaneo concurrente con grupos de gorutinas acotados mediante errgroup
Registro estilo plugin usando funciones init() de Go para sondas, generadores, detectores, mejoras y arneses
Motor de ataque iterativo con gestión de conversaciones multi-stream, poda de candidatos y puntuación basada en juez para PAIR/TAP
Motor de ataque multi-turno con historial de conversación persistente, detección de rechazo, diseño agnóstico a la estrategia para Crescendo/GOAT
Plantillas YAML de sonda (estilo Nuclei) para definiciones declarativas de sondas junto con sondas basadas en Go
Prefiltrado Aho-Corasick para coincidencia rápida de palabras clave en detectores

Configuración

Archivo de Configuración YAML

Cree un archivo 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"

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

Configuración del Proxy

Enruta el tráfico HTTP a través de un proxy (por ejemplo, Burp Suite) para inspección:```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"}'

- 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

Comandos:```bash augustus version # Print version information augustus list # List available probes, detectors, generators, harnesses, buffs augustus scan # Run vulnerability scan augustus completion # Generate shell completion (bash, zsh, fish)

**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"}'

How do I add custom probes?

Crea un nuevo archivo Go en internal/probes/
Implementa la interfaz probes.Probe
Registra usando registry.RegisterProbe() en una función init()
Reconstruye: make build

See CONTRIBUTING.md para instrucciones detalladas.

What output formats are supported?

Augustus soporta cuatro formatos de salida:

How do I test multiple models at once?```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

### ¿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: "context deadline exceeded" or "timeout"

Causa: Sondas complejas (como TAP o PAIR) superan el tiempo de espera predeterminado.

Solución:```bash augustus scan openai.OpenAI
--probe tap.TAPv1
--timeout 60m
--config-file config.yaml

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

El escaneo no produce resultados

Causa: El detector no coincidió con ninguna respuesta, o no se escribió la salida.

Soluciones:

Ejecutar con --verbose para ver la salida detallada
Verificar que el detector coincida con el tipo de sonda
Verificar que la ruta del archivo de salida sea escribible

Contribuciones

¡Agradecemos las contribuciones! Consulta CONTRIBUTING.md para:

Añadir nuevas sondas de vulnerabilidad
Crear nuevas implementaciones de detectores
Añadir integraciones de proveedores de LLM
Directrices de prueba
Requisitos de estilo de código

Desarrollo```bash

Run all tests

make test

Run specific package tests

go test ./pkg/scanner -v

Run equivalence tests (compare Go vs Python implementations)

go test ./tests/equivalence -v

Build binary

make build

Install to $GOPATH/bin

make install

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

Dentro del devpod:```bash devpod/scripts/setup.sh # Configure LLM provider API keys devpod/scripts/pull-models.sh # Pull local Ollama models (GPU only) devpod/scripts/benchmark.sh # Run benchmarks with comparison reports

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

Más de 210 sondas de vulnerabilidad	47 categorías de ataque: jailbreaks, inyección de prompts, ejemplos adversariales, extracción de datos, puntos de referencia de seguridad, ataques de agentes, y más
28 proveedores de LLM	OpenAI, Anthropic, Azure, Bedrock, Vertex AI, Ollama, y 22 más con 43 variantes de generador
Más de 90 detectores	Coincidencia de patrones, LLM como juez, HarmJudge (arXiv:2511.15304), Perspective API, detección de contenido inseguro
7 transformaciones Buff	Codificación, paráfrasis, poesía (5 formatos, 3 estrategias), traducción a idiomas de bajos recursos, transformaciones de mayúsculas/minúsculas
Salida flexible	Formatos de informe: tabla, JSON, JSONL y HTML
Listo para producción	Escaneo concurrente, limitación de velocidad, lógica de reintentos, manejo de tiempos de espera
Binario único	Herramienta basada en Go que compila a un ejecutable portátil
Extensible	Registro estilo plugin mediante funciones `init()` de Go

`crescendo.Crescendo`	10	Escalada gradual	Modelos con filtros de seguridad que rastrean tono	Medio (10 turnos × 3 llamadas LLM)
`goat.Goat`	10	Cambio agresivo de técnica	Resultados rápidos, modelos débiles a trucos de encuadre	Medio-Alto (sobrecarga de razonamiento de técnica)
`hydra.Hydra`	10	Retroceso ante rechazos	Modelos tercos que rechazan con frecuencia	Alto (retroceso añade reintentos)
`mischievous.MischievousUser`	5	Sondeo casual de persona	Modelos entrenados contra patrones adversariales	Bajo (5 turnos, enfoque sutil)

Table	`--format table`	Salida de terminal legible para humanos
JSON	`--format json`	Objeto JSON único para análisis
JSONL	`--format jsonl`	JSON delimitado por líneas para transmisión en flujo
HTML	`--html report.html`	Informes visuales para las partes interesadas

Lenguaje	Go	Python	TypeScript
Binario único	Sí	No	No
Escaneo concurrente	Goroutine pools	Multiprocessing pools	Sí
Proveedores de LLM	28	35+	80+
Tipos de sonda	210+	160+	119 plugins + 36 strategies
Enfoque empresarial	Sí	Investigación	Sí

augustus

Más Populares