Escáner de inyección SQL listo para producción con 6 métodos de detección, remediación impulsada por IA, salida SARIF e integración CI/CD.

Inicio rápido · Documentación · Docker · Análisis con IA · Deja una estrella en GitHub

Pythia — imagen principal de SQL Clairvoyance

En acción

_{Escaneo en vivo · tienda PHP vulnerable · 11 hallazgos detectados · modo seguro · 2265.56s}

_{Informe HTML — vista general de hallazgos con insignias de severidad y mapeo OWASP}

_{Tabla de hallazgos — códigos PYTHIA-SQL, detección de DBMS, mapeo CWE-89}

¿Qué es Pythia?

Pythia es un escáner de detección de inyección SQL listo para producción que pone la ética primero. Diseñado para probadores de penetración, investigadores de seguridad e ingenieros DevSecOps, identifica vulnerabilidades de inyección SQL mediante 6 métodos de detección y se integra directamente en pipelines de CI/CD.

¿Por qué Pythia?

Ético por diseño: El sistema de token de consentimiento previene escaneos no autorizados
Detección multimétodo: 6 técnicas de detección, incluyendo inyección de segundo orden y ORDER BY
Impulsado por IA: GPT, Claude u Ollama local para guías de remediación inteligentes con ejemplos de código
Listo para CI/CD: flags --fail-on, --sarif, --diff para integración en pipelines
Informes profesionales: HTML con barra de filtros + insignias OWASP/CWE/CVE + JSON con puntuación CVSS contextual
Seguimiento persistente: base de datos SQLite compartida con Argos Suite (~/.argos/argos.db)
Alta precisión: endurecimiento contra falsos positivos con puntuación de similitud y confirmación de múltiples payloads

Qué detecta

Características

Detección de inyección SQL principal```bash

One command, comprehensive SQLi analysis

python -m pyth --target http://example.com/products?id=1 --html

- **14 Códigos de hallazgo**: específicos de DBMS (MySQL, PostgreSQL, MSSQL, Oracle, SQLite) + específicos de técnica
- **Fingerprinting de DBMS**: detección automática del tipo y la versión de la base de datos
- **Bypass de WAF**: 170+ payloads de bypass en modo agresivo (hex, codificación URL, comentarios en línea, variantes de mayúsculas/minúsculas)
- **Detección de variables de sesión**: cadena POST→GET para patrones de autenticación estilo DVWA-high
- **Rastreador inteligente**: BFS con extracción de popups/onclick (`--js`), sitemap, robots.txt
- **Endurecimiento contra falsos positivos**: puntuación de similitud SequenceMatcher + confirmación con múltiples payloads

### Integración CI/CD```bash
# Pipeline-friendly: exit 10 if high+ findings found
python -m pyth --target https://staging.app.com --aggressive --fail-on high
echo $?  # 0=clean, 10=findings found, 1=error

# SARIF for GitHub Security / GitLab SAST
python -m pyth --target https://app.com --aggressive --sarif > results.sarif

# Compare vs last scan — show what's new, what's fixed
python -m pyth --target https://app.com --aggressive --diff last --html

Encabezados de Autenticación```bash

Scan authenticated endpoints (JWT, API keys, custom cookies)

python -m pyth --target https://api.example.com/v1/users
--auth-header "Authorization: Bearer eyJhbGc..."
--auth-header "X-API-Key: sk-prod-xxx"
--aggressive --html

Pasa `--auth-header` varias veces para múltiples cabeceras.

### Análisis impulsado por IA

Elige tu proveedor de IA desde la línea de comandos:

| Proveedor                       | Ideal para                       | Velocidad  | Costo       | Privacidad    |
| -------------------------------- | --------------------------------- | ---------- | ----------- | ------------ |
| **OpenAI gpt-4o-mini** (predeterminado) | Calidad de producción, bajo costo | Rápida     | ~$0.02/scan | Estándar     |
| **Anthropic Claude**             | Centrado en la privacidad, remediación de código | Rápida     | ~$0.06/scan | Mejorada     |
| **Ollama (Local)**               | Privacidad total                  | Lenta (CPU) | Gratis      | 100% sin conexión |```bash
# Standard analysis
python -m pyth --target http://example.com --use-ai --ai-tone technical --html

