← Voltar ao Blog

PHP2Shell: falha crítica no núcleo do PHP permite execução remota de código (CVE-2026-109618, CVE-2026-109619 e CVE-2026-115560)

Análise de threat intelligence sobre o PHP2Shell: duas falhas de memória no núcleo do PHP (CVSS 9,2) e o novo CVE-2026-115560, ainda sem correção. Veja o que os boletins confirmam, a exploração em curso e como corrigir, mitigar e detectar.

G
Gila Security
21 de outubro de 2026
PHP2Shell: falha crítica no núcleo do PHP permite execução remota de código (CVE-2026-109618, CVE-2026-109619 e CVE-2026-115560)

Em 21 de outubro de 2026, o time de segurança do PHP publicou correções para duas vulnerabilidades críticas no núcleo da linguagem. Elas permitem execução remota de código (RCE) e foram registradas como CVE-2026-109618 e CVE-2026-109619, ambas com nota 9,2 no CVSS v4.0. O conjunto ficou conhecido como PHP2Shell.

Os detalhes vazaram no dia 20, e o PHP antecipou o lançamento, que estava marcado para quinta-feira (22/10).

Se algum servidor, contêiner ou sistema da sua empresa roda PHP e recebe tráfego da internet, atualize hoje. Este texto reúne o que as fontes oficiais confirmam, o que ainda é incerto e o que fazer em cada caso.

Como este texto foi feito. Usamos os boletins oficiais de segurança (advisories) do repositório php-src e as análises de Wiz, Sansec, Huntress e Upwind. Quando as fontes divergem, dizemos isso. Não publicamos código de exploração.

Update: 23/10. O PHP publicou um aviso informativo sobre um terceiro CVE, o CVE-2026-115560, que não é corrigido pelas versões de 21/10. Ele só afeta uma combinação incomum de configuração e código, mas a mitigação é simples: session.upload_progress.enabled=0. Veja a seção de atualização.

Resumo executivo

  • O que é: duas falhas de uso de memória após a liberação (use-after-free), causadas pela forma como o PHP trata erros fatais, principalmente a falta de memória (OOM, de out of memory), durante uma requisição.
  • Impacto: execução de código sem autenticação, com os privilégios do usuário do servidor web (por exemplo, www-data), além de vazamento de memória do processo.
  • Quem está exposto: servidores web com PHP, principalmente Apache com mod_php. O PHP-FPM está menos exposto, mas não está livre.
  • Correção: PHP 8.5.12, 8.4.27, 8.3.36 ou 8.2.35. As versões 8.1 e anteriores não têm correção oficial.
  • Mitigação: nenhuma configuração resolve o problema por completo. Atualizar é a única correção confiável.
  • Update: 23/10: um terceiro CVE, o CVE-2026-115560, foi anunciado e não está corrigido nas versões acima. Mitigação: session.upload_progress.enabled=0. Veja a seção de update.

Cronologia

Data (UTC)Evento
19/08/2026A Wiz Research descobre a primeira falha.
24/08/2026A Wiz reporta o problema ao time de segurança do PHP.
21/09/2026O PHP confirma o recebimento e inicia a correção coordenada.
20/10/2026Os detalhes vazam num post no Hacker News (depois removido) e a watchTowr confirma que as falhas são reais. O PHP antecipa o lançamento.
21/10/2026, 07:43Segundo a Sansec, a Cloudflare reporta os primeiros ataques.
21/10/2026, 14:00O PHP publica as versões 8.5.12, 8.4.27, 8.3.36 e 8.2.35.
21/10/2026 (hora não informada)Update: 23/10: a watchTowr observa exploração dos dois CVEs em seus honeypots.
23/10/2026, 10:12Update: 23/10: o PHP publica o aviso informativo sobre o CVE-2026-115560, ainda sem correção. A correção virá na próxima versão regular.

A Sansec registra que a Calif encontrou caminhos de RCE em 01/08 e reportou o primeiro bug em 11/08. Segundo a Wiz, a Calif e a OpenAI colaboraram na descoberta, na coordenação e na verificação do patch.

O que são as falhas?

