WPRecon

Un potente strumento di ricognizione e scansione delle vulnerabilità di WordPress basato su template

Caratteristiche • Installazione • Utilizzo • Architettura • Template

📋 Panoramica

WPRecon è un moderno strumento di ricognizione della sicurezza per WordPress, scritto in Go, che aiuta gli ingegneri della sicurezza a identificare vulnerabilità, configurazioni errate e problemi di divulgazione di informazioni nelle installazioni di WordPress.

A differenza degli scanner di vulnerabilità tradizionali con controlli hard-coded, WPRecon utilizza un'architettura a template basata su YAML, che consente:

✅ Facile estensibilità senza ricompilazione
✅ Collaborazione in team tramite template condivisi
✅ Distribuzione rapida come singolo binario
✅ Scansione parallela ad alte prestazioni
✅ Capacità flessibili di corrispondenza ed estrazione

Statistiche chiave

Singolo binario - Nessuna dipendenza runtime
150+ template - Copertura completa di WordPress
Scansione parallela - Pool di worker configurabili
Codice minimo - ~1.200 righe di codice di produzione
Pronto per la produzione - Architettura testata sul campo

⚡ Caratteristiche

Capacità principali

Operazioni HTTP

Tutti i metodi HTTP standard (GET, POST, PUT, DELETE)
Header e cookie personalizzati
Parametri del corpo della richiesta
Supporto SSL/TLS
Timeout configurabili

Matcher (5 tipi)

Identifica i risultati positivi nelle risposte:

Stato - Corrispondenza del codice di stato HTTP (200, 404, 500, ecc.)
Parola - Presenza di sottostringhe nel corpo della risposta
Regex - Corrispondenza di pattern con gruppi di cattura
Header - Validazione dell'header della risposta
Dimensione - Controllo della dimensione del corpo della risposta

Estrattori (2 tipi)

Estrai dati utilizzabili dalle risposte corrispondenti:

Regex - Estrai gruppi di cattura usando espressioni regolari
JSON - Estrazione semplice di percorsi JSON

Libreria di template

150+ template pronti per la produzione che coprono:

Rilevamento di WordPress - Rilevamento del core e fingerprinting della versione
Rilevamento di plugin - Scoperta di plugin popolari e rilevamento della versione
Enumerazione utenti - Scoperta di utenti WordPress
Controlli CVE - Rilevamento di vulnerabilità note
Esposizioni - Divulgazione di informazioni (backup, .git, .env, ecc.)
Rilevamento WAF - Cloudflare, AWS WAF, ModSecurity, Sucuri, Wordfence
Analisi della sicurezza - Rilevamento di configurazioni errate e header di sicurezza
Database - Esposizione del database e rilevamento di riparazione

📦 Installazione

Requisiti

Go 1.17 o superiore
Linux, macOS o Windows

Dal sorgente

# Clona il repository
git clone https://github.com/ffx64/wprecon.git
cd wprecon

# Compila il binario
go build -o wprecon ./cmd/wprecon/main.go

# Sposta nel PATH (opzionale)
sudo mv wprecon /usr/local/bin/

Installa tramite Go

go install github.com/ffx64/wprecon/cmd/wprecon@latest

Docker (opzionale)

docker build -t wprecon .
docker run wprecon scan https://example.com

🚀 Utilizzo

Interfaccia a riga di comando

Scansione base

Esegue la scansione di un sito WordPress con tutti i template disponibili:

wprecon scan https://example.com

Scansione con template specifici

Esegue solo i template selezionati:

wprecon scan https://example.com -t wordpress-detection,plugin-detection,user-enumeration

Formato di output personalizzato

# Output JSON per automazione
wprecon scan https://example.com --output json

# Tabella ben formattata (default)
wprecon scan https://example.com --output table

Controllo della parallelizzazione e della limitazione della frequenza

# Usa 20 worker concorrenti e 100 richieste/sec
wprecon scan https://example.com --workers 20 --rate-limit 100

Elenca i template disponibili

wprecon list-templates

Mostra l'aiuto

wprecon --help

📋 Esempio di output

Durante l'esecuzione di una scansione, WPRecon produce risultati dettagliati:

Formato tabella:

ID                    | Template                | Nome                      | Gravità | Destinazione      | Evidenza
---------------------|------------------------|--------------------------|--------|---------------------|----------
finding_001           | wordpress-version      | Versione WordPress Trovata  | info     | example.com         | 6.2.1
finding_002           | plugin-detection       | Plugin Rilevato          | basso      | example.com         | Yoast SEO 16.0
finding_003           | security-headers       | Header di Sicurezza Mancanti | medio   | example.com         | X-Frame-Options

Formato JSON:

