WPRecon

Un outil de reconnaissance WordPress et de scan de vulnérabilités, puissant et basé sur des templates

Fonctionnalités • Installation • Utilisation • Architecture • Templates

📋 Aperçu

WPRecon est un outil moderne de reconnaissance de sécurité WordPress, construit avec Go, qui aide les ingénieurs sécurité à identifier les vulnérabilités, les mauvaises configurations et les fuites d'informations dans les installations WordPress.

Contrairement aux scanners de vulnérabilités traditionnels avec des vérifications codées en dur, WPRecon utilise une architecture de templates pilotée par YAML, permettant :

✅ Extensibilité facile sans recompilation
✅ Collaboration en équipe via des templates partagés
✅ Déploiement rapide sous forme d'un binaire unique
✅ Scan parallèle haute performance
✅ Capacités flexibles de correspondance et d'extraction

Statistiques clés

Binaire unique - Aucune dépendance d'exécution
150+ templates - Couverture complète de WordPress
Scan parallèle - Pools de workers configurables
Code minimal - ~1 200 lignes de code de production
Prêt pour la production - Architecture éprouvée

⚡ Fonctionnalités

Capacités de base

Opérations HTTP

Toutes les méthodes HTTP standard (GET, POST, PUT, DELETE)
En-têtes et cookies personnalisés
Paramètres du corps de la requête
Prise en charge SSL/TLS
Timeouts configurables

Correspondances (5 types)

Identifier les hits positifs dans les réponses :

Statut - Correspondance du code de statut HTTP (200, 404, 500, etc.)
Mot - Présence d'une sous-chaîne dans le corps de la réponse
Regex - Correspondance de motifs avec groupes de capture
En-tête - Validation des en-têtes de réponse
Taille - Vérification de la taille du corps de la réponse

Extracteurs (2 types)

Extraire des données exploitables depuis les réponses correspondantes :

Regex - Extraire les groupes de capture à l'aide d'expressions régulières
JSON - Extraction simple par chemin JSON

Bibliothèque de templates

150+ templates prêts pour la production couvrant :

Détection WordPress - Détection du cœur et empreinte de version
Détection de plugins - Découverte de plugins populaires et détection de version
Énumération d'utilisateurs - Découverte d'utilisateurs WordPress
Vérifications CVE - Détection de vulnérabilités connues
Expositions - Fuites d'informations (backups, .git, .env, etc.)
Détection WAF - Cloudflare, AWS WAF, ModSecurity, Sucuri, Wordfence
Analyse de sécurité - Détection de mauvaises configurations et en-têtes de sécurité
Base de données - Exposition de base de données et détection de réparation

📦 Installation

Prérequis

Go 1.17 ou supérieur
Linux, macOS ou Windows

Depuis les sources

# Cloner le dépôt
git clone https://github.com/ffx64/wprecon.git
cd wprecon

# Compiler le binaire
go build -o wprecon ./cmd/wprecon/main.go

# Déplacer dans votre PATH (optionnel)
sudo mv wprecon /usr/local/bin/

Installer via Go

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

Docker (optionnel)

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

🚀 Utilisation

Interface en ligne de commande

Scan de base

Scanner un site WordPress avec tous les templates disponibles :

wprecon scan https://example.com

Scan avec des templates spécifiques

Exécuter uniquement les templates sélectionnés :

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

Format de sortie personnalisé

# Sortie JSON pour l'automatisation
wprecon scan https://example.com --output json

# Tableau joliment formaté (par défaut)
wprecon scan https://example.com --output table

Contrôle de la parallélisation et de la limitation de débit

# Utiliser 20 workers concurrents et 100 requêtes/sec
wprecon scan https://example.com --workers 20 --rate-limit 100

Lister les templates disponibles

wprecon list-templates

Afficher l'aide

wprecon --help

📋 Exemple de sortie

Lors de l'exécution d'un scan, WPRecon produit des résultats détaillés :

Format tableau :

ID                    | Template                | Nom                      | Sévérité | Cible               | Preuve
---------------------|------------------------|--------------------------|----------|---------------------|---------
finding_001           | wordpress-version      | Version WordPress trouvée| info     | example.com         | 6.2.1
finding_002           | plugin-detection       | Plugin détecté           | faible   | example.com         | Yoast SEO 16.0
finding_003           | security-headers       | En-têtes de sécurité manquants | moyen | example.com         | X-Frame-Options

Format 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": "Installation WordPress détectée",
      "description": "Installation du CMS WordPress identifiée sur la cible",
      "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": "Maintenez WordPress à jour vers la dernière version"
    }
  ]
}

🏗️ Architecture

Structure du projet