# Agent mode: AI queries NVD for real CVEs (no API key for NVD)
python -m pyth --target http://example.com --use-ai --ai-agent --html

# Multi-provider comparison
python -m pyth --target http://example.com --use-ai \
  --ai-compare "openai:gpt-4o-mini,anthropic:claude-3-5-haiku-20241022" --html

# With budget cap
python -m pyth --target http://example.com --use-ai --ai-budget 0.05 --html

Informes profesionales

Informes JSON (Legible por máquina, esquema v0.2.0)```json { "tool": "pythia", "version": "0.2.0", "target": "http://localhost:8081", "mode": "aggressive", "summary": { "total": 26, "critical": 18, "high": 6, "medium": 2 }, "findings": [ { "id": "PYTHIA-SQL-001", "title": "Error-Based SQL Injection (MySQL/MariaDB)", "severity": "critical", "confidence": "high", "parameter": "id", "vector": "GET", "dbms": "MySQL 8.0.32", "cvss": 9.8, "contextual_score": 9.9, "risk_factors": ["no_ssl", "pii_detected"], "payload": "' OR '1'='1' --", "owasp": { "id": "A03", "name": "Injection" }, "cwe": { "id": "CWE-89", "name": "SQL Injection" }, "detection_method": "error-based" } ], "notes": { "scan_duration_seconds": 87.3, "requests_sent": 342, "rate_limit_applied": "5.0 req/s", "false_positive_disclaimer": "..." }, "diff": null }

**Informes HTML** (legibles para humanos)

- Barra de filtros: severidad, categoría OWASP, método de detección, DBMS
- Insignias OWASP/CWE/CVE por hallazgo (clicables a referencias externas)
- Puntuación CVSS base + contextual con codificación por colores
- Secciones de evidencia expandibles con visualización de payloads
- Pestañas de análisis de IA (estándar / agente / comparar)
- Sección de diff (hallazgos nuevos/corregidos/persistentes)
- Tema Oracle (morado `#6a11cb`) — entregable a clientes sin edición

### Códigos de Hallazgo

Todos los códigos → **OWASP A03 Injection** / **CWE-89 SQL Injection**

| Código           | Tipo               | DBMS / Vector            | Modo       |
| ---------------- | ------------------ | ------------------------ | ---------- |
| `PYTHIA-SQL-001` | Basado en errores  | MySQL / MariaDB          | Seguro     |
| `PYTHIA-SQL-002` | Basado en errores  | PostgreSQL               | Seguro     |
| `PYTHIA-SQL-003` | Basado en errores  | MSSQL                    | Seguro     |
| `PYTHIA-SQL-004` | Basado en errores  | Oracle                   | Seguro     |
| `PYTHIA-SQL-005` | Basado en errores  | SQLite                   | Seguro     |
| `PYTHIA-SQL-010` | Ciego booleano     | Cualquier DBMS           | Seguro     |
| `PYTHIA-SQL-011` | Ciego booleano     | Mediante inyección en cabecera | Seguro |
| `PYTHIA-SQL-020` | Basado en tiempo   | MySQL SLEEP()            | Agresivo   |
| `PYTHIA-SQL-021` | Basado en tiempo   | MSSQL WAITFOR            | Agresivo   |
| `PYTHIA-SQL-022` | Basado en tiempo   | PostgreSQL pg_sleep()    | Agresivo   |
| `PYTHIA-SQL-030` | Basado en UNION    | Parámetro GET/POST       | Agresivo   |
| `PYTHIA-SQL-031` | Basado en UNION    | Mediante cookie          | Agresivo   |
| `PYTHIA-SQL-040` | Segundo orden      | Patrón de almacenar → recuperar | Agresivo |
| `PYTHIA-SQL-050` | Inyección ORDER BY | Parámetro de ordenación numérica | Agresivo |

---

## Validación y Pruebas

Pythia v0.2.0 ha sido **validado empíricamente** utilizando aplicaciones vulnerables controladas basadas en Docker.

### Resultados de QA (mayo de 2026)