Update: 23/10: há agora um terceiro CVE, descrito mais abaixo, cuja causa ainda não foi publicada. As duas primeiras têm a mesma raiz: quando uma requisição termina de forma anormal, o PHP não limpa com segurança o que ficou na memória. Um processo de trabalho (worker) reaproveitado pode, então, usar dados que já foram liberados.

CVE-2026-109618: corrupção causada por falta de memória

Para sair de um erro de falta de memória, o PHP usa uma função chamada longjmp(), que interrompe tudo de uma vez. O problema aparece quando a alocação falha com a requisição ainda parcialmente inicializada: o PHP não leva essa saída antecipada em conta e, ao encerrar a requisição, processa um estado inválido.

O boletim oficial (GHSA-w8hw-w9fx-j79w) descreve formas de levar uma requisição a esse erro sem estourar os limites aparentes:

  • requisições multipart sem tamanho declarado utilizável, que passam pela checagem inicial de post_max_size;
  • partes com um número ilimitado de cabeçalhos, que ocupam muito mais memória dentro do PHP do que trafegam pela rede;
  • campos de arquivo vazios, que não contam para max_file_uploads, mas criam estruturas de metadados, e o efeito se multiplica com nomes de campo aninhados.

CVE-2026-109619: estado global que sobrevive à requisição

Os workers do PHP guardam estado global de erros, sessão, objetos e extensões. Esse estado pode continuar apontando para memória de uma requisição que já terminou. Algumas operações rodam antes da inicialização normal da requisição, leem esses valores e provocam o use-after-free (GHSA-6wmf-4rv5-p3rp).

O boletim descreve duas peças que precisam se encontrar:

  • O que deixa o estado para trás: erros fatais, como falha de parse ou de compilação, require que falha, estouro de tempo de execução e falta de memória.
  • O que usa esse estado depois: os diagnósticos de configuração (INI) emitidos antes da inicialização e o tratamento de upload progress da sessão, que vem ativado por padrão.
  • Condição: as duas coisas precisam acontecer no mesmo worker, em requisições diferentes.

CVE-2026-115560: sessão com troca de serialize handler em tempo de execução

Update: 23/10. Esta falha foi anunciada depois das duas anteriores e não está corrigida nas versões de 21/10.

Ao contrário das duas primeiras, o PHP ainda não publicou o boletim técnico, a nota CVSS nem as versões afetadas, e não explicou a causa. O que o aviso de 23/10 diz é que o problema envolve o rastreamento de progresso de upload da sessão (session upload progress) e só ocorre numa combinação incomum:

  • a configuração define session.serialize_handler como php_binary ou php_serialize;
  • o código da aplicação volta o handler para php com ini_set() antes de session_start();
  • o upload progress continua ativo, que é o padrão.

O PHP afirma que, nessa combinação, um atacante poderia obter execução remota de código. Não se sabe ainda se a causa é a mesma do CVE-2026-109619, que também passa pelo upload progress, e por isso não tratamos os dois como o mesmo problema. Veja a análise e o workaround.

O que a Wiz demonstrou

A análise da Wiz descreve quatro variações: um use-after-free no tratamento do upload progress, um vazamento remoto de memória do processo (devolvido num cookie PHPSESSID), um use-after-free no registro da pilha de chamadas do erro fatal e uma confusão de tipos no OPcache.

O vazamento funciona mesmo que a aplicação nunca chame session_start() e pode expor dados de outras requisições. A Sansec cita senhas, tokens de sessão, chaves de API e chaves privadas TLS como exemplos do que essa memória pode conter.

A Wiz não deixa claro qual CVE corresponde a cada variação, por isso não fazemos essa associação aqui.

Quem está exposto?

AmbienteSituação, segundo o boletim oficial
Apache + mod_phpVulnerável. O RCE foi validado por HTTP, com limites padrão e prefork, antes de qualquer código da aplicação rodar. É o caso mais grave.
PHP-FPMMenos exposto no caso da falta de memória (109618): o processo filho encerra quando a inicialização falha, e esse boletim não demonstra um exploit completo para FPM. Já no 109619, o RCE pelo ciclo de vida da sessão foi validado também contra FPM, e existe um caminho condicional via PHP_VALUE.
FrankenPHPProvavelmente suscetível, segundo a análise do código-fonte.
LSAPI / LiteSpeedCandidato condicional, ainda não validado.