{
  "scan_id": "scan_uuid_001",
  "timestamp": "2026-04-10T14:37:00Z",
  "target": "https://example.com",
  "total_findings": 15,
  "findings": [
    {
      "id": "finding_uuid_001",
      "template_id": "wordpress-detection",
      "name": "Installazione WordPress Rilevata",
      "description": "Installazione CMS WordPress identificata sul target",
      "severity": "info",
      "cvss_score": 0.0,
      "matched_url": "https://example.com/wp-admin/",
      "http_method": "GET",
      "status_code": 200,
      "response_time_ms": 245,
      "evidence": {
        "version": "6.2.1",
        "wp_version_header": "6.2.1"
      },
      "timestamp": "2026-04-10T14:37:00Z",
      "remediation": "Mantenere WordPress aggiornato all'ultima versione"
    }
  ]
}

🏗️ Architettura

Struttura del progetto

wprecon/
├── cmd/wprecon/
│   └── main.go                    # Punto di ingresso CLI
├── internal/
│   ├── app/
│   │   ├── cli.go                 # Gestori comandi CLI
│   │   └── api.go                 # Gestori API REST
│   ├── engine/
│   │   ├── scanner.go             # Orchestrazione scansione
│   │   ├── worker_pool.go         # Motore di parallelizzazione
│   │   ├── context.go             # Gestione contesto scansione
│   │   ├── logger.go              # Utility di logging
│   │   └── rate_limit.go          # Limitazione della frequenza
│   ├── executor/
│   │   ├── http_executor.go       # Client HTTP
│   │   ├── request_builder.go     # Costruzione richiesta
│   │   └── variables.go           # Risoluzione variabili
│   ├── matchers/
│   │   └── matchers.go            # Logica di corrispondenza delle risposte
│   ├── extractors/
│   │   └── extractors.go          # Estrazione dati
│   ├── templates/
│   │   ├── loader.go              # Scoperta template
│   │   └── parser.go              # Parsing YAML
│   ├── pipeline/
│   │   └── pipeline.go            # Workflow scansione
│   └── domain/
│       ├── template.go            # Modelli dati
│       ├── finding.go
│       ├── http.go
│       ├── matcher.go
│       └── extractor.go
├── templates/                      # Libreria template YAML
│   ├── wordpress/                  # Specifici per WordPress
│   ├── cves/                       # Rilevamento CVE
│   ├── exposures/                  # Divulgazione informazioni
│   ├── common/                     # Controlli generici
│   └── waf/                        # Rilevamento WAF
└── go.mod                          # Dipendenze

Diagramma dell'architettura

┌─────────────────────────────────────────────┐
│         Interfaccia Utente (CLI/API)        │
└─────────────────────────────────────────────┘
          │
          ├─→ Caricatore Template
          ├─→ Limitatore di Frequenza
          └─→ Gestore Pool di Worker
          │
          ▼
┌─────────────────────────────────────────────┐
│         Motore del Pipeline di Scansione    │
│  ┌────────→ Costruttore Richiesta             │
│  │ ┌────────→ Esecutore HTTP                 │
│  │ │ ┌────────→ Matcher (5 tipi)             │
│  │ │ │ ┌────────→ Estrattore (2 tipi)        │
│  │ │ │ │ ┌────────→ Report del Risultato     │
│  │ │ │ │ │                                 │
│  ▼ ▼ ▼ ▼ ▼                                 │
│ Template → Richiesta → Risposta → Risultato │
└─────────────────────────────────────────────┘
          │
          ▼
┌─────────────────────────────────────────────┐
│       Formattatori di Output e Archiviazione│
│    (JSON, Tabella, Generazione Report)      │
└─────────────────────────────────────────────┘

Principi di progettazione

Singola responsabilità - Ogni modulo ha uno scopo chiaro e focalizzato
Guidato da template - Tutta la logica di scansione vive in YAML, non nel codice
Scalabilità orizzontale - Design modulare per facile estensione
Pattern Factory - Aggiunta semplice di nuovi matcher ed estrattori
Nessuna dipendenza esterna - Solo librerie UUID e parsing YAML
Thread-safe - Scansione concorrente sicura con pool di worker

📚 Template

I template sono file YAML che definiscono come WPRecon deve scansionare per specifiche vulnerabilità o informazioni.

Struttura del template

id: wordpress-version-detection
name: Rilevamento Versione WordPress
description: Rileva ed estrae la versione di WordPress da readme.html
severity: info
author: Team WPRecon

requests:
  - url: "{{BaseURL}}/readme.html"
    method: GET
    
    matchers:
      - type: status
        status:
          - 200
      
      - type: word
        words:
          - "WordPress"
    
    extractors:
      - type: regex
        regex:
          - 'Version (\d+\.\d+\.\d+)'

Categorie di template

Core di WordPress

Vulnerabilità

Rilevamento CVE per plugin WordPress
Controlli di vulnerabilità note
Rilevamento di configurazioni errate di sicurezza

Divulgazione di informazioni

Esposizione di file di backup (wp-config.php.bak, .sql)
Esposizione repository Git (.git/)
Esposizione file di ambiente (.env)
Configurazione errata bucket S3

Rilevamento WAF