wprecon/
├── cmd/wprecon/
│   └── main.go                    # Point d'entrée CLI
├── internal/
│   ├── app/
│   │   ├── cli.go                 # Gestionnaires de commandes CLI
│   │   └── api.go                 # Gestionnaires d'API REST
│   ├── engine/
│   │   ├── scanner.go             # Orchestration du scan
│   │   ├── worker_pool.go         # Moteur de parallélisation
│   │   ├── context.go             # Gestion du contexte de scan
│   │   ├── logger.go              # Utilitaires de journalisation
│   │   └── rate_limit.go          # Limitation de débit
│   ├── executor/
│   │   ├── http_executor.go       # Client HTTP
│   │   ├── request_builder.go     # Construction de requêtes
│   │   └── variables.go           # Résolution de variables
│   ├── matchers/
│   │   └── matchers.go            # Logique de correspondance des réponses
│   ├── extractors/
│   │   └── extractors.go          # Extraction de données
│   ├── templates/
│   │   ├── loader.go              # Découverte des templates
│   │   └── parser.go              # Analyse YAML
│   ├── pipeline/
│   │   └── pipeline.go            # Workflow de scan
│   └── domain/
│       ├── template.go            # Modèles de données
│       ├── finding.go
│       ├── http.go
│       ├── matcher.go
│       └── extractor.go
├── templates/                      # Bibliothèque de templates YAML
│   ├── wordpress/                  # Spécifique WordPress
│   ├── cves/                       # Détection de CVE
│   ├── exposures/                  # Fuite d'informations
│   ├── common/                     # Vérifications génériques
│   └── waf/                        # Détection WAF
└── go.mod                          # Dépendances

Diagramme d'architecture

┌─────────────────────────────────────────────┐
│         Interface utilisateur (CLI/API)     │
└─────────────────────────────────────────────┘
          │
          ├─→ Chargeur de templates
          ├─→ Limiteur de débit
          └─→ Gestionnaire de pool de workers
          │
          ▼
┌─────────────────────────────────────────────┐
│          Moteur de pipeline de scan         │
│  ┌────────→ Constructeur de requêtes        │
│  │ ┌────────→ Exécuteur HTTP                │
│  │ │ ┌────────→ Correspondance (5 types)    │
│  │ │ │ ┌────────→ Extracteur (2 types)     │
│  │ │ │ │ ┌────────→ Rapport de résultat    │
│  │ │ │ │ │                                 │
│  ▼ ▼ ▼ ▼ ▼                                 │
│ Template → Requête → Réponse → Résultat    │
└─────────────────────────────────────────────┘
          │
          ▼
┌─────────────────────────────────────────────┐
│       Formateurs de sortie et stockage      │
│    (JSON, Tableau, Génération de rapport)   │
└─────────────────────────────────────────────┘

Principes de conception

Responsabilité unique - Chaque module a un objectif clair et précis
Piloté par templates - Toute la logique de scan réside dans YAML, pas dans le code
Évolutivité horizontale - Conception modulaire permettant une extension facile
Pattern Factory - Ajout simple de nouveaux matchers et extracteurs
Aucune dépendance externe - Uniquement les bibliothèques UUID et d'analyse YAML
Thread-safe - Scan concurrent sûr avec pools de workers

📚 Templates

Les templates sont des fichiers YAML qui définissent comment WPRecon doit scanner pour des vulnérabilités ou informations spécifiques.

Structure d'un template

id: wordpress-version-detection
name: Détection de version WordPress
description: Détecte et extrait la version WordPress depuis readme.html
severity: info
author: Équipe 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+)'

Catégories de templates

Cœur WordPress

Vulnérabilités

Détection de CVE pour les plugins WordPress
Vérifications de vulnérabilités connues
Détection de mauvaises configurations de sécurité

Fuite d'informations

Exposition de fichiers de sauvegarde (wp-config.php.bak, .sql)
Exposition de dépôt Git (.git/)
Exposition de fichier d'environnement (.env)
Mauvaise configuration de bucket S3

Détection WAF

Cloudflare
AWS WAF
ModSecurity
Sucuri
Wordfence
Détection WAF générique

Analyse de sécurité

En-têtes de sécurité manquants
Authentification faible
Mauvaise configuration CORS
Détection du mode débogage

Ajouter des templates personnalisés