Quanto às versões: o código vulnerável existe desde o PHP 5.4 (2012), e Wiz e Sansec afirmam que praticamente toda versão da última década é afetada. Os boletins oficiais listam como afetadas as ramificações 8.2 a 8.5 anteriores às versões corrigidas. Para o 8.1 e anteriores não há patch oficial, e a Huntress relata que existem versões corrigidas do código-fonte (backports) para 7.4, 8.0 e 8.1.

Quanto às aplicações: a Sansec relata RCE sem autenticação confirmado em Magento, WordPress, Drupal, Joomla, MediaWiki, Roundcube, phpMyAdmin, Nextcloud, Laravel, Symfony e WHMCS. O ponto central é que a falha está no PHP, não na aplicação. Atualizar o plugin ou o CMS não resolve.

O que se sabe sobre exploração e códigos públicos

  • Update: 23/10: a exploração ativa agora está confirmada por mais fontes (watchTowr, Patchstack, Cloudflare). Veja a análise de ameaças. O item abaixo reflete o que se sabia em 21/10.
  • Ataques reais: a Sansec cita ataques iniciais reportados pela Cloudflare antes da publicação do patch. A Huntress disse que não via exploração entre seus parceiros, mas que outras fontes relatavam ataques. O mais prudente é assumir que a exploração em massa é iminente.
  • Códigos de prova de conceito (PoC): os boletins oficiais não linkam nenhum. Circulam repositórios de qualidade muito variada:
    • O laboratório do 0x4148 e a análise que o acompanha são transparentes. Mostram que o caminho vulnerável pode ser alcançado, mas o autor afirma que não conseguiu provocar uma queda nem executar código, porque faltam a preparação precisa da memória (heap grooming) e os endereços específicos de cada build.
    • Outros repositórios dizem ter exploits completos, em geral sem nenhuma evidência, e alguns vendem o código. Trate todos como não verificados.
  • Cuidado com o que você baixa: repositórios de PoC de falhas recém-divulgadas são um vetor conhecido de malware contra analistas. Não execute código de terceiros fora de um laboratório isolado.
  • Isso não torna o risco aceitável: a exploração depende do estado da memória e de uma condição de corrida, e uma tentativa que falha costuma derrubar o worker. Isso gera ruído (erros 5xx e reinícios), mas o boletim é claro: vários workers e a reciclagem de processos reduzem a chance de sucesso de cada tentativa, sem eliminar a condição.

Update: 23/10 — CVE-2026-115560 e análise de ameaças

O que mudou

Em 23/10/2026 (10:12 UTC), dois dias depois das correções de emergência, o PHP publicou o aviso informativo “Session upload progress” e reservou o CVE-2026-115560. Pontos confirmados pelo aviso:

  • É um problema separado do PHP2Shell (109618 e 109619). Não está corrigido em 8.5.12, 8.4.27, 8.3.36 e 8.2.35.
  • Condições (todas juntas):
    1. session.serialize_handler definido como php_binary ou php_serialize na configuração;
    2. a aplicação troca o handler para php em tempo de execução com ini_set() antes de session_start();
    3. session.upload_progress.enabled ainda ativo (é o padrão).
  • Impacto: possível execução remota de código. O PHP descreve a combinação como incomum e improvável na prática.
  • Correção: virá na próxima versão regular de correções (bugfix), não em uma versão de emergência. O boletim completo sai junto.
  • Mitigação oficial: session.upload_progress.enabled=0 até lá. Quem já aplicou isso por causa do CVE-2026-109619 não precisa fazer mais nada.

O que ainda não foi publicado: versões afetadas, versão corrigida, nota CVSS e se a causa é a mesma do 109619. Não preencha essas lacunas por conta própria. Também não há exploração do 115560 reportada até 23/10: os ataques observados desde 21/10 miram os dois CVEs originais.

Há ainda uma alegação independente (publicada por um pesquisador, sem CVE) de que a diferença entre os valores de leitura e escrita de session.serialize_handler permite injeção de objetos, chegando a RCE via __wakeup() ou __destruct(). Não está claro se é o mesmo problema, já que o PHP cita apenas php.ini mais ini_set(), e a alegação inclui também .htaccess e vhost. Trate como não verificada.