Cloudflare
AWS WAF
ModSecurity
Sucuri
Wordfence
Rilevamento WAF generico

Analisi della sicurezza

Header di sicurezza mancanti
Autenticazione debole
Configurazione errata CORS
Rilevamento modalità debug

Aggiunta di template personalizzati

Crea un nuovo file YAML in templates/custom/
Segui la struttura del template (vedi esempio sopra)
Esegui WPRecon - i template vengono scoperti automaticamente

Esempio:

# Crea template personalizzato
cat > templates/custom/mio-controllo.yaml << 'EOF'
id: mio-controllo-personalizzato
name: Mio Controllo Personalizzato
description: Rileva vulnerabilità personalizzata
severity: medium
author: Il Tuo Nome

requests:
  - url: "{{BaseURL}}/endpoint-vulnerabile"
    method: GET
    
    matchers:
      - type: status
        status:
          - 200
      
      - type: word
        words:
          - "vulnerabile"
EOF

# Scansiona con template personalizzato
wprecon scan https://example.com -t mio-controllo-personalizzato

🔧 Configurazione

Variabili d'ambiente

# Timeout HTTP (default: 10s)
export WPRECON_TIMEOUT=15

# Numero di worker (default: 10)
export WPRECON_WORKERS=20

# Richieste al secondo (default: 50)
export WPRECON_RATE_LIMIT=100

# Livello di log (default: info)
export WPRECON_LOG_LEVEL=debug

# Directory dei template (default: ./templates)
export WPRECON_TEMPLATE_DIRS=/percorso/dei/template:/percorso/di/altri/template

Flag CLI

wprecon scan <target> \
  --templates-dir ./template-personalizzati \
  --workers 20 \
  --rate-limit 100 \
  --timeout 15 \
  --output json \
  --log-level debug

💼 Casi d'uso

Valutazioni di sicurezza

Valutazione completa della sicurezza delle installazioni WordPress:

wprecon scan https://example.com --output json > report_valutazione.json

Integrazione CI/CD

Scansione automatica delle vulnerabilità nelle pipeline di deployment:

# Esempio GitHub Actions
- name: Scansione sicurezza WordPress
  run: |
    wprecon scan ${{ secrets.STAGING_URL }} \
      --output json \
      --templates wordpress-detection,plugin-detection,cve-checks

Ricognizione di massa

Scansiona più target in modo efficiente:

cat targets.txt | while read target; do
  wprecon scan "$target" --output json >> risultati.json
done

🛠️ Sviluppo

Prerequisiti

Go 1.17+

Compilazione

# Compila binario
go build -o wprecon ./cmd/wprecon/main.go

# Compila per più piattaforme
GOOS=linux GOARCH=amd64 go build -o wprecon-linux ./cmd/wprecon/main.go
GOOS=darwin GOARCH=amd64 go build -o wprecon-darwin ./cmd/wprecon/main.go
GOOS=windows GOARCH=amd64 go build -o wprecon-windows.exe ./cmd/wprecon/main.go

Dipendenze del progetto

google/uuid v1.6.0   - Generazione UUID per i risultati
gopkg.in/yaml.v3     - Parsing template YAML

Struttura del codice

Dipendenze minime - Solo librerie essenziali
Architettura pulita - Design a strati per manutenibilità
Estensibile - Facile aggiunta di matcher, estrattori e template
Ben documentato - Commenti e documentazione chiari

🤝 Contribuire con template

Fai il fork del repository
Crea un branch per la funzionalità (git checkout -b feature/mio-template)
Aggiungi il tuo template in templates/
Testa a fondo: wprecon scan https://test.site -t tuo-template
Invia una Pull Request

📄 Licenza

Questo progetto è concesso in licenza con la licenza MIT - vedi il file LICENSE per i dettagli.

Fatto con ❤️ per Matheus (ffx64)

⬆ torna all'inizio

Scansione parallela	Pool di worker configurabile (default: 10 worker) per richieste concorrenti
Limitazione della frequenza	Throttling delle richieste integrato (default: 50 req/s) per essere rispettoso della rete
Ritentativo automatico	Logica di ripetizione automatica per richieste HTTP fallite
Ricaricamento a caldo dei template	Nessuna ricompilazione necessaria - aggiungi template e scansiona
Risoluzione delle variabili	Variabili dinamiche: `{{BaseURL}}`, `{{Timestamp}}`, `{{RandomInt}}`
Output multi-formato	Tabelle leggibili dall'uomo e JSON strutturato
Modalità CLI e API	Sia interfaccia a riga di comando che API REST
Livelli di gravità	Risultati classificati come info, basso, medio, alto, critico

`wordpress-detection`	Rileva installazione WordPress
`wordpress-version`	Impronta digitale della versione di WordPress
`plugins.yaml`	Rileva plugin installati
`themes.yaml`	Rileva temi installati
`users.yaml`	Enumera utenti WordPress

wprecon

Più Popolari