WpfWordPressTool

⚠️ LEGAL DISCLAIMER / AVISO LEGAL

This tool is intended exclusively for authorized penetration testing, security audits on systems you own or have explicit written permission to test, and educational/research purposes in CTF environments. Unauthorized use against systems you do not own is illegal and may result in criminal prosecution under the Computer Fraud and Abuse Act (CFAA), the Computer Misuse Act, or equivalent laws in your jurisdiction. The author assumes no liability for misuse.

English

Overview

WpfWordPressTool is a high-performance Windows desktop application built with WPF and C# (.NET 6) for WordPress security assessment. It automates the full discovery pipeline: detecting whether a domain runs WordPress, enumerating valid usernames through 10 different strategies, and batch-testing credentials via the XML-RPC protocol — all with a custom work-stealing thread pool for maximum throughput.

No prior credentials are needed — only a list of domains and a password dictionary.

Use Cases

Authorized penetration testing engagements (with written scope authorization)
Security audits of WordPress installations you manage
Red team assessments
CTF (Capture The Flag) competitions
Security research and education

Key Features

Feature	Details
WordPress Auto-Detection	Confirms WordPress presence before testing (no wasted effort)
10 User Enumeration Methods	REST API, Author IDs, RSS, Sitemap, oEmbed, XML-RPC, and more
XML-RPC Credential Testing	Uses `wp.getUsersBlogs` for reliable validation
Custom Work-Stealing Thread Pool	Up to 5,000 concurrent threads with adaptive scaling
Auto Thread Detection	Reads CPU cores, RAM, and live CPU load to pick optimal thread count
Smart Password Placeholders	`%domain%`, `%user%`, `%USER%`, `%resu%` substitutions
Real-Time Dashboard	Live stats: progress, valid count, active threads, elapsed time
Multi-Format Export	Save results as TXT or CSV
Auto-Save	Continuously saves valid credentials to `Results/` during execution
Dark Theme UI	Clean, modern WPF dark theme
Graceful Cancellation	Stop mid-scan without losing already-found results

System Requirements

Component	Requirement
OS	Windows 10 or Windows 11 (64-bit)
Runtime	.NET 6 Desktop Runtime
RAM	Minimum 2 GB (4 GB+ recommended for large scans)
CPU	Any modern multi-core processor
Network	Active internet connection
Disk	~50 MB free space

Important: The application requires the .NET 6 Desktop Runtime. If you run the .exe and nothing happens or you get an error, download and install the runtime first.

Installation

Option A — Pre-built Release (Recommended)

Go to the Releases page
Download the latest WpfWordPressTool-vX.X.X-windows-x64.zip
Extract the ZIP to any folder (e.g., C:\Tools\WpfWordPressTool\)
Ensure .NET 6 Desktop Runtime is installed
Double-click WpfWordPressTool.exe to launch

Folder structure after extraction:

WpfWordPressTool/
├── WpfWordPressTool.exe          ← Main executable
├── WpfWordPressTool.dll
├── WpfWordPressTool.deps.json
├── WpfWordPressTool.runtimeconfig.json
├── System.Management.dll
├── System.CodeDom.dll
├── runtimes/
│   └── win/lib/net6.0/
│       └── System.Management.dll
└── dic/
    ├── user.txt                  ← Default username dictionary
    ├── pass.txt                  ← Default password dictionary
    └── pass_max.txt              ← Extended password dictionary

Option B — Build from Source

git clone https://github.com/ByteCodeSecure/WpfWordPressTool.git
cd WpfWordPressTool
dotnet build -c Release

The built output will be in bin/Release/net6.0-windows/.

Interface Overview

┌─────────────────────────────────────────────────────────────────┐
│  WpfWordPressTool                                               │
├──────────────┬──────────────────────────────────────────────────┤
│  [Load       │  Domains: 0      Passwords: 0                    │
│   Domains]   │  Tasks: 0/0      Success: 0     Threads: 0       │
│  [Load       │  Progress: 0%    Elapsed: 00:00:00               │
│   Passwords] │  Status: Ready                                   │
├──────────────┼──────────────────────────────────────────────────┤
│  Threads:    │                                                  │
│  [1000    ]  │   ┌─ Activity Log ──────────────────────────┐   │
│  Timeout(s): │   │ [timestamp] Loaded 500 domains           │   │
│  [20      ]  │   │ [timestamp] Starting scan...             │   │
│              │   │ [timestamp] ✓ VALID → site.com:admin:pw  │   │
│  [✓] Use     │   └──────────────────────────────────────────┘   │
│  Default     │                                                  │
│  Dicts       │   ┌─ Results ───────────────────────────────┐   │
│              │   │  site.com | admin | password123          │   │
│  [START]     │   │  blog.net | editor | mypassword          │   │
│  [STOP]      │   └──────────────────────────────────────────┘   │
│  [Export]    │                                                  │
│  [Clear]     │  [Open wp-admin] [Copy] [Clear Log]              │
└──────────────┴──────────────────────────────────────────────────┘

Input File Formats

Domains File

A plain text file with one domain per line. The tool normalizes URLs automatically (adds https://, removes trailing slashes):

example.com
https://myblog.org
http://wordpress-site.net
subdomain.domain.com
192.168.1.100

Both http:// and https:// are accepted (auto-upgraded to HTTPS)
IP addresses are supported
Subdomains are supported
Blank lines are ignored

Password Dictionary

A plain text file with one password per line:

password123
admin
letmein
%domain%2024
%user%123
P@ssw0rd
wordpress

See Password Placeholder System for dynamic password generation.

Username Dictionary (optional)

A plain text file with one username per line. If not loaded, the tool enumerates usernames from each target and falls back to built-in defaults:

admin
administrator
webmaster
editor
user

The built-in dic/user.txt and dic/pass.txt are used automatically when "Use Default Dicts" is checked.

Step-by-Step Usage

Step 1 — Load Domains

Click "Load Domains"
Select your .txt file containing one domain per line
The domains counter updates: Domains: 500

Alternatively, check "Use Default Dicts" to use the built-in dictionaries.

Step 2 — Load Passwords

Click "Load Passwords"
Select your password dictionary (.txt)
The passwords counter updates: Passwords: 1000

Step 3 — Configure Settings

Setting	Range	Default	Notes
Threads	50–5,000	1,000	Higher = faster, but more resource intensive
Timeout (seconds)	3–60	20	Per-domain timeout multiplied by 3 internally

Click the auto-detect button (if available) to let the tool choose threads based on your hardware.

Step 4 — Start Scanning

Click "START"
Watch the real-time dashboard:
- Progress bar fills as domains are processed
- Success counter increments on each valid credential found
- Activity Log shows real-time events
- Results panel lists found credentials
Valid credentials are automatically saved to Results/<timestamp>/success.txt

Step 5 — Export Results

Click "Export" → choose TXT or CSV format
Select a save location
Results are written immediately

Step 6 — Interact with Results

Select a result row → click "Open wp-admin" to open the WordPress admin panel in your browser
Select a result row → click "Copy" to copy credentials to clipboard (url#user@password format)

Step 7 — Stop Scanning

Click "STOP" at any time for a graceful shutdown
All results found so far are preserved and saved

Password Placeholder System

The tool supports dynamic password generation using placeholders that are substituted per-domain and per-username:

Placeholder	Replacement	Example (domain: `www.example.com`, user: `Admin`)
`%domain%`	Full domain without protocol	`www.example.com`
`%domain_center%`	Middle part of domain	`example`
`%user%`	Username (lowercase)	`admin`
`%User%`	Username (capitalized)	`Admin`
`%USER%`	Username (UPPERCASE)	`ADMIN`
`%resu%`	Username (reversed)	`nimdA`

Example password list using placeholders:

%domain%2024
%domain_center%123
%user%@2024
%User%!
%USER%_secure
admin_%domain_center%

For www.example.com with user admin, this generates:

www.example.com2024
example123
admin@2024
Admin!
ADMIN_secure
admin_example

Output & Results

Auto-Save (During Execution)

Valid credentials are continuously saved to:

Results/
└── <YYYY-MM-DD_HH-MM-SS>/
    └── success.txt

Format:

https://example.com/wp-login.php#admin@password123

Manual Export

TXT Format

https://example.com/wp-login.php#admin@password123
https://blog.net/wp-login.php#editor@mypassword

CSV Format

URL,Username,Password,Role,BlogName
https://example.com/wp-login.php,admin,password123,administrator,My Blog
https://blog.net/wp-login.php,editor,mypassword,editor,Tech Blog

Configuration Reference

All defaults are defined in Core/Constants/AppConstants.cs:

Constant	Value	Description
`DefaultThreadCount`	1,000	Initial thread count
`MinThreadCount`	50	Minimum allowed threads
`MaxThreadCount`	5,000	Maximum allowed threads
`DefaultTimeout`	20s	Per-request timeout
`MinTimeout`	3s	Minimum timeout
`MaxTimeout`	60s	Maximum timeout
`CredentialParallelism`	5	Passwords tested in parallel per username
`DomainPartitionSize`	50	Domains per processing batch
`BackpressureHighWatermark`	10,000	Queue size at which backpressure kicks in
`DefaultPasswordDictPath`	`dic/pass.txt`	Built-in password dictionary
`DefaultUserDictPath`	`dic/user.txt`	Built-in username dictionary

How It Works — Technical Deep Dive

Processing Pipeline (Per Domain)

Domain Input
     │
     ▼
┌─────────────────────────┐
│  WordPress Detection    │  HEAD request → check wp-login.php, xmlrpc.php,
│  (CachedWordPressDetector)│  /wp-includes/, /wp-content/
└──────────┬──────────────┘
           │ Not WordPress → Skip
           │ Is WordPress  ↓
┌─────────────────────────┐
│  User Enumeration       │  10 parallel strategies:
│  (UserEnumerationService)│  REST API, Author IDs, RSS, oEmbed,
│                         │  WP-JSON, Sitemap, Homepage, XML-RPC,
└──────────┬──────────────┘  Login Errors, oEmbed
           │ No users found → use defaults (admin, administrator, etc.)
           │ Users found    ↓
┌─────────────────────────┐
│  Credential Testing     │  XML-RPC wp.getUsersBlogs
│  (BatchCredentialTester)│  5 passwords tested in parallel per user
│                         │  Early-exit on first valid credential
└──────────┬──────────────┘
           │ Valid found → auto-save + update UI
           ▼
     Next Domain

Thread Pool Architecture

The custom PriorityThreadPoolService implements work-stealing:

Worker 0 ──┐
Worker 1 ──┤──▶  WorkStealingQueue (per worker)
Worker 2 ──┤         │
Worker 3 ──┘         └── Idle workers steal from busy workers
                          Lock-free ConcurrentDeque operations
                          Priority: High > Normal > Low

User Enumeration Methods

#	Method	Endpoint
1	REST API v1	`GET /wp-json/wp/v2/users`
2	REST API v2	`GET /wp-json/wp/v2/users?per_page=100`
3	Author Enumeration	`GET /?author=1` through `/?author=20`
4	RSS Feed	`GET /feed/` — parses `<dc:creator>`
5	oEmbed	`GET /wp-json/oembed/1.0/embed`
6	WP-JSON Root	`GET /wp-json/` — analyzes available routes
7	User Sitemap	`GET /wp-sitemap-users-1.xml`
8	Homepage	Scrapes `author` meta tags from main page
9	XML-RPC	`POST /xmlrpc.php` — lists system methods
10	Login Error	`POST /wp-login.php` — error message analysis

HTTP Optimization

SocketsHttpHandler with configurable connection pooling (up to 4,000 connections)
Per-host SemaphoreSlim for rate limiting
Adaptive timeouts based on observed host latency
DNS result caching
Automatic gzip/deflate decompression
HTTP/2 support
SSL certificate validation disabled (accepts self-signed certs)

Architecture

WpfWordPressTool/
├── App.xaml / App.xaml.cs          # Application entry point
├── Core/
│   ├── Commands/
│   │   └── RelayCommand.cs         # ICommand implementation for MVVM
│   ├── Constants/
│   │   └── AppConstants.cs         # All configuration constants
│   ├── Converters/                  # XAML value converters
│   └── Interfaces/                  # 9 service interfaces (DI contracts)
├── Models/
│   ├── CredentialResult.cs          # Found valid credential
│   ├── DetectionResult.cs           # WordPress detection cache entry
│   ├── HttpResult.cs                # HTTP response wrapper
│   ├── ResponseMetrics.cs           # Per-host performance metrics
│   └── WorkItem.cs                  # Thread pool task unit
├── ViewModels/
│   └── MainViewModel.cs             # Main UI logic (MVVM)
├── Views/
│   └── MainWindow.xaml              # UI layout
├── Services/
│   ├── AutoThreadDetector.cs        # Hardware-based thread count selection
│   ├── BatchCredentialTester.cs     # XML-RPC credential testing
│   ├── CachedWordPressDetector.cs   # WordPress detection with caching
│   ├── DomainNormalizer.cs          # URL normalization
│   ├── ExportService.cs             # TXT/CSV export
│   ├── OptimizedHttpService.cs      # High-perf HTTP client
│   ├── PasswordProcessor.cs         # Placeholder substitution
│   ├── PriorityThreadPoolService.cs # Work-stealing thread pool
│   ├── UserEnumerationService.cs    # 10-method user enumeration
│   └── ...                          # Additional support services
├── Themes/
│   └── DarkTheme.xaml               # Application dark theme
└── dic/
    ├── user.txt                      # Default username list
    ├── pass.txt                      # Default password list
    └── pass_max.txt                  # Extended password list

Troubleshooting

Problem	Cause	Solution
Application doesn't launch	.NET 6 Runtime missing	Install .NET 6 Desktop Runtime
Application crashes on start	Missing DLL files	Ensure all files from the ZIP are in the same folder
All results show as errors	Network/firewall issue	Check internet connection; try reducing threads
Scan is very slow	Too few threads or high timeout	Increase threads; reduce timeout to 10s
No usernames found	Target hardened REST API	Normal — tool falls back to default usernames
Results folder not created	Permissions issue	Run as Administrator or move to a writable folder
XML-RPC not found	Target disabled XML-RPC	Cannot test; tool will skip that domain
High RAM usage	Many threads + large dictionaries	Reduce thread count; split domain list

Español

Tabla de Contenidos

Descripción General
Características Principales
Requisitos del Sistema
Instalación
Vista General de la Interfaz
Formatos de Archivos de Entrada
Uso Paso a Paso
Sistema de Placeholders de Contraseñas
Salida y Resultados
Referencia de Configuración
Cómo Funciona — Análisis Técnico Detallado
Arquitectura
Solución de Problemas

Descripción General

WpfWordPressTool es una aplicación de escritorio Windows de alto rendimiento construida con WPF y C# (.NET 6) para la evaluación de seguridad de WordPress. Automatiza el pipeline completo de descubrimiento: detectar si un dominio ejecuta WordPress, enumerar nombres de usuario válidos mediante 10 estrategias diferentes, y probar credenciales en lote a través del protocolo XML-RPC — todo con un thread pool personalizado de work-stealing para máximo rendimiento.

No se necesitan credenciales previas — solo una lista de dominios y un diccionario de contraseñas.

Casos de Uso

Pruebas de penetración autorizadas (con autorización escrita de alcance)
Auditorías de seguridad de instalaciones WordPress que administras
Evaluaciones de red team
Competencias CTF (Capture The Flag)
Investigación y educación en seguridad

Características Principales

Característica	Detalles
Auto-detección WordPress	Confirma presencia de WordPress antes de probar (sin esfuerzo desperdiciado)
10 Métodos de Enumeración de Usuarios	REST API, IDs de Autor, RSS, Sitemap, oEmbed, XML-RPC, y más
Prueba de Credenciales XML-RPC	Usa `wp.getUsersBlogs` para validación confiable
Thread Pool Work-Stealing Personalizado	Hasta 5,000 hilos concurrentes con escalado adaptativo
Auto-detección de Hilos	Lee cores de CPU, RAM y carga de CPU en vivo para elegir la cantidad óptima
Placeholders Inteligentes de Contraseñas	Sustituciones `%domain%`, `%user%`, `%USER%`, `%resu%`
Panel en Tiempo Real	Estadísticas en vivo: progreso, conteo válidos, hilos activos, tiempo transcurrido
Exportación Multi-formato	Guardar resultados como TXT o CSV
Auto-guardado	Guarda continuamente credenciales válidas en `Results/` durante la ejecución
Tema Oscuro UI	Tema oscuro WPF limpio y moderno
Cancelación Graciosa	Detener a mitad del escaneo sin perder resultados ya encontrados

Requisitos del Sistema

Componente	Requisito
SO	Windows 10 o Windows 11 (64-bit)
Runtime	.NET 6 Desktop Runtime
RAM	Mínimo 2 GB (4 GB+ recomendado para escaneos grandes)
CPU	Cualquier procesador multi-core moderno
Red	Conexión a internet activa
Disco	~50 MB de espacio libre

Importante: La aplicación requiere el .NET 6 Desktop Runtime. Si ejecutas el .exe y no sucede nada o aparece un error, descarga e instala el runtime primero.

Instalación

Opción A — Release Precompilado (Recomendado)

Ve a la página de Releases
Descarga el último WpfWordPressTool-vX.X.X-windows-x64.zip
Extrae el ZIP a cualquier carpeta (ej., C:\Tools\WpfWordPressTool\)
Asegúrate de tener instalado .NET 6 Desktop Runtime
Haz doble clic en WpfWordPressTool.exe para iniciar

Estructura de carpeta después de extraer:

WpfWordPressTool/
├── WpfWordPressTool.exe          ← Ejecutable principal
├── WpfWordPressTool.dll
├── WpfWordPressTool.deps.json
├── WpfWordPressTool.runtimeconfig.json
├── System.Management.dll
├── System.CodeDom.dll
├── runtimes/
│   └── win/lib/net6.0/
│       └── System.Management.dll
└── dic/
    ├── user.txt                  ← Diccionario de usuarios por defecto
    ├── pass.txt                  ← Diccionario de contraseñas por defecto
    └── pass_max.txt              ← Diccionario extendido de contraseñas

Opción B — Compilar desde el Código Fuente

git clone https://github.com/ByteCodeSecure/WpfWordPressTool.git
cd WpfWordPressTool
dotnet build -c Release

La salida compilada estará en bin/Release/net6.0-windows/.

Vista General de la Interfaz

┌─────────────────────────────────────────────────────────────────┐
│  WpfWordPressTool                                               │
├──────────────┬──────────────────────────────────────────────────┤
│  [Cargar     │  Dominios: 0     Contraseñas: 0                  │
│   Dominios]  │  Tareas: 0/0     Éxitos: 0     Hilos: 0         │
│  [Cargar     │  Progreso: 0%    Transcurrido: 00:00:00          │
│  Contraseñas]│  Estado: Listo                                   │
├──────────────┼──────────────────────────────────────────────────┤
│  Hilos:      │                                                  │
│  [1000    ]  │   ┌─ Log de Actividad ──────────────────────┐   │
│  Timeout(s): │   │ [timestamp] Cargados 500 dominios        │   │
│  [20      ]  │   │ [timestamp] Iniciando escaneo...         │   │
│              │   │ [timestamp] ✓ VÁLIDO → sitio.com:admin   │   │
│  [✓] Usar    │   └──────────────────────────────────────────┘   │
│  Dicts por   │                                                  │
│  Defecto     │   ┌─ Resultados ────────────────────────────┐   │
│              │   │  sitio.com | admin | contraseña123       │   │
│  [INICIAR]   │   │  blog.net | editor | micontraseña        │   │
│  [DETENER]   │   └──────────────────────────────────────────┘   │
│  [Exportar]  │                                                  │
│  [Limpiar]   │  [Abrir wp-admin] [Copiar] [Limpiar Log]         │
└──────────────┴──────────────────────────────────────────────────┘

Formatos de Archivos de Entrada

Archivo de Dominios

Archivo de texto plano con un dominio por línea. La herramienta normaliza las URLs automáticamente (agrega https://, elimina barras finales):

ejemplo.com
https://miblog.org
http://sitio-wordpress.net
subdominio.dominio.com
192.168.1.100

Se aceptan tanto http:// como https:// (se actualizan automáticamente a HTTPS)
Las direcciones IP son compatibles
Los subdominios son compatibles
Las líneas en blanco se ignoran

Diccionario de Contraseñas

Archivo de texto plano con una contraseña por línea:

contraseña123
admin
letmein
%domain%2024
%user%123
P@ssw0rd
wordpress

Ver Sistema de Placeholders de Contraseñas para generación dinámica.

Diccionario de Usuarios (opcional)

Archivo de texto plano con un nombre de usuario por línea. Si no se carga, la herramienta enumera usuarios de cada objetivo y recurre a los predeterminados integrados:

admin
administrator
webmaster
editor
usuario

Los archivos dic/user.txt y dic/pass.txt integrados se usan automáticamente cuando "Usar Dicts por Defecto" está marcado.

Uso Paso a Paso

Paso 1 — Cargar Dominios

Clic en "Cargar Dominios"
Selecciona tu archivo .txt con un dominio por línea
El contador de dominios se actualiza: Dominios: 500

Alternativamente, marca "Usar Dicts por Defecto" para usar los diccionarios integrados.

Paso 2 — Cargar Contraseñas

Clic en "Cargar Contraseñas"
Selecciona tu diccionario de contraseñas (.txt)
El contador de contraseñas se actualiza: Contraseñas: 1000

Paso 3 — Configurar Ajustes

Ajuste	Rango	Por Defecto	Notas
Hilos	50–5,000	1,000	Mayor = más rápido, pero más intensivo en recursos
Timeout (segundos)	3–60	20	Timeout por dominio multiplicado por 3 internamente

Paso 4 — Iniciar Escaneo

Clic en "INICIAR"
Observa el panel en tiempo real:
- La barra de Progreso se llena a medida que se procesan dominios
- El contador de Éxitos se incrementa con cada credencial válida encontrada
- El Log de Actividad muestra eventos en tiempo real
- El panel de Resultados lista las credenciales encontradas
Las credenciales válidas se guardan automáticamente en Results/<timestamp>/success.txt

Paso 5 — Exportar Resultados

Clic en "Exportar" → elige formato TXT o CSV
Selecciona ubicación de guardado
Los resultados se escriben inmediatamente

Paso 6 — Interactuar con Resultados

Selecciona una fila de resultado → clic en "Abrir wp-admin" para abrir el panel de administración de WordPress en tu navegador
Selecciona una fila de resultado → clic en "Copiar" para copiar credenciales al portapapeles (formato url#usuario@contraseña)

Paso 7 — Detener Escaneo

Clic en "DETENER" en cualquier momento para un cierre gracioso
Todos los resultados encontrados hasta ese momento se preservan y guardan

Sistema de Placeholders de Contraseñas

La herramienta soporta generación dinámica de contraseñas usando placeholders que se sustituyen por dominio y por usuario:

Placeholder	Reemplazo	Ejemplo (dominio: `www.ejemplo.com`, usuario: `Admin`)
`%domain%`	Dominio completo sin protocolo	`www.ejemplo.com`
`%domain_center%`	Parte central del dominio	`ejemplo`
`%user%`	Usuario (minúsculas)	`admin`
`%User%`	Usuario (capitalizado)	`Admin`
`%USER%`	Usuario (MAYÚSCULAS)	`ADMIN`
`%resu%`	Usuario (invertido)	`nimdA`

Lista de contraseñas de ejemplo con placeholders:

%domain%2024
%domain_center%123
%user%@2024
%User%!
%USER%_seguro
admin_%domain_center%

Para www.ejemplo.com con usuario admin, esto genera:

www.ejemplo.com2024
ejemplo123
admin@2024
Admin!
ADMIN_seguro
admin_ejemplo

Salida y Resultados

Auto-guardado (Durante Ejecución)

Las credenciales válidas se guardan continuamente en:

Results/
└── <YYYY-MM-DD_HH-MM-SS>/
    └── success.txt

Formato:

https://ejemplo.com/wp-login.php#admin@contraseña123

Exportación Manual

Formato TXT

https://ejemplo.com/wp-login.php#admin@contraseña123
https://blog.net/wp-login.php#editor@micontraseña

Formato CSV

URL,Username,Password,Role,BlogName
https://ejemplo.com/wp-login.php,admin,contraseña123,administrator,Mi Blog
https://blog.net/wp-login.php,editor,micontraseña,editor,Blog Tecnología

Referencia de Configuración

Todos los valores predeterminados están definidos en Core/Constants/AppConstants.cs:

Constante	Valor	Descripción
`DefaultThreadCount`	1,000	Cantidad de hilos inicial
`MinThreadCount`	50	Mínimo de hilos permitidos
`MaxThreadCount`	5,000	Máximo de hilos permitidos
`DefaultTimeout`	20s	Timeout por solicitud
`MinTimeout`	3s	Timeout mínimo
`MaxTimeout`	60s	Timeout máximo
`CredentialParallelism`	5	Contraseñas probadas en paralelo por usuario
`DomainPartitionSize`	50	Dominios por lote de procesamiento
`BackpressureHighWatermark`	10,000	Tamaño de cola en que actúa el backpressure
`DefaultPasswordDictPath`	`dic/pass.txt`	Diccionario de contraseñas integrado
`DefaultUserDictPath`	`dic/user.txt`	Diccionario de usuarios integrado

Cómo Funciona — Análisis Técnico Detallado

Pipeline de Procesamiento (Por Dominio)

Entrada de Dominio
       │
       ▼
┌─────────────────────────┐
│  Detección WordPress    │  Solicitud HEAD → verificar wp-login.php,
│  (CachedWordPressDetector)│ xmlrpc.php, /wp-includes/, /wp-content/
└──────────┬──────────────┘
           │ No es WordPress → Saltar
           │ Es WordPress   ↓
┌─────────────────────────┐
│  Enumeración de Usuarios│  10 estrategias paralelas:
│  (UserEnumerationService)│  REST API, IDs Autor, RSS, oEmbed,
│                         │  WP-JSON, Sitemap, Homepage, XML-RPC,
└──────────┬──────────────┘  Errores Login
           │ Sin usuarios → usar predeterminados (admin, administrator, etc.)
           │ Usuarios encontrados ↓
┌─────────────────────────┐
│  Prueba de Credenciales │  XML-RPC wp.getUsersBlogs
│  (BatchCredentialTester)│  5 contraseñas en paralelo por usuario
│                         │  Early-exit en primera credencial válida
└──────────┬──────────────┘
           │ Válido encontrado → auto-guardar + actualizar UI
           ▼
     Siguiente Dominio

Arquitectura del Thread Pool

El PriorityThreadPoolService personalizado implementa work-stealing:

Worker 0 ──┐
Worker 1 ──┤──▶  WorkStealingQueue (por worker)
Worker 2 ──┤         │
Worker 3 ──┘         └── Workers ociosos roban de workers ocupados
                          Operaciones ConcurrentDeque sin bloqueo
                          Prioridad: Alta > Normal > Baja

Métodos de Enumeración de Usuarios

#	Método	Endpoint
1	REST API v1	`GET /wp-json/wp/v2/users`
2	REST API v2	`GET /wp-json/wp/v2/users?per_page=100`
3	Enumeración de Autores	`GET /?author=1` hasta `/?author=20`
4	Feed RSS	`GET /feed/` — parsea `<dc:creator>`
5	oEmbed	`GET /wp-json/oembed/1.0/embed`
6	Raíz WP-JSON	`GET /wp-json/` — analiza rutas disponibles
7	Mapa de Usuarios	`GET /wp-sitemap-users-1.xml`
8	Página de Inicio	Extrae meta tags `author` de página principal
9	XML-RPC	`POST /xmlrpc.php` — lista métodos del sistema
10	Error de Login	`POST /wp-login.php` — análisis de mensajes de error

Arquitectura

WpfWordPressTool/
├── App.xaml / App.xaml.cs          # Punto de entrada de la aplicación
├── Core/
│   ├── Commands/
│   │   └── RelayCommand.cs         # Implementación ICommand para MVVM
│   ├── Constants/
│   │   └── AppConstants.cs         # Todas las constantes de configuración
│   ├── Converters/                  # Conversores de valores XAML
│   └── Interfaces/                  # 9 interfaces de servicios (contratos DI)
├── Models/
│   ├── CredentialResult.cs          # Credencial válida encontrada
│   ├── DetectionResult.cs           # Entrada de caché de detección WordPress
│   ├── HttpResult.cs                # Wrapper de respuesta HTTP
│   ├── ResponseMetrics.cs           # Métricas de rendimiento por host
│   └── WorkItem.cs                  # Unidad de tarea del thread pool
├── ViewModels/
│   └── MainViewModel.cs             # Lógica principal de UI (MVVM)
├── Views/
│   └── MainWindow.xaml              # Layout de la interfaz
├── Services/
│   ├── AutoThreadDetector.cs        # Selección de hilos basada en hardware
│   ├── BatchCredentialTester.cs     # Prueba de credenciales XML-RPC
│   ├── CachedWordPressDetector.cs   # Detección WordPress con caché
│   ├── DomainNormalizer.cs          # Normalización de URLs
│   ├── ExportService.cs             # Exportación TXT/CSV
│   ├── OptimizedHttpService.cs      # Cliente HTTP de alto rendimiento
│   ├── PasswordProcessor.cs         # Sustitución de placeholders
│   ├── PriorityThreadPoolService.cs # Thread pool con work-stealing
│   ├── UserEnumerationService.cs    # Enumeración de usuarios 10 métodos
│   └── ...                          # Servicios de soporte adicionales
├── Themes/
│   └── DarkTheme.xaml               # Tema oscuro de la aplicación
└── dic/
    ├── user.txt                      # Lista de usuarios por defecto
    ├── pass.txt                      # Lista de contraseñas por defecto
    └── pass_max.txt                  # Lista extendida de contraseñas

Solución de Problemas

Problema	Causa	Solución
La aplicación no inicia	Falta .NET 6 Runtime	Instala .NET 6 Desktop Runtime
La aplicación falla al iniciar	Archivos DLL faltantes	Asegúrate de que todos los archivos del ZIP estén en la misma carpeta
Todos los resultados muestran errores	Problema de red/firewall	Verifica la conexión a internet; prueba reduciendo hilos
El escaneo es muy lento	Pocos hilos o timeout alto	Aumenta hilos; reduce timeout a 10s
No se encuentran usuarios	REST API del objetivo protegida	Normal — la herramienta recurre a usuarios por defecto
Carpeta Results no creada	Problema de permisos	Ejecuta como Administrador o mueve a carpeta con permisos de escritura
XML-RPC no encontrado	Objetivo deshabilitó XML-RPC	No se puede probar; la herramienta omitirá ese dominio
Alto uso de RAM	Muchos hilos + diccionarios grandes	Reduce el número de hilos; divide la lista de dominios

License / Licencia

This project is licensed under the MIT License. See LICENSE for details.

Este proyecto está bajo la Licencia MIT. Ver LICENSE para más detalles.

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
.github		.github
Core		Core
Models		Models
Services		Services
Themes		Themes
ViewModels		ViewModels
Views		Views
dic		dic
.gitignore		.gitignore
App.xaml		App.xaml
App.xaml.cs		App.xaml.cs
FEATURES_EN.md		FEATURES_EN.md
FEATURES_ES.md		FEATURES_ES.md
LICENSE		LICENSE
README.md		README.md
WpfWordPressTool.csproj		WpfWordPressTool.csproj
WpfWordPressTool.sln		WpfWordPressTool.sln
app.ico		app.ico

Folders and files

Latest commit

History

Repository files navigation