Créez un nouveau fichier YAML dans templates/custom/
Suivez la structure du template (voir l'exemple ci-dessus)
Exécutez WPRecon - les templates sont découverts automatiquement

Exemple :

# Créer un template personnalisé
cat > templates/custom/my-check.yaml << 'EOF'
id: my-custom-check
name: Ma vérification personnalisée
description: Détecte une vulnérabilité personnalisée
severity: medium
author: Votre nom

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

# Scanner avec le template personnalisé
wprecon scan https://example.com -t my-custom-check

🔧 Configuration

Variables d'environnement

# Timeout HTTP (par défaut : 10s)
export WPRECON_TIMEOUT=15

# Nombre de workers (par défaut : 10)
export WPRECON_WORKERS=20

# Requêtes par seconde (par défaut : 50)
export WPRECON_RATE_LIMIT=100

# Niveau de log (par défaut : info)
export WPRECON_LOG_LEVEL=debug

# Répertoires de templates (par défaut : ./templates)
export WPRECON_TEMPLATE_DIRS=/chemin/vers/templates:/chemin/vers/autres/templates

Options CLI

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

💼 Cas d'utilisation

Évaluations de sécurité

Évaluation complète de la sécurité des installations WordPress :

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

Intégration CI/CD

Scan automatisé des vulnérabilités dans les pipelines de déploiement :

# Exemple GitHub Actions
- nom: Scan de sécurité WordPress
  run: |
    wprecon scan ${{ secrets.STAGING_URL }} \
      --output json \
      --templates wordpress-detection,plugin-detection,cve-checks

Reconnaissance de masse

Scanner plusieurs cibles efficacement :

cat cibles.txt | while read cible; do
  wprecon scan "$cible" --output json >> resultats.json
done

🛠️ Développement

Prérequis

Go 1.17+

Compilation

# Compiler le binaire
go build -o wprecon ./cmd/wprecon/main.go

# Compiler pour plusieurs plateformes
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

Dépendances du projet

google/uuid v1.6.0   - Génération d'UUID pour les résultats
gopkg.in/yaml.v3     - Analyse des templates YAML

Structure du code

Dépendances minimales - Bibliothèques essentielles uniquement
Architecture propre - Conception en couches pour la maintenabilité
Extensible - Facile d'ajouter des matchers, extracteurs et templates
Bien documenté - Commentaires de code clairs et documentation

🤝 Contribuer aux templates

Forkez le dépôt
Créez une branche de fonctionnalité (git checkout -b feature/mon-template)
Ajoutez votre template dans templates/
Testez minutieusement : wprecon scan https://test.site -t votre-template
Soumettez une Pull Request

📄 Licence

Ce projet est sous licence MIT - voir le fichier LICENSE pour plus de détails.

Fait avec ❤️ pour Matheus (ffx64)

⬆ retour en haut

Scan parallèle	Pool de workers configurable (par défaut : 10 workers) pour les requêtes concurrentes
Limitation de débit	Limitation de requêtes intégrée (par défaut : 50 req/s) pour être respectueux du réseau
Réessai automatique	Logique de réessai automatique pour les requêtes HTTP échouées
Rechargement à chaud des templates	Aucune recompilation nécessaire – ajoutez des templates et scannez
Résolution de variables	Variables dynamiques : `{{BaseURL}}`, `{{Timestamp}}`, `{{RandomInt}}`
Sortie multi-format	Tableaux lisibles et JSON structuré
Modes CLI et API	Interfaces en ligne de commande et API REST
Niveaux de sévérité	Résultats classés info, faible, moyen, élevé, critique

`wordpress-detection`	Détecter une installation WordPress
`wordpress-version`	Empreinte de la version WordPress
`plugins.yaml`	Détecter les plugins installés
`themes.yaml`	Détecter les thèmes installés
`users.yaml`	Énumérer les utilisateurs WordPress

wprecon

Populaires

WPRecon

📋 Aperçu

Statistiques clés

⚡ Fonctionnalités

Capacités de base

Opérations HTTP

Correspondances (5 types)

Extracteurs (2 types)

Bibliothèque de templates

📦 Installation

Prérequis

Depuis les sources

Installer via Go

Docker (optionnel)

🚀 Utilisation

Interface en ligne de commande

Scan de base

Scan avec des templates spécifiques

Format de sortie personnalisé

Contrôle de la parallélisation et de la limitation de débit

Lister les templates disponibles

Afficher l'aide

📋 Exemple de sortie

🏗️ Architecture

Structure du projet

Diagramme d'architecture

Principes de conception

📚 Templates

Structure d'un template

Catégories de templates

Cœur WordPress

Vulnérabilités

Fuite d'informations

Détection WAF

Analyse de sécurité

Ajouter des templates personnalisés

🔧 Configuration

Variables d'environnement

Options CLI

💼 Cas d'utilisation

Évaluations de sécurité

Intégration CI/CD

Reconnaissance de masse

🛠️ Développement

Prérequis

Compilation

Dépendances du projet

Structure du code

🤝 Contribuer aux templates

📄 Licence