Scanner de injeção SQL pronto para produção com 6 métodos de detecção, remediação baseada em IA, saída SARIF e integração CI/CD.

Início Rápido · Documentação · Docker · Análise com IA · Estrela no GitHub

Em Ação

_{Varredura ao vivo · Loja PHP vulnerável · 11 descobertas detectadas · modo seguro · 2265.56s}

_{Relatório HTML — visão geral das descobertas com badges de severidade e mapeamento OWASP}

_{Tabela de descobertas — códigos PYTHIA-SQL, detecção de DBMS, mapeamento CWE-89}

O que é Pythia?

Pythia é um scanner de detecção de injeção SQL pronto para produção que coloca a ética em primeiro lugar. Construído para testadores de penetração, pesquisadores de segurança e engenheiros DevSecOps, ele identifica vulnerabilidades de injeção SQL em 6 métodos de detecção e se integra diretamente em pipelines CI/CD.

Por que Pythia?

Ético por Design: Sistema de token de consentimento impede varreduras não autorizadas
Detecção Multimétodo: 6 técnicas de detecção incluindo injeção de segunda ordem e ORDER BY
Com IA: GPT, Claude ou Ollama local para guias de remediação inteligentes com exemplos de código
Pronto para CI/CD: Flags --fail-on, --sarif, --diff para integração em pipelines
Relatórios Profissionais: HTML com barra de filtro + badges OWASP/CWE/CVE + JSON com pontuação CVSS contextual
Rastreamento Persistente: Banco de dados SQLite compartilhado com o Argos Suite (~/.argos/argos.db)
Alta Precisão: Endurecimento contra falsos positivos com pontuação de similaridade e confirmação multi-payload

O que Detecta

Recursos

Detecção Central de Injeção SQL```bash

One command, comprehensive SQLi analysis

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

- **14 Códigos de Descoberta**: Específicos de DBMS (MySQL, PostgreSQL, MSSQL, Oracle, SQLite) + específicos de técnica
- **Identificação de DBMS**: Detecção automática de tipo e versão de banco de dados
- **WAF Bypass**: Mais de 170 payloads de bypass em modo agressivo (hex, codificação URL, comentários inline, variações de maiúsculas/minúsculas)
- **Detecção de Variáveis de Sessão**: Cadeia POST→GET para padrões de autenticação estilo DVWA-high
- **Crawler Inteligente**: BFS com extração de popup/onclick (--js), sitemap, robots.txt
- **Fortalecimento contra Falsos Positivos**: Pontuação de similaridade SequenceMatcher + confirmação com múltiplos payloads

### Integração 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

Cabeçalhos de Autenticação```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

Pass `--auth-header` várias vezes para múltiplos cabeçalhos.

### Análise com IA

Escolha seu provedor de IA a partir da linha de comando:

| Provedor                         | Melhor para                      | Velocidade | Custo        | Privacidade   |
| -------------------------------- | -------------------------------- | ---------- | ------------ | ------------- |
| **OpenAI gpt-4o-mini** (padrão)  | Qualidade de produção, baixo custo | Rápida   | ~$0.02/scan | Padrão        |
| **Anthropic Claude**             | Foco em privacidade, remediação de código | Rápida | ~$0.06/scan | Aprimorada    |
| **Ollama (Local)**               | Privacidade total                | Lenta (CPU) | Gratuito    | 100% Offline  |```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

Relatórios Profissionais

JSON Reports (Legível por máquina, v0.2.0 schema)```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 }

**Relatórios HTML** (Amigáveis ao Humano)

- Barra de filtros: severidade, categoria OWASP, método de detecção, SGBD
- Emblemas OWASP/CWE/CVE por descoberta (clicáveis para referências externas)
- Pontuação CVSS base + contextual com codificação por cores
- Seções de evidência expansíveis com visualização de payload
- Abas de análise IA (padrão / agente / comparação)
- Seção de diff (descobertas novas/corrigidas/persistentes)
- Tema Oracle (roxo `#6a11cb`) — entregável a clientes sem edição

### Códigos de Descobertas

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