Análise de threat intel

Esta seção é a avaliação da Gila a partir de fontes públicas. Quando algo é inferência nossa, está dito.

1. Exploração dos CVEs originais está confirmada. A watchTowr observou exploração dos dois CVEs em seus honeypots em 21/10. A Patchstack relatou “múltiplos incidentes de exploração ativa” de parceiros de hospedagem às 07:34 UTC, antes do patch, e a Cloudflare citou ataques iniciais e ativou regras de WAF. Isso corrige o que dissemos antes: a Huntress não via exploração entre seus parceiros no início, mas a exploração ativa já está documentada por outras fontes. Não há atribuição a nenhum grupo, nem payloads ou IOCs públicos confirmados.

2. A superfície é enorme e antiga. A Recorded Future aponta cerca de 4,38 milhões de serviços PHP expostos (Modat) e 5,1 milhões de IPs com PHP (VirusTotal), a maioria em ramificações já sem suporte. Esses servidores não receberão correção oficial. Na nossa avaliação, é esse parque sem suporte que tende a render a maior parte dos comprometimentos nas próximas semanas.

3. A janela de exposição começou antes do patch. Os detalhes vazaram em 20/10 e um arquivo com o material foi enviado ao VirusTotal em 21/10, às 02:29 UTC. Por isso, a investigação de comprometimento deve olhar para trás até 20/10, no mínimo.

4. Os PoCs públicos são pouco confiáveis, o que não ajuda a defesa. A Recorded Future relata que dois scripts populares dependem de uma teoria que o próprio pesquisador invalidou depois. Isso derruba o risco de cópia trivial, mas não o risco real: atacantes com recursos podem desenvolver exploits próprios, e o vazamento de memória (credenciais, tokens, chaves TLS) já é útil para eles sem RCE. Inferência nossa: espere exploits mais estáveis nas próximas semanas, sobretudo contra mod_php.

5. O 115560 é de baixa probabilidade, não de baixo cuidado. Precisa de uma combinação específica, mas a condição do ini_set() pode vir de uma biblioteca em vendor/, e não só do seu código. Quem tem muitos plugins e dependências não deve presumir que está fora. Como a mitigação não tem custo relevante, não há motivo para esperar.

6. O cenário mais perigoso é o encadeamento. Vazamento de memória para obter segredos, depois RCE ou acesso com credenciais roubadas. Por isso a resposta a incidente precisa incluir troca de segredos, e não apenas a atualização do PHP.

Update: 23/10. Scanner que “não consegue validar” o CVE-2026-115560. Esse resultado é esperado e não significa que o sistema não está afetado. Por enquanto, o PHP não publicou as versões afetadas nem a versão corrigida, então um scanner que compara versões não tem referência. Também não há exploit nem assinatura públicos para um teste ativo, e a condição depende de configuração e de código da aplicação (inclusive de bibliotecas em vendor/), que um scan externo não enxerga. Leia “não validado” como “verifique no host”: rode a auditoria de serialize_handler e confirme session.upload_progress.enabled = 0 no processo que atende a web. Quem já aplicou essa configuração pode ser tratado como mitigado, independentemente da versão.

Workaround para o CVE-2026-115560

Passo 1: desligar o upload progress no nível certo. O boletim do 109619 pede a configuração no php.ini, em um pool do FPM ou na configuração do servidor, com reinício de todos os workers. Não dependa de ini_set() nem de .user.ini.

; php.ini, pool do PHP-FPM ou configuração do servidor
session.upload_progress.enabled = 0

Efeito colateral: barras de progresso de upload baseadas em sessão deixam de funcionar. Aplicações que não usam isso não percebem diferença.

Passo 2: auditar o uso de serialize_handler. Procure nas configurações e no código, incluindo vendor/:

# configuração do PHP e do servidor web
grep -rIn "serialize_handler" /etc/php* /usr/local/etc/php /etc/apache2 /etc/nginx 2>/dev/null

# código da aplicação e dependências
grep -rIn "serialize_handler" /var/www --include=*.php --include=.htaccess --include=.user.ini

Se achar php_binary ou php_serialize na configuração e um ini_set('session.serialize_handler', 'php') no código, esse sistema cumpre as duas primeiras condições. Priorize a mitigação do passo 1 e o monitoramento dele.