| Objetivo                 | Modo                               | Hallazgos        | Notas                                      |
| ----------------------- | ---------------------------------- | ---------------- | ------------------------------------------ |
| **PHP Lab** (8081)      | `--aggressive`                     | **26 hallazgos** | Las 4 técnicas + segundo orden + ORDER BY |
| **Flask Lab** (8082)    | `--js --aggressive`                | **18 hallazgos** | Variable de sesión + segundo orden + ORDER BY |
| **DVWA Low**            | `--no-crawl --aggressive`          | 4/4 técnicas     | PYTHIA-SQL-001/010/020/030                 |
| **DVWA Medium**         | `--no-crawl --aggressive`          | 4/4 técnicas     | Formulario POST, todas las técnicas        |
| **DVWA High**           | `--js --max-pages 2 --aggressive`  | 4/4 técnicas     | Cadena POST→GET con variable de sesión     |
| **Prueba de falso positivo** | `--aggressive`                 | **0 hallazgos**  | URL estática — se confirmó que no hay falsos positivos |

**Validaciones clave:**

- ✅ Los 14 códigos de hallazgo funcionales
- ✅ DVWA alto (patrón de variable de sesión) — paridad completa 4/4
- ✅ Detección de segundo orden (PYTHIA-SQL-040)
- ✅ Detección de inyección ORDER BY (PYTHIA-SQL-050)
- ✅ Cero falsos positivos en URLs estáticas
- ✅ Códigos de salida de `--fail-on` (0/10/1) correctos
- ✅ La salida SARIF 2.1.0 es válida
- ✅ La comparación `--diff last` funciona
- ✅ `--auth-header` transmite las cabeceras en todas las solicitudes

---

## Inicio Rápido

### Requisitos previos

- **Python 3.11+** (se recomienda 3.12)
- **pip** (gestor de paquetes de Python)
- **Docker** (opcional, para laboratorios vulnerables)

### Instalación

**1. Clona el repositorio**```bash
git clone https://github.com/rodhnin/pythia-sql-clairvoyance.git
cd pythia-sql-clairvoyance

2. Crear y activar el entorno virtual```bash python3 -m venv .venv source .venv/bin/activate

**3. Instalar dependencias**```bash
python -m pip install --upgrade pip
python -m pip install -r requirements.txt

4. Configura las claves de API (si usas IA en la nube)```bash export OPENAI_API_KEY="sk-..." export ANTHROPIC_API_KEY="sk-ant-..."

**5. Verificar la instalación**```bash
python -m pyth --version
# Output: Pythia v0.2.0

Tu Primer Escaneo```bash

python -m pyth --target "http://testphp.vulnweb.com/artists.php?artist=1"

With HTML report

python -m pyth --target "http://testphp.vulnweb.com/artists.php?artist=1" --html

python -m pyth --gen-consent example.com python -m pyth --verify-consent http --domain example.com --token verify-abc123 python -m pyth --target http://example.com --aggressive --html

Informes guardados en `~/.pythia/reports/`.

---

## Guía de uso

### Referencia de flags de CLI```
Scan Options:
  --target URL          Target URL to scan
  --safe                Safe mode (default): error-based + boolean-blind
  --aggressive          Aggressive mode: all 6 techniques + WAF bypass payloads

Auth:
  --cookie COOKIE       Session cookie string
  --auth-header HEADER  Custom HTTP header (pass multiple times for multiple headers)
  --auto-csrf           Automatically detect and include CSRF tokens

Crawler:
  --max-depth N         Max crawl depth (default: 2)
  --max-pages N         Max pages to crawl (default: 100)
  --no-robots           Ignore robots.txt
  --no-crawl            Skip BFS crawl, test target URL only
  --js                  JS-aware popup/onclick URL extraction

Output:
  --report-dir DIR      Output directory for reports (default: ~/.pythia/reports/)
  --html                Generate HTML report
  --db                  Save findings to database
  --diff SCAN_ID        Compare vs previous scan (use "last" for most recent)
  --sarif               Output SARIF 2.1.0 to stdout (logs redirect to stderr)
  --fail-on SEVERITY    Exit 10 if findings found at this severity or higher

CI/CD:
  --fail-on SEVERITY    Exit codes: 0=clean, 10=findings found, 1=error

Logging:
  -v / -vv / -vvv       Verbosity levels
  -q                    Quiet mode (errors only)
  --log-file FILE       Log to file
  --log-json            Structured JSON logging
  --no-color            Disable colored output

AI:
  --use-ai              Enable AI analysis
  --ai-tone TONE        Analysis tone: technical, non_technical, both
  --api-key-env VAR     Environment variable name for API key
  --ai-provider NAME    AI provider: openai, anthropic, ollama
  --ai-model MODEL      Model name (e.g. gpt-4o-mini, claude-3-5-haiku-20241022)
  --ai-stream           Stream AI output token by token
  --ai-compare LIST     Compare providers (e.g. "openai,anthropic" or "openai:gpt-4o-mini,anthropic:claude-3-5-haiku-20241022")
  --ai-agent            Agent mode: NVD CVE lookup + iterative analysis
  --ai-budget AMOUNT    Cost cap per scan in USD

Consent:
  --gen-consent DOMAIN  Generate consent token for domain
  --verify-consent METHOD  Verify consent: http or dns
  --domain DOMAIN       Domain for consent verification
  --token TOKEN         Consent token value

Advanced:
  --rate N              Request rate limit (default: 2.0 safe, 5.0 aggressive)
  --timeout N           HTTP timeout in seconds (default: 10)
  --user-agent STRING   Custom User-Agent
  --no-verify-ssl       Disable SSL verification
  --threads N           Worker threads (default: 5)
  --version             Show version and exit

Escaneo básico```bash

python -m pyth --target "http://example.com/search?q=test"

Generate HTML report

python -m pyth --target "http://example.com/products?id=1" --html

Increase verbosity

python -m pyth --target "http://example.com/api/users?id=1" -vv

Skip crawler, test target URL directly

python -m pyth --target "http://example.com/api/users?id=1" --no-crawl

### Integración CI/CD```bash
# Exit 10 if high or critical findings exist (blocks pipeline)
python -m pyth \
  --target https://staging.myapp.com \
  --aggressive \
  --fail-on high

# SARIF output for GitHub Security tab
python -m pyth \
  --target https://staging.myapp.com \
  --aggressive \
  --sarif > results.sarif

# Compare vs last scan to see what changed
python -m pyth \
  --target https://staging.myapp.com \
  --aggressive \
  --diff last \
  --html

Escaneo autenticado```bash

JWT Bearer token

python -m pyth
--target https://api.example.com/v1/products
--aggressive
--auth-header "Authorization: Bearer eyJhbGc..."
--html

Multiple headers

python -m pyth
--target https://api.example.com/v1/users
--aggressive
--auth-header "Authorization: Bearer eyJhbGc..."
--auth-header "X-API-Key: sk-prod-xxx"
--html

python -m pyth
--target "http://localhost:8080/vulnerabilities/sqli/?id=1&Submit=Submit"
--no-crawl
--aggressive
--cookie "PHPSESSID=abc123; security=low"

### Rastreo con soporte de JS```bash
# Extract popup/onclick URLs for complex navigation patterns
python -m pyth \
  --target http://localhost:8082 \
  --js \
  --aggressive \
  --html

# DVWA high: session-variable form (needs popup URL extraction)
python -m pyth \
  --target "http://localhost:8080/vulnerabilities/sqli/" \
  --js \
  --max-pages 2 \
  --aggressive \
  --cookie "PHPSESSID=abc123; security=high"

La bandera --js utiliza la extracción con regex de los atributos onclick — no se requiere dependencia de Playwright.

Modo agresivo```bash

python -m pyth --gen-consent example.com

Output: Token: verify-a3f9b2c1d8e4...

Step 2: Place token at https://example.com/.well-known/verify-a3f9b2c1d8e4.txt

python -m pyth --verify-consent http
--domain example.com
--token verify-a3f9b2c1d8e4

Step 4: Run aggressive scan (all 6 techniques + WAF bypass)

python -m pyth
--target http://example.com
--aggressive
--html -v

---

## Despliegue con Docker

Pythia ofrece dos opciones de despliegue con Docker:

1. **Imagen de escáner**: Construye Pythia como una imagen de Docker para escaneos de una sola vez
2. **Laboratorio de pruebas**: Aplicaciones vulnerables (DVWA, PHP, Flask) para pruebas seguras

### Inicio rápido```bash
cd docker
./deploy.sh

Laboratorio de Pruebas (Aplicaciones Vulnerables)

NUNCA expongas el laboratorio de pruebas a Internet público — ¡SOLO PRUEBAS LOCALES!```bash

Start vulnerable applications

sudo docker compose -f docker/compose.testing.yml up -d

Expected targets:

DVWA: http://localhost:8080

PHP Shop: http://localhost:8081

Flask Blog: http://localhost:8082

Scan from host

python -m pyth --target http://localhost:8081 --aggressive --html

Stop lab

sudo docker compose -f docker/compose.testing.yml down

---

## Análisis impulsado por IA

Pythia utiliza **LangChain v1.0.0** con soporte para múltiples proveedores de IA.

### Dos modos de análisis

- **Técnico**: Sentencias preparadas, consultas parametrizadas, código de validación de entrada (PHP/PDO, Python/SQLAlchemy, Node.js/pg, Java/PreparedStatement)
- **Ejecutivo**: Evaluación de riesgos en lenguaje sencillo para las partes interesadas y la dirección

### Cambiar de proveedor```bash
# CLI flags (v0.2.0) — no YAML editing required
python -m pyth --target http://example.com --use-ai --ai-provider anthropic --ai-model claude-3-5-haiku-20241022 --html
python -m pyth --target http://example.com --use-ai --ai-provider ollama --ai-model llama3.2 --html

La configuración YAML (config/default.yaml) aún se puede usar como respaldo. Las opciones de la CLI tienen prioridad.

Para obtener la guía completa de integración de IA, consulta docs/AI_INTEGRATION.md

Entendiendo los informes

Archivos de informe```

~/.pythia/ ├── reports/ │ ├── pythia_sqli_report_localhost_20260318_143022.json │ └── pythia_sqli_report_localhost_20260318_143022.html ~/.argos/ ├── argos.db # Shared Argos Suite database ├── costs.json # AI cost tracking (shared) └── logs/ └── pythia.log # Scan logs

### Mapeo de Severidad

- **CRÍTICO (9.0-10.0)**: Basado en errores, basado en tiempo, basado en UNION, de segundo orden con explotación confirmada
- **ALTO (7.0-8.9)**: Ciego booleano (alta confianza), inyección por ORDER BY
- **MEDIO (4.0-6.9)**: Ciego booleano (confianza media)
- **BAJO (0.1-3.9)**: Posible SQLi con evidencia no concluyente

### Códigos de Salida

| Code  | Meaning                                                                       |
| ----- | ----------------------------------------------------------------------------- |
| `0`   | Escaneo completado, sin hallazgos en el umbral `--fail-on` (o sin usar `--fail-on`) |
| `1`   | Error técnico (conexión, tiempo de espera, base de datos)                     |
| `10`  | Hallazgos encontrados en o por encima del umbral de severidad `--fail-on`     |
| `130` | Usuario canceló (Ctrl+C)                                                      |

---

## Persistencia de la Base de Datos

Base de datos SQLite **compartida con el ecosistema Argos** (`~/.argos/argos.db`):

- **Historial de Escaneos**: Fecha, duración, número de hallazgos, métodos de detección
- **Repositorio de Hallazgos**: Base de datos de vulnerabilidades de inyección SQL buscable
- **Dominios Verificados**: Seguimiento de tokens de consentimiento con expiración
- **Costos de IA**: Seguimiento de costos por escaneo (nuevo en v0.2.0)```bash
# Query recent Pythia scans
sqlite3 ~/.argos/argos.db "SELECT * FROM scans WHERE tool='pythia' ORDER BY scan_id DESC LIMIT 10"

# Find critical SQL injections
sqlite3 ~/.argos/argos.db "SELECT * FROM findings WHERE severity='critical' AND scan_id IN (SELECT scan_id FROM scans WHERE tool='pythia')"

# View AI cost summary
sqlite3 ~/.argos/argos.db "SELECT provider, model, ROUND(SUM(cost_usd),4) FROM ai_costs WHERE tool='pythia' GROUP BY provider, model"

Estructura del Proyecto```

pythia-sql-clairvoyance/ ├── pyth/ │ ├── checks/ │ │ ├── crawler.py # BFS web crawler (JS-aware with --js) │ │ ├── error_based.py # PYTHIA-SQL-001..005 │ │ ├── boolean_blind.py # PYTHIA-SQL-010..011 │ │ ├── time_based.py # PYTHIA-SQL-020..022 │ │ ├── union_based.py # PYTHIA-SQL-030..031 │ │ ├── second_order.py # PYTHIA-SQL-040 │ │ ├── order_injection.py # PYTHIA-SQL-050 │ │ ├── waf_bypass.py # WAF bypass payloads (aggressive only) │ │ └── forms.py # Form analysis │ ├── core/ │ │ ├── ai.py # AI integration + AICostTracker │ │ ├── config.py # Config loader │ │ ├── consent.py # Consent token system │ │ ├── cve_lookup.py # NVD CVE API client │ │ ├── db.py # ArgosDB (shared SQLite) │ │ ├── diff.py # Diff reports │ │ ├── http_client.py # Rate-limited HTTP session │ │ ├── logging.py # Structured logging + secret redaction │ │ ├── owasp.py # OWASP/CWE mapper │ │ ├── report.py # Report generation (JSON + HTML + SARIF) │ │ └── risk_scoring.py # Contextual CVSS scoring │ ├── cli.py # CLI argument parser (35+ flags) │ ├── scanner.py # Main scan orchestrator │ └── init.py # version = "0.2.0" ├── config/ │ ├── default.yaml │ └── prompts/ # AI prompt templates ├── db/migrate.sql # Shared DB schema ├── schema/report.schema.json # JSON Schema Draft 2020-12 ├── templates/report.html.j2 # HTML template (oracle purple theme) ├── docker/ # Docker deployment + vulnerable labs └── docs/ ├── AI_INTEGRATION.md ├── CONSENT.md ├── DATABASE_GUIDE.md ├── ETHICS.md ├── REPORT_FORMAT.md ├── ROADMAP.md └── TESTING_GUIDE.md

---

## Hoja de ruta

### v0.1.0 — Versión inicial (noviembre de 2025)

**Estado:** Publicada

- 4 métodos de detección, remediación con IA, sistema de consentimiento, informes HTML+JSON, persistencia SQLite

### v0.2.0 — Paridad total y funciones empresariales (mayo de 2026)

**Estado:** Publicada

- 6 métodos de detección (se añadieron second-order y ORDER BY)
- 14 códigos de hallazgo específicos de DBMS
- Integración con CI/CD (`--fail-on`, `--sarif`, `--diff`)
- Cabeceras de autenticación, rastreo compatible con JS, payloads de evasión de WAF
- IA: streaming, comparación, agente (consulta de CVE en NVD), seguimiento de costos, opciones `--ai-provider`/`--ai-model`
- Puntuación de riesgo contextual OWASP/CWE/CVSS en cada hallazgo
- Endurecimiento contra falsos positivos (puntuación de similitud, confirmación con múltiples payloads)
- Paridad de seguridad alta de DVWA (cadena de variables de sesión)

### v0.3.0 — Suite pytest y herramientas para desarrolladores (T3 2026)

**Planificado:**

- 40+ pruebas pytest que cubren los 14 códigos de hallazgo
- Gestión interactiva de configuración (`python -m pyth config set`)
- CLI de base de datos (`python -m pyth db scans list`)
- Detección de expiración de sesión durante escaneos autenticados
- Escaneo por lotes de múltiples sitios (`--targets targets.txt`)

### v0.4.0 — Inteligencia y automatización (T1 2027)

**Planificado:**

- Detección de anomalías basada en ML
- Explotación automatizada de solo lectura (prueba de impacto)
- Interfaz de chat con IA para el análisis de resultados de escaneo

Para descripciones detalladas de las funciones, consulta [docs/ROADMAP.md](https://github.com/rodhnin/pythia-sql-clairvoyance/blob/HEAD/docs/ROADMAP.md)

---

## Ética y Legal

### La regla de oro

**Escanea únicamente sistemas de tu propiedad o para los que tengas permiso explícito por escrito para probarlos.**

### Aplicación del consentimiento

| Modo            | Pruebas                    | Consentimiento requerido | Límite de peticiones |
| --------------- | -------------------------- | ---------------- | ---------- |
| **Seguro**      | Error-Based, Boolean-Blind | No               | 2.0 req/s  |
| **Agresivo**    | Las 6 técnicas             | Sí               | 5.0 req/s  |
| **Análisis IA** | Guía de remediación        | Sí               | N/D        |

### Marco legal

- EE. UU.: Computer Fraud and Abuse Act (CFAA)
- Reino Unido: Computer Misuse Act 1990
- UE: Directiva 2013/40/EU
- Internacional: Diversas leyes de ciberdelincuencia

Para obtener las pautas éticas completas, consulta [docs/ETHICS.md](https://github.com/rodhnin/pythia-sql-clairvoyance/blob/HEAD/docs/ETHICS.md)

---

## Contribuciones

Agradecemos las contribuciones: informes de errores, solicitudes de funciones, mejoras de documentación y contribuciones de código.

### Cómo contribuir

1. Haz un fork del repositorio
2. Crea una rama de características (`git checkout -b feature/amazing-feature`)
3. Realiza tus cambios y escribe pruebas
4. Haz commit de tus cambios
5. Sube la rama y abre un Pull Request

### Configuración del entorno de desarrollo```bash
git clone https://github.com/YOUR-USERNAME/pythia-sql-clairvoyance.git
cd pythia-sql-clairvoyance
python -m pip install -r requirements.txt
python -m pip install pytest black flake8 mypy
black pyth/
flake8 pyth/
pytest tests/

Documentación

Licencia

Este proyecto está licenciado bajo la Licencia MIT — consulta el archivo LICENSE para más detalles.

Descargo de responsabilidad

IMPORTANTE: Esta herramienta es solo para pruebas de seguridad autorizadas.

Al usar Pythia, reconoces y aceptas que:

Solo escanearás sistemas que te pertenezcan o tengas permiso explícito por escrito para probar
Cumplirás con todas las leyes y regulaciones aplicables
Entiendes que el acceso no autorizado es ilegal (CFAA, Computer Misuse Act, etc.)
El autor y los colaboradores no asumen ninguna responsabilidad por el mal uso

Agradecimientos

OWASP — Guía de inyección SQL, Testing Guide
SQLMap — Inspiración para métodos y técnicas de detección
PortSwigger — Recursos de Web Security Academy
LangChain — Framework de IA para análisis inteligente
Anthropic & OpenAI — Modelos de IA para la remediación de vulnerabilidades
Ollama — Inferencia de IA local para escaneo centrado en la privacidad
NVD/NIST — Datos CVE a través de API pública gratuita

Autor

Rodney Dhavid Jimenez Chacin (rodhnin)

Sitio web: rodhnin.com
GitHub: @rodhnin
Proyecto: pythia-sql-clairvoyance

Construida para hackers éticos, pentesters e ingenieros DevSecOps de todo el mundo

Reportar un error • Solicitar una función • Documentación

Pythia v0.2.0 — Mayo de 2026

Basado en errores	Errores SQL en las respuestas (MySQL, PostgreSQL, MSSQL, Oracle, SQLite)	Seguro
Ciego booleano	Diferencias en las respuestas ante condiciones TRUE/FALSE	Seguro
Ciego basado en tiempo	Retrasos en las respuestas por payloads SLEEP/WAITFOR	Agresivo
Basado en UNION	Extracción de datos mediante UNION SELECT	Agresivo
Segundo orden	Patrones de inyección almacenar→recuperar (cadena POST→GET)	Agresivo
Inyección ORDER BY	Inyección en el parámetro numérico de ordenación	Agresivo

AI_INTEGRATION.md	Guía completa de configuración de IA (proveedores, streaming, agente, seguimiento de costos)
CONSENT.md	Detalles técnicos del sistema de tokens de consentimiento
DATABASE_GUIDE.md	Esquema SQLite v1.1, consultas, tabla ai_costs
ETHICS.md	Marco legal y pautas éticas
REPORT_FORMAT.md	Esquema JSON completo, SARIF, formato diff
ROADMAP.md	Historial de funciones y planes de desarrollo
TESTING_GUIDE.md	Configuración del laboratorio Docker y escenarios de prueba v0.2.0

pythia-sql-clairvoyance

Más Populares