| Código             | Tipo               | SGBD / Vetor            | Modo       |
| ------------------ | ------------------ | ------------------------ | ---------- |
| `PYTHIA-SQL-001` | Baseado em Erro        | MySQL / MariaDB          | Seguro       |
| `PYTHIA-SQL-002` | Baseado em Erro        | PostgreSQL               | Seguro       |
| `PYTHIA-SQL-003` | Baseado em Erro        | MSSQL                    | Seguro       |
| `PYTHIA-SQL-004` | Baseado em Erro        | Oracle                   | Seguro       |
| `PYTHIA-SQL-005` | Baseado em Erro        | SQLite                   | Seguro       |
| `PYTHIA-SQL-010` | Cego Booleano      | Qualquer SGBD                 | Seguro       |
| `PYTHIA-SQL-011` | Cego Booleano      | Via injeção de cabeçalho     | Seguro       |
| `PYTHIA-SQL-020` | Baseado em Tempo         | MySQL SLEEP()            | Agressivo |
| `PYTHIA-SQL-021` | Baseado em Tempo         | MSSQL WAITFOR            | Agressivo |
| `PYTHIA-SQL-022` | Baseado em Tempo         | PostgreSQL pg_sleep()    | Agressivo |
| `PYTHIA-SQL-030` | Baseado em UNION        | Parâmetro GET/POST       | Agressivo |
| `PYTHIA-SQL-031` | Baseado em UNION        | Via cookie               | Agressivo |
| `PYTHIA-SQL-040` | Segunda Ordem       | Padrão armazenar → recuperar | Agressivo |
| `PYTHIA-SQL-050` | Injeção ORDER BY | Parâmetro de ordenação numérica   | Agressivo |

---

## Validação e Testes

Pythia v0.2.0 foi **validada empiricamente** usando aplicações vulneráveis controladas baseadas em Docker.

### Resultados do QA (Maio de 2026)

| Alvo                  | Modo                              | Descobertas        | Notas                                      |
| ----------------------- | --------------------------------- | --------------- | ------------------------------------------ |
| **PHP Lab** (8081)      | `--aggressive`                    | **26 descobertas** | Todas as 4 técnicas + segunda ordem + ORDER BY |
| **Flask Lab** (8082)    | `--js --aggressive`               | **18 descobertas** | Variável de sessão + segunda ordem + 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  | Formulário POST, todas as técnicas                  |
| **DVWA High**           | `--js --max-pages 2 --aggressive` | 4/4 técnicas  | Cadeia POST→GET de variável de sessão            |
| **Teste de Falso Positivo** | `--aggressive`                    | **0 descobertas**  | URL estática — confirmado sem falsos positivos  |

**Validações Chave:**

- ✅ Todos os 14 códigos de descobertas funcionais
- ✅ DVWA alto (padrão de variável de sessão) — paridade total 4/4
- ✅ Detecção de segunda ordem (PYTHIA-SQL-040)
- ✅ Detecção de injeção ORDER BY (PYTHIA-SQL-050)
- ✅ Zero falsos positivos em URLs estáticas
- ✅ Códigos de saída `--fail-on` (0/10/1) corretos
- ✅ Saída SARIF 2.1.0 validada
- ✅ Comparação `--diff last` funcionando
- ✅ `--auth-header` transmite cabeçalhos por todas as requisições

---

## Início Rápido

### Pré-requisitos

- **Python 3.11+** (3.12 recomendado)
- **pip** (gerenciador de pacotes Python)
- **Docker** (opcional, para laboratórios vulneráveis)

### Instalação

**1. Clone o repositório**```bash
git clone https://github.com/rodhnin/pythia-sql-clairvoyance.git
cd pythia-sql-clairvoyance

2. Crie e ative o ambiente virtual```bash python3 -m venv .venv source .venv/bin/activate

**3. Instalar dependências**```bash
python -m pip install --upgrade pip
python -m pip install -r requirements.txt

4. Configure as chaves de API (se estiver usando cloud AI)```bash export OPENAI_API_KEY="sk-..." export ANTHROPIC_API_KEY="sk-ant-..."

**5. Verificar instalação**```bash
python -m pyth --version
# Output: Pythia v0.2.0

Sua Primeira Varredura```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

Relatórios salvos em `~/.pythia/reports/`.

---

## Guia de Uso

### Referência de Flags 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

Varredura Básica```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

### Integração 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

Varredura Autenticada```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"

### Rastreamento Consciente de JavaScript```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"

A flag --js usa extração por regex de atributos onclick — nenhuma dependência do Playwright necessária.

