Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
wprecon — WRecon es una herramienta para el reconocimiento de vulnerabilidades e información de caja negra para wordpress. | Kitploit
Herramientas/GitHubGitHub/ffx64/wprecon
ReconocimientoEscáneres de VulnerabilidadesRecopilación de InformaciónSeguridad WebPruebas de Penetración
GitHubffx64/wprecon

wprecon

WRecon es una herramienta para el reconocimiento de vulnerabilidades e información de caja negra para wordpress.

Ver Repositorio
2031hace 4 mesesRevisado por Kitploit

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

WPRecon

Una potente herramienta de reconocimiento y escaneo de vulnerabilidades para WordPress, basada en plantillas

Go 1.17+ Licencia PRs Bienvenidos

Características • Instalación • Uso • Arquitectura • Plantillas


📋 Resumen

WPRecon es una herramienta moderna de reconocimiento de seguridad para WordPress, construida con Go, que ayuda a los ingenieros de seguridad a identificar vulnerabilidades, configuraciones incorrectas y problemas de divulgación de información en instalaciones de WordPress.

A diferencia de los escáneres de vulnerabilidades tradicionales con comprobaciones fijas en el código, WPRecon utiliza una arquitectura de plantillas basada en YAML, lo que permite:

  • ✅ Fácil extensibilidad sin necesidad de recompilación
  • ✅ Colaboración en equipo mediante plantillas compartidas
  • ✅ Despliegue rápido como un único binario
  • ✅ Escaneo paralelo de alto rendimiento
  • ✅ Capacidades flexibles de coincidencia y extracción

Estadísticas clave

  • Binario único - Sin dependencias en tiempo de ejecución
  • Más de 150 plantillas - Cobertura completa de WordPress
  • Escaneo paralelo - Grupos de trabajadores configurables
  • Código mínimo - ~1.200 líneas de código de producción
  • Listo para producción - Arquitectura probada en combate

⚡ Características

Capacidades principales

Operaciones HTTP

  • Todos los métodos HTTP estándar (GET, POST, PUT, DELETE)
  • Cabeceras y cookies personalizadas
  • Parámetros del cuerpo de la solicitud
  • Soporte SSL/TLS
  • Tiempos de espera configurables

Comparadores (5 tipos)

Identifica aciertos positivos en las respuestas:

  1. Estado - Coincidencia de código de estado HTTP (200, 404, 500, etc.)
  2. Palabra - Presencia de subcadena en el cuerpo de la respuesta
  3. Regex - Coincidencia de patrones con grupos de captura
  4. Cabecera - Validación de cabeceras de respuesta
  5. Tamaño - Verificación del tamaño del cuerpo de la respuesta

Extractores (2 tipos)

Extrae datos procesables de respuestas coincidentes:

  1. Regex - Extrae grupos de captura usando expresiones regulares
  2. JSON - Extracción simple de rutas JSON

Biblioteca de plantillas

Más de 150 plantillas listas para producción que cubren:

  • Detección de WordPress - Detección del núcleo y huella digital de la versión
  • Detección de plugins - Descubrimiento de plugins populares y detección de versiones
  • Enumeración de usuarios - Descubrimiento de usuarios de WordPress
  • Comprobaciones CVE - Detección de vulnerabilidades conocidas
  • Exposiciones - Divulgación de información (backups, .git, .env, etc.)
  • Detección de WAF - Cloudflare, AWS WAF, ModSecurity, Sucuri, Wordfence
  • Análisis de seguridad - Detección de configuraciones incorrectas y cabeceras de seguridad
  • Base de datos - Detección de exposición y reparación de bases de datos

📦 Instalación

Requisitos

  • Go 1.17 o superior
  • Linux, macOS o Windows

Desde el código fuente

root@kitploit:~
# Clonar el repositorio
git clone https://github.com/ffx64/wprecon.git
cd wprecon

# Compilar el binario
go build -o wprecon ./cmd/wprecon/main.go

# Mover al PATH (opcional)
sudo mv wprecon /usr/local/bin/

Instalar mediante Go

root@kitploit:~
go install github.com/ffx64/wprecon/cmd/wprecon@latest

Docker (Opcional)

root@kitploit:~
docker build -t wprecon .
docker run wprecon scan https://example.com

🚀 Uso

Interfaz de línea de comandos

Escaneo básico

Escanea un sitio web WordPress con todas las plantillas disponibles:

root@kitploit:~
wprecon scan https://example.com

Escaneo con plantillas específicas

Ejecuta solo las plantillas seleccionadas:

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

Formato de salida personalizado

root@kitploit:~
# Salida JSON para automatización
wprecon scan https://example.com --output json

# Tabla con formato bonito (por defecto)
wprecon scan https://example.com --output table

Control de paralelización y límite de velocidad

root@kitploit:~
# Usar 20 trabajadores concurrentes y 100 solicitudes/segundo
wprecon scan https://example.com --workers 20 --rate-limit 100

Listar plantillas disponibles

root@kitploit:~
wprecon list-templates

Mostrar ayuda

root@kitploit:~
wprecon --help

📋 Ejemplo de salida

Al ejecutar un escaneo, WPRecon produce hallazgos detallados:

Formato tabla:

root@kitploit:~
ID                    | Plantilla              | Nombre                     | Gravedad | Objetivo           | Evidencia
---------------------|------------------------|----------------------------|----------|--------------------|----------
finding_001           | wordpress-version      | Versión de WordPress encontrada | info     | example.com         | 6.2.1
finding_002           | plugin-detection       | Plugin detectado           | bajo     | example.com         | Yoast SEO 16.0
finding_003           | security-headers       | Cabeceras de seguridad faltantes | medio   | example.com         | X-Frame-Options

Formato JSON:

root@kitploit:~
{
  "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": "Instalación de WordPress detectada",
      "description": "Instalación de CMS WordPress identificada en el objetivo",
      "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": "Mantener WordPress actualizado a la última versión"
    }
  ]
}

🏗️ Arquitectura

Estructura del proyecto

root@kitploit:~
wprecon/
├── cmd/wprecon/
│   └── main.go                    # Punto de entrada CLI
├── internal/
│   ├── app/
│   │   ├── cli.go                 # Manejadores de comandos CLI
│   │   └── api.go                 # Manejadores de API REST
│   ├── engine/
│   │   ├── scanner.go             # Orquestación de escaneo
│   │   ├── worker_pool.go         # Motor de paralelización
│   │   ├── context.go             # Gestión del contexto de escaneo
│   │   ├── logger.go              # Utilidades de registro
│   │   └── rate_limit.go          # Límite de velocidad
│   ├── executor/
│   │   ├── http_executor.go       # Cliente HTTP
│   │   ├── request_builder.go     # Construcción de solicitudes
│   │   └── variables.go           # Resolución de variables
│   ├── matchers/
│   │   └── matchers.go            # Lógica de coincidencia de respuestas
│   ├── extractors/
│   │   └── extractors.go          # Extracción de datos
│   ├── templates/
│   │   ├── loader.go              # Descubrimiento de plantillas
│   │   └── parser.go              # Análisis YAML
│   ├── pipeline/
│   │   └── pipeline.go            # Flujo de trabajo de escaneo
│   └── domain/
│       ├── template.go            # Modelos de datos
│       ├── finding.go
│       ├── http.go
│       ├── matcher.go
│       └── extractor.go
├── templates/                      # Biblioteca de plantillas YAML
│   ├── wordpress/                  # Específico de WordPress
│   ├── cves/                       # Detección de CVE
│   ├── exposures/                  # Divulgación de información
│   ├── common/                     # Comprobaciones genéricas
│   └── waf/                        # Detección de WAF
└── go.mod                          # Dependencias

Diagrama de arquitectura

root@kitploit:~
┌─────────────────────────────────────────────────┐
│          Interfaz de usuario (CLI/API)           │
└─────────────────────────────────────────────────┘
          │
          ├─→ Cargador de plantillas
          ├─→ Limitador de velocidad
          └─→ Gestor de grupos de trabajadores
          │
          ▼
┌─────────────────────────────────────────────────┐
│              Motor de tubería de escaneo         │
│  ┌────────→ Constructor de solicitudes           │
│  │ ┌────────→ Ejecutor HTTP                     │
│  │ │ ┌────────→ Comparador (5 tipos)             │
│  │ │ │ ┌────────→ Extractor (2 tipos)           │
│  │ │ │ │ ┌────────→ Informe de hallazgo         │
│  │ │ │ │ │                                     │
│  ▼ ▼ ▼ ▼ ▼                                     │
│ Plantilla → Solicitud → Respuesta → Hallazgo    │
└─────────────────────────────────────────────────┘
          │
          ▼
┌─────────────────────────────────────────────────┐
│            Formateadores de salida y almacenamiento│
│         (JSON, Tabla, Generación de informes)     │
└─────────────────────────────────────────────────┘

Principios de diseño

  1. Responsabilidad única - Cada módulo tiene un propósito claro y enfocado
  2. Basado en plantillas - Toda la lógica de escaneo vive en YAML, no en código
  3. Escalabilidad horizontal - Diseño modular que permite fácil extensión
  4. Patrón de fábrica - Adición simple de nuevos comparadores y extractores
  5. Sin dependencias externas - Solo bibliotecas para UUID y análisis YAML
  6. Seguro para subprocesos - Escaneo concurrente seguro con grupos de trabajadores

📚 Plantillas

Las plantillas son archivos YAML que definen cómo WPRecon debe escanear vulnerabilidades o información específica.

Estructura de la plantilla

root@kitploit:~
id: wordpress-version-detection
name: Detección de versión de WordPress
description: Detecta y extrae la versión de WordPress desde readme.html
severity: info
author: Equipo 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+)'

Categorías de plantillas

Núcleo de WordPress

Vulnerabilidades

  • Detección de CVE para plugins de WordPress
  • Comprobaciones de vulnerabilidades conocidas
  • Detección de configuraciones de seguridad incorrectas

Divulgación de información

  • Exposición de archivos de backup (wp-config.php.bak, .sql)
  • Exposición de repositorio Git (.git/)
  • Exposición de archivos de entorno (.env)
  • Configuración incorrecta de bucket S3

Detección de WAF

  • Cloudflare
  • AWS WAF
  • ModSecurity
  • Sucuri
  • Wordfence
  • Detección genérica de WAF

Análisis de seguridad

  • Cabeceras de seguridad faltantes
  • Autenticación débil
  • Configuración incorrecta de CORS
  • Detección de modo depuración

Agregar plantillas personalizadas

  1. Crea un nuevo archivo YAML en templates/custom/
  2. Sigue la estructura de la plantilla (ver ejemplo arriba)
  3. Ejecuta WPRecon - las plantillas se descubren automáticamente

Ejemplo:

root@kitploit:~
# Crear plantilla personalizada
cat > templates/custom/my-check.yaml << 'EOF'
id: my-custom-check
name: Mi comprobación personalizada
description: Detecta vulnerabilidad personalizada
severity: medium
author: Tu Nombre

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

# Escanear con plantilla personalizada
wprecon scan https://example.com -t my-custom-check

🔧 Configuración

Variables de entorno

root@kitploit:~
# Tiempo de espera HTTP (por defecto: 10s)
export WPRECON_TIMEOUT=15

# Número de trabajadores (por defecto: 10)
export WPRECON_WORKERS=20

# Solicitudes por segundo (por defecto: 50)
export WPRECON_RATE_LIMIT=100

# Nivel de registro (por defecto: info)
export WPRECON_LOG_LEVEL=debug

# Directorios de plantillas (por defecto: ./templates)
export WPRECON_TEMPLATE_DIRS=/ruta/a/plantillas:/ruta/a/mas/plantillas

Banderas CLI

root@kitploit:~
wprecon scan <objetivo> \
  --templates-dir ./plantillas-personalizadas \
  --workers 20 \
  --rate-limit 100 \
  --timeout 15 \
  --output json \
  --log-level debug

💼 Casos de uso

Evaluaciones de seguridad

Evaluación integral de seguridad de instalaciones de WordPress:

root@kitploit:~
wprecon scan https://example.com --output json > informe_evaluacion.json

Integración CI/CD

Escaneo automatizado de vulnerabilidades en tuberías de despliegue:

root@kitploit:~
# Ejemplo de GitHub Actions
- name: Escaneo de seguridad WordPress
  run: |
    wprecon scan ${{ secrets.STAGING_URL }} \
      --output json \
      --templates wordpress-detection,plugin-detection,cve-checks

Reconocimiento masivo

Escanea múltiples objetivos de manera eficiente:

root@kitploit:~
cat objetivos.txt | while read objetivo; do
  wprecon scan "$objetivo" --output json >> resultados.json
done

🛠️ Desarrollo

Requisitos previos

  • Go 1.17+

Compilación

root@kitploit:~
# Compilar binario
go build -o wprecon ./cmd/wprecon/main.go

# Compilar para múltiples plataformas
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

Dependencias del proyecto

root@kitploit:~
google/uuid v1.6.0   - Generación de UUID para hallazgos
gopkg.in/yaml.v3     - Análisis de plantillas YAML

Estructura del código

  • Dependencias mínimas - Solo bibliotecas esenciales
  • Arquitectura limpia - Diseño en capas para mantenibilidad
  • Extensible - Fácil de agregar comparadores, extractores y plantillas
  • Bien documentado - Comentarios de código claros y documentación

🤝 Contribuir con plantillas

  1. Haz un fork del repositorio
  2. Crea una rama de funcionalidad (git checkout -b feature/mi-plantilla)
  3. Agrega tu plantilla a templates/
  4. Prueba a fondo: wprecon scan https://test.site -t tu-plantilla
  5. Envía una solicitud de extracción

📄 Licencia

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


Hecho con ❤️ para Matheus (ffx64)

⬆ volver al inicio

Descargar herramienta
CaracterísticaDescripción
Escaneo paraleloGrupo de trabajadores configurable (por defecto: 10 trabajadores) para solicitudes concurrentes
Límite de velocidadRegulación de solicitudes incorporada (por defecto: 50 req/s) para ser amigable con la red
Reintento automáticoLógica de reintento automático para solicitudes HTTP fallidas
Plantillas de recarga en calienteSin necesidad de recompilación: agrega plantillas y escanea
Resolución de variablesVariables dinámicas: {{BaseURL}}, {{Timestamp}}, {{RandomInt}}
Salida en múltiples formatosTablas legibles y JSON estructurado
Modos CLI y APIInterfaces tanto de línea de comandos como API REST
Niveles de gravedadHallazgos clasificados como info, bajo, medio, alto, crítico
PlantillaPropósito
wordpress-detectionDetecta instalación de WordPress
wordpress-versionHuella digital de la versión de WordPress
plugins.yamlDetecta plugins instalados
themes.yamlDetecta temas instalados
users.yamlEnumera usuarios de WordPress