Passo 3: confirmar que valeu. Verifique no processo que atende a web, não só no CLI:

# CLI (pode não refletir o servidor web)
php -r 'var_dump(ini_get("session.upload_progress.enabled"));'

Para o valor real do servidor web, use uma página temporária com phpinfo() restrita ao seu IP e remova depois, ou consulte a configuração do pool. Não deixe phpinfo() exposto.

Passo 4: acompanhar a versão corrigida. Quando o PHP publicar a próxima versão regular com o boletim completo do 115560, atualize e só então avalie reativar o recurso, se ele for necessário.

Workaround consolidado (os três CVEs)

CamadaMedidaCobre
CorreçãoAtualizar para 8.5.12, 8.4.27, 8.3.36 ou 8.2.35 e reiniciar os workers109618 e 109619
Configuraçãosession.upload_progress.enabled = 0109619 (parcial) e 115560
Servidor web/WAFBloquear multipart/form-data onde não há upload e limitar o tamanho e o aninhamento da entradagatilhos conhecidos do 109618 e 109619
ArquiteturaIsolar ou migrar PHP 8.1 e anteriores; WAF ou VPN na frentetodos, enquanto não há patch
DetecçãoAlertar para shell criado por php-fpm/httpd/apache2 e picos de 5xxtentativas e pós-exploração
RespostaTrocar segredos de servidores sob suspeita, com análise retroativa desde 20/10vazamento de memória

Nenhuma dessas medidas, sozinha, substitui a atualização.

Mudanças no checklist

  • session.upload_progress.enabled = 0 aplicado no php.ini/pool/servidor (não via ini_set()), com todos os workers reiniciados.
  • Auditoria de serialize_handler feita em configuração, aplicação e vendor/.
  • Investigação de comprometimento cobrindo logs desde 20/10/2026.
  • Atualização para a próxima versão regular do PHP agendada.

Como saber se você está exposto?

  1. Faça o inventário de tudo que roda PHP, inclusive o que não parece PHP: painéis de controle, CMS, plugins empacotados, imagens Docker e hospedagem compartilhada.
  2. Descubra qual PHP realmente atende a web. O php -v do terminal pode apontar para outra instalação.
# versão do CLI (pode não ser a do servidor web)
php -v

# PHP-FPM
php-fpm -v 2>/dev/null || php-fpm8.3 -v

# Apache com mod_php
apachectl -M 2>/dev/null | grep -i php

# imagens de contêiner
docker run --rm --entrypoint php SUA_IMAGEM:TAG -v
  1. Compare a versão com as corrigidas: 8.5.12, 8.4.27, 8.3.36 e 8.2.35. Os pacotes das distribuições (Debian, Ubuntu, RHEL) podem trazer a correção com outro número de versão. Consulte o aviso do fornecedor.
  2. Se você usa o repositório Remi, a Sansec informou que ele ainda não tinha a correção em 21/10. Confira antes de assumir que está protegido.

Como corrigir?

1. Atualizar (a única correção completa)

Atualize para 8.5.12, 8.4.27, 8.3.36 ou 8.2.35 e reinicie os workers (reload do PHP-FPM, restart do Apache). Em contêineres, a versão que vale é a de dentro da imagem: reconstrua sobre uma base com PHP corrigido e publique de novo. Veja o estudo de caso com WordPress em Docker mais abaixo.

Comece pelos sistemas expostos à internet, e dentre eles pelos que usam Apache com mod_php.

2. Versões sem suporte (8.1 e anteriores)

Não há correção oficial. Por ordem de preferência:

  1. migrar para uma versão com suporte;
  2. contratar um fornecedor com suporte estendido (LTS);
  3. compilar a partir dos backports de código-fonte, lembrando que a Huntress não consegue verificar patches de terceiros;
  4. enquanto isso, isolar o sistema atrás de VPN ou WAF, ou tirá-lo do ar.

3. Mitigações temporárias (reduzem o risco, mas não resolvem)

Desligar o upload progress da sessão. O boletim recomenda fazer isso mesmo depois do patch, se a função não for usada:

; php.ini do SAPI que atende a web
session.upload_progress.enabled = 0

PHP 8.5 sem o patch: esta configuração remove a origem do RCE confirmado, mas não as demais famílias de estado.

fatal_error_backtraces = 0

Bloquear multipart/form-data onde a aplicação não precisa dele. Como o PHP processa o corpo da requisição antes de o código da aplicação rodar, o bloqueio precisa ficar no servidor web ou no WAF.

nginx:

# rota que NÃO recebe upload
location / {
    if ($content_type ~* "^multipart/form-data") {
        return 403;
    }
    # ... fastcgi_pass / proxy normal
}
# libere o multipart só onde há upload legítimo
location = /upload {
    # ... configuração normal
}

Apache (mod_php):

SetEnvIfNoCase Content-Type "^multipart/form-data" is_multipart
<Location "/">
    <RequireAll>
        Require all granted
        Require not env is_multipart
    </RequireAll>
</Location>

Testamos as duas regras em contêineres nginx:alpine e httpd:alpine: a sintaxe é válida, o multipart é bloqueado com erro 403 e as requisições normais passam. A Sansec recomenda a mesma regra para o nginx. Teste também na sua aplicação, porque uploads de imagens de produto, formulários de contato e o checkout costumam usar multipart.

Limite desta mitigação: ela cobre os gatilhos multipart conhecidos, mas o boletim do 109619 descreve também situações que não dependem de multipart, como os diagnósticos de INI aplicados antes da inicialização (por exemplo, via .htaccess ou php_value no mod_php). Ela reduz a superfície de ataque e não substitui a atualização.

Limitar a entrada no proxy ou no WAF: tamanho decodificado da requisição, post_max_size conservador, max_input_nesting_level baixo e limites para o número de partes, de cabeçalhos por parte e de uploads.

memory_limit = -1. Para quem não pode atualizar, o boletim do 109618 indica esta como a principal mitigação de configuração, porque ela elimina o limite previsível por requisição que permite provocar a falta de memória de forma controlada. O próprio boletim ressalva que ela é incompleta: se o mmap() ou outra alocação falhar, o PHP ainda pode usar longjmp().

Há também um custo sério: uma única requisição pode consumir toda a memória do servidor, e a Sansec orienta restaurar o limite depois de atualizar. Se optar por essa medida, reinicie todos os workers e confirme que nenhum pool, diretório ou aplicação restaurou um limite finito.

Um limite externo por cgroup (memory.max) é uma alternativa, com uma ressalva: encerrar o contêiner ou o cgroup pode derrubar o processo mestre e todos os workers, a menos que cada worker tenha o seu próprio grupo.

Evite RLIMIT_AS e RLIMIT_DATA. Eles fazem o mmap() falhar ao atingir o limite e levam justamente ao caminho vulnerável.

Outras formas de reduzir o risco (do boletim do 109619): eliminar erros fatais nos caminhos que o atacante alcança, reduzir os diagnósticos de INI aplicados antes da inicialização e, se o desempenho permitir, considerar pm.max_requests = 1.

Estudo de caso: corrigindo um WordPress em Docker

Para mostrar o caminho na prática, este é o passo a passo de um caso real que acompanhamos, com os nomes trocados. Era um blog WordPress em docker-compose, com Apache e mod_php, e o MariaDB em outro contêiner. O núcleo do WordPress já estava atualizado (7.1.3), mas o contêiner usava a imagem wordpress:latest, com PHP 8.3.31, vulnerável aos dois CVEs. Como a falha está no PHP, atualizar o WordPress não resolve.

1. Conferir a versão dentro do contêiner

A versão que importa é a do contêiner, não a do servidor onde ele roda:

docker exec <contêiner> php -v

2. Ver se a imagem oficial já tinha a correção

No dia da divulgação (21/10), wordpress:latest e as tags php8.3-apache, php8.4-apache e php8.5-apache ainda estavam uma versão abaixo da correção (8.3.35, 8.4.26 e 8.5.11). Já a imagem oficial do PHP, php:8.3.36-apache, estava publicada. A solução foi montar uma imagem própria.

Essa situação costuma durar poucos dias. Antes de montar uma imagem própria, confira se a tag oficial que você usa já foi atualizada.

3. Mitigação provisória

Enquanto a imagem corrigida não ficava pronta, desativamos o upload progress com um arquivo .ini montado como volume somente leitura:

; ./php-conf/99-php2shell-mitigation.ini
session.upload_progress.enabled = 0
# docker-compose.yml
services:
  wordpress:
    volumes:
      - ./html:/var/www/html
      - ./php-conf/99-php2shell-mitigation.ini:/usr/local/etc/php/conf.d/99-php2shell-mitigation.ini:ro

Isso reduz a superfície de ataque, mas não corrige a falha. Os boletins são claros: só atualizar o PHP resolve.

4. Imagem própria com PHP 8.3.36

Reproduzimos o que a imagem oficial do WordPress faz (extensões, OPcache, registro de erros, remoteip e entrypoint), trocando apenas a base:

FROM wordpress:latest AS wp
FROM php:8.3.36-apache

RUN set -eux; \
    apt-get update; \
    apt-get install -y --no-install-recommends \
        ghostscript libfreetype6-dev libicu-dev libjpeg-dev \
        libmagickwand-dev libpng-dev libwebp-dev libzip-dev; \
    docker-php-ext-configure gd --with-freetype --with-jpeg --with-webp; \
    docker-php-ext-install -j"$(nproc)" bcmath exif gd intl mysqli zip; \
    pecl install imagick; \
    docker-php-ext-enable imagick opcache; \
    rm -rf /var/lib/apt/lists/* /tmp/pear

COPY --from=wp /usr/local/etc/php/conf.d/opcache-recommended.ini /usr/local/etc/php/conf.d/
COPY --from=wp /usr/local/etc/php/conf.d/error-logging.ini       /usr/local/etc/php/conf.d/
COPY --from=wp /etc/apache2/conf-available/remoteip.conf         /etc/apache2/conf-available/

RUN a2enmod rewrite expires remoteip && a2enconf remoteip && \
    chown www-data:www-data /var/www/html

COPY --from=wp /usr/src/wordpress /usr/src/wordpress
COPY --from=wp /usr/local/bin/docker-entrypoint.sh /usr/local/bin/

VOLUME /var/www/html
ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["apache2-foreground"]
docker build -t meusite-wordpress:php8.3.36 .

Se o build falhar em pecl install imagick: o download vem do pecl.php.net, que pode ficar instável justamente em dias de grande demanda (no dia da divulgação, ao reproduzir o exemplo, ele respondeu com erros 500 e 504). Isso não indica erro no Dockerfile. Tente de novo mais tarde, ou deixe o imagick de fora se o seu site não o usa, removendo libmagickwand-dev, a linha do pecl e imagick do docker-php-ext-enable.

5. Validar antes de trocar

Comparamos php -m entre a imagem antiga e a nova. As listas de módulos saíram idênticas, o que indica que nenhuma extensão que o WordPress usa ficou para trás.

6. Fazer a troca

Fizemos backup do docker-compose.yml, trocamos image: wordpress:latest por image: meusite-wordpress:php8.3.36 e rodamos docker compose up -d wordpress. Os arquivos do WordPress (volume ./html) e o banco de dados não foram alterados.

7. Verificar

  • php -v no contêiner: 8.3.36.
  • /, /wp-login.php e /wp-json/ responderam 200, /wp-admin/ respondeu 302 (redirecionamento para o login) e o site público respondeu 200.
  • session.upload_progress.enabled confirmado como 0.
  • Plano de volta: restaurar o docker-compose.yml do backup e subir o contêiner de novo.

Trade-offs e pontos de atenção

  • Sem atualização automática. Uma imagem própria não recebe as atualizações da imagem oficial. Quando a imagem oficial do WordPress sair com PHP 8.3.36 ou superior, vale voltar a ela.
  • Multipart não foi bloqueado, para não quebrar o upload de mídia do WordPress.
  • memory_limit = -1 não foi usado, porque deixa uma única requisição consumir toda a memória do servidor.
  • Escopo da validação. Confirmamos que o site responde. Não testamos upload de mídia nem login com senha, e isso deve entrar no seu roteiro de testes.
  • Sem indicadores de comprometimento. Não encontramos IOCs conhecidos do PHP2Shell, e a ausência de sinais nos logs não prova que não houve exploração.

Como detectar tentativas e comprometimento?

Os boletins alertam: um log limpo não prova que está tudo bem. Também não há indicadores de comprometimento (IOCs) confirmados, e multipart/form-data e PHP_SESSION_UPLOAD_PROGRESS sozinhos não servem de indicador, porque são usos legítimos.

Sinais de tentativa:

  • requisições multipart em rotas que não recebem upload;
  • erros de limite de memória logo depois de requisições multipart;
  • picos de erros 5xx nos workers PHP (a Upwind os trata como sinal de alta confiança de uma tentativa que falhou) e reinícios frequentes de workers;
  • cookies PHPSESSID anormalmente grandes ou malformados nas respostas, que podem indicar vazamento de memória.

Sinais de pós-exploração (procure na telemetria de processos ou no EDR):

  • php-fpm, php-cgi, httpd ou apache2 criando processos como sh, bash, python, perl, curl, wget ou nc;
  • argumentos com /dev/tcp/, fsockopen ou mkfifo;
  • comandos de reconhecimento, como whoami, id e uname -a, executados pelo usuário do servidor web;
  • arquivos novos no diretório web, tarefas cron e contas de usuário que ninguém criou.

Para facilitar a investigação, habilite log_errors, um error_log funcional e error_reporting=E_ALL na configuração de inicialização.

E se você suspeita de comprometimento?

  1. Isole o servidor da rede.
  2. Preserve os logs do servidor web e do PHP e uma imagem do disco antes de mudar qualquer coisa.
  3. Procure webshells, arquivos recentes no diretório web, cron, tarefas agendadas e contas novas.
  4. Troque as credenciais e os segredos que o processo conseguia acessar: chaves de API, senhas de banco de dados, tokens de sessão e chaves TLS. O vazamento de memória pode ter exposto esses dados.
  5. Atualize o PHP antes de recolocar o sistema no ar e reconstrua o servidor a partir de uma imagem conhecida e confiável.
  6. Se houve acesso a dados pessoais, avalie as obrigações de comunicação previstas na LGPD.

Checklist rápido

  • Inventário de todos os sistemas com PHP, incluindo contêineres e software de terceiros.
  • Versão do PHP conferida dentro de cada contêiner (docker exec <contêiner> php -v), e não só no servidor.
  • SAPI que atende a web identificado em cada um (mod_php, FPM, FrankenPHP).
  • Atualização para 8.5.12, 8.4.27, 8.3.36 ou 8.2.35, com os workers reiniciados.
  • Sistemas em PHP 8.1 ou anterior isolados ou migrados.
  • session.upload_progress.enabled = 0 aplicado onde a função não é usada.
  • Multipart bloqueado nas rotas sem upload, e a regra testada.
  • Alertas para workers que criam shells e para picos de erros 5xx.
  • Segredos trocados em qualquer servidor sob suspeita.

Onde a Gila e o Defenzor entram

Uma falha no núcleo da linguagem é o pior cenário para uma empresa, porque está em tudo que roda PHP, inclusive no que ninguém lembra que existe. O primeiro passo é saber o que você tem exposto. O Defenzor monitora continuamente a sua superfície digital, ajuda a identificar as tecnologias e versões expostas e avisa quando algo muda, com alertas no Slack, no Teams ou por webhook.

Update: 23/10. Do achado à correção. Com três CVEs em andamento, o desafio deixa de ser descobrir e passa a ser priorizar e acompanhar a correção. A gestão de vulnerabilidades do Defenzor ordena os achados por exploração real, com a lista KEV da CISA e o EPSS, e permite filtrar só o que está sob exploração ativa, o caso do PHP2Shell. Os achados da mesma causa raiz (como “PHP desatualizado” em vários servidores) viram um plano de correção com responsável e prazo, e cada achado passa por Aberta, Em andamento, Corrigida, Re-teste e Fechada. Assim, a atualização do PHP e a mitigação do CVE-2026-115560 ficam rastreadas até a validação, com trilha de auditoria.

Para confirmar que a correção foi aplicada e se algum servidor já foi alvo de ataque, a Gila faz testes de intrusão e avaliações de comprometimento, com evidências reproduzíveis e recomendações priorizadas.

Quer ajuda para mapear e corrigir a sua exposição ao PHP2Shell? Fale com a Gila Security.

Referências