Modo Agressivo```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

---

## Implantação Docker

O Pythia oferece duas opções de implantação Docker:

1. **Imagem do Scanner**: Construa o Pythia como uma imagem Docker para verificações únicas
2. **Laboratório de Testes**: Aplicações vulneráveis (DVWA, PHP, Flask) para testes seguros

### Início Rápido```bash
cd docker
./deploy.sh

Laboratório de Testes (Aplicações Vulneráveis)

NUNCA exponha o laboratório de testes à internet pública — APENAS PARA TESTES LOCAIS!```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álise Potenciada por IA

Pythia usa **LangChain v1.0.0** com suporte para múltiplos provedores de IA.

### Dois Modos de Análise

- **Técnico**: Prepared statements, consultas parametrizadas, código de validação de entrada (PHP/PDO, Python/SQLAlchemy, Node.js/pg, Java/PreparedStatement)
- **Executivo**: Avaliação de risco em linguagem simples para stakeholders e gestão

### Mudar de Provedor```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

A configuração YAML (config/default.yaml) ainda pode ser usada como fallback. As flags da CLI têm prioridade.

Para o guia completo de integração de IA, consulte docs/AI_INTEGRATION.md

Compreendendo Relatórios

Arquivos de Relatório```

~/.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

### Mapeamento de Gravidade

- **CRÍTICO (9.0-10.0)**: Baseado em erro, baseado em tempo, baseado em UNION, segunda-ordem com exploração confirmada
- **ALTO (7.0-8.9)**: Booleano-cego (alta confiança), injeção ORDER BY
- **MÉDIO (4.0-6.9)**: Booleano-cego (confiança média)
- **BAIXO (0.1-3.9)**: Possível SQLi com evidência inconclusiva

### Códigos de Saída

| Código | Significado                                                                        |
| ------ | ---------------------------------------------------------------------------------- |
| `0`    | Escaneamento concluído, nenhum achado no limite `--fail-on` (ou nenhum `--fail-on` usado) |
| `1`    | Erro técnico (conexão, tempo limite, banco de dados)                               |
| `10`   | Achados encontrados no ou acima do limite de gravidade `--fail-on`                 |
| `130`  | Usuário cancelou (Ctrl+C)                                                          |

---

## Persistência de Banco de Dados

Banco de dados SQLite **compartilhado com o ecossistema Argos** (`~/.argos/argos.db`):

- **Histórico de Escaneamentos**: Data, duração, contagem de achados, métodos de detecção
- **Repositório de Achados**: Banco de dados pesquisável de vulnerabilidades de injeção SQL
- **Domínios Verificados**: Rastreamento de token de consentimento com expiração
- **Custos de IA**: Rastreamento de custo por escaneamento (novo na 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"

Estrutura do Projeto```

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

---

## Roteiro

### v0.1.0 — Lançamento Inicial (Novembro de 2025)

**Status:** Lançado

- 4 métodos de detecção, remediação com IA, sistema de consentimento, relatórios HTML+JSON, persistência SQLite

### v0.2.0 — Paridade Total e Recursos Empresariais (Maio de 2026)

**Status:** Lançado

- 6 métodos de detecção (adicionado second-order + ORDER BY)
- 14 códigos de descoberta específicos de SGBD
- Integração CI/CD (`--fail-on`, `--sarif`, `--diff`)
- Cabeçalhos de autenticação, rastreamento com reconhecimento de JavaScript, payloads de bypass de WAF
- IA: streaming, comparação, agente (consulta NVD CVE), rastreamento de custos, flags `--ai-provider`/`--ai-model`
- Pontuação de risco OWASP/CWE/CVSS/contextual em cada descoberta
- Endurecimento contra falsos positivos (pontuação de similaridade, confirmação multi-payload)
- Paridade de alta segurança do DVWA (cadeia de variáveis de sessão)

### v0.3.0 — Suíte Pytest e Ferramentas para Desenvolvedores (Q3 2026)

**Planejado:**

- 40+ testes pytest cobrindo todos os 14 códigos de descoberta
- Gerenciamento interativo de configuração (`python -m pyth config set`)
- CLI de banco de dados (`python -m pyth db scans list`)
- Detecção de expiração de sessão durante varreduras autenticadas
- Varredura em lote multi-site (`--targets targets.txt`)

### v0.4.0 — Inteligência e Automação (Q1 2027)

**Planejado:**

- Detecção de anomalias baseada em ML
- Exploração automatizada somente leitura (prova de impacto)
- Interface de chat com IA para análise de resultados de varredura

Para descrições detalhadas dos recursos, veja [docs/ROADMAP.md](https://github.com/rodhnin/pythia-sql-clairvoyance/blob/HEAD/docs/ROADMAP.md)

---

## Ética e Legal

### A Regra de Ouro

**Varra apenas sistemas que você possui ou para os quais tenha permissão explícita por escrito para testar.**

### Aplicação de Consentimento

| Modo            | Testes                     | Consentimento Necessário | Limite de Taxa |
| --------------- | -------------------------- | ------------------------ | -------------- |
| **Safe**        | Error-Based, Boolean-Blind | Não                      | 2.0 req/s      |
| **Aggressive**  | All 6 techniques           | Sim                      | 5.0 req/s      |
| **AI Analysis** | Remediation guide          | Sim                      | N/A            |

### Quadro Legal

- EUA: Computer Fraud and Abuse Act (CFAA)
- Reino Unido: Computer Misuse Act 1990
- UE: Diretiva 2013/40/EU
- Internacional: Várias leis de crimes cibernéticos

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

---

## Contribuição

Aceitamos contribuições — relatórios de bugs, solicitações de recursos, melhorias na documentação e contribuições de código.

### Como Contribuir

1. Faça um fork do repositório
2. Crie um branch de funcionalidade (`git checkout -b feature/amazing-feature`)
3. Faça suas alterações e escreva testes
4. Faça commit das suas alterações
5. Envie o branch e abra um Pull Request

### Configuração de Desenvolvimento```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/

Documentação

Licença

Este projeto é licenciado sob a Licença MIT — consulte o arquivo LICENSE para mais detalhes.

Aviso Legal

IMPORTANTE: Esta ferramenta destina-se apenas a testes de segurança autorizados.

Ao usar o Pythia, você reconhece e concorda que:

Você apenas varrerá sistemas que possui ou para os quais tenha permissão explícita por escrito
Você cumprirá todas as leis e regulamentos aplicáveis
Você entende que o acesso não autorizado é ilegal (CFAA, Computer Misuse Act, etc.)
O autor e os contribuidores não assumem qualquer responsabilidade por uso indevido

Agradecimentos

OWASP — Orientação sobre injeção SQL, Testing Guide
SQLMap — Inspiração para métodos e técnicas de detecção
PortSwigger — Recursos da Web Security Academy
LangChain — Framework de IA para análise inteligente
Anthropic & OpenAI — Modelos de IA para remediação de vulnerabilidades
Ollama — Inferência de IA local para varredura focada em privacidade
NVD/NIST — Dados de CVE via API pública gratuita

Autor

Rodney Dhavid Jimenez Chacin (rodhnin)

Website: rodhnin.com
GitHub: @rodhnin
Projeto: pythia-sql-clairvoyance

Construído para hackers éticos, testadores de penetração e engenheiros DevSecOps em todo o mundo

Reportar Bug • Solicitar Recurso • Documentação

Pythia v0.2.0 — Maio de 2026

Baseado em Erro	Erros SQL nas respostas (MySQL, PostgreSQL, MSSQL, Oracle, SQLite)	Safe
Cego Booleano	Diferenças de resposta de condições TRUE/FALSE	Safe
Cego Baseado em Tempo	Atrasos nas respostas de payloads SLEEP/WAITFOR	Aggressive
Baseado em UNION	Extração de dados via UNION SELECT	Aggressive
Segunda Ordem	Padrões de injeção armazenar→recuperar (cadeia POST→GET)	Aggressive
Injeção em ORDER BY	Injeção em parâmetro de ordenação numérica	Aggressive

AI_INTEGRATION.md	Guia completo de configuração de IA (provedores, streaming, agente, custo)
CONSENT.md	Detalhes técnicos do sistema de token de consentimento
DATABASE_GUIDE.md	Schema SQLite v1.1, consultas, tabela ai_costs
ETHICS.md	Marco legal e diretrizes éticas
REPORT_FORMAT.md	Schema JSON completo, SARIF, formato diff
ROADMAP.md	Histórico de funcionalidades e planos de desenvolvimento
TESTING_GUIDE.md	Configuração de laboratório Docker e cenários de teste v0.2.0

Mais Populares

pythia-sql-clairvoyance