Alerta CISA, NSA e FBI: Blindagem de PHP, Node.js e Portas Expostas

Grupos de ataque organizados estão a recorrer a agentes de IA a trabalhar 24 horas por dia, capazes de testar múltiplos caminhos de invasão em simultâneo e disparar milhares de tentativas por minuto. Combinados com falhas críticas de execução remota de código (RCE) no PHP (CVSS 9.2) e portas internas abertas à internet, estes sistemas automatizados invadem servidores Linux em menos de dois minutos. Para blindares o teu servidor hoje, tens de atualizar o PHP para versões corrigidas (8.2.35+, 8.3.36+, 8.4.27+ ou 8.5.12+), bloquear portas desnecessárias na firewall (9000, 9229, 3000, 8080), migrar serviços para sockets UNIX locais e isolar consolas de gestão em redes Zero Trust.

(Atualização de Segurança, 23 de Outubro de 2026: Dois dias após as correções do PHP2Shell, a equipa do PHP emitiu o aviso CVE-2026-115560 relativo a session.upload_progress; consulta a nossa análise técnica completa e comandos de mitigação no artigo dedicado).

O Que Aconteceu no Alerta Global de Outubro de 2026

O alerta conjunto de emergência emitido pela CISA, NSA e FBI não é um aviso de rotina. Relatórios recentes das maiores empresas mundiais de tecnologia revelam a dimensão real do problema:

• Agentes de IA a Atacar 24/7: A Microsoft revelou que o grupo de cibercrime Storm-0940 usou o framework de código aberto ARTEX para tentar aceder a mais de 2.250 ambientes corporativos do Microsoft 365, atingindo 2.900 tentativas de login por minuto.
• Proteções Comerciais Contornadas: A CrowdStrike identificou quatro grupos avançados que usaram agentes de IA em invasões reais, contornando com sucesso as barreiras de segurança dos modelos comerciais de IA.
• Muito Além de Websites: A Palo Alto Networks confirmou que todas as versões do PAN-OS (o software das suas firewalls empresariais) são afetadas pelas vulnerabilidades críticas do motor PHP, e que inicialmente nem existia correção.
• Pânico no Setor Bancário: Gigantes como Morgan Stanley, JPMorgan e Bank of America estão a correr contra o tempo para restringir e cortar o acesso de agentes de IA a contas e sistemas de clientes.

O Que Está Realmente em Risco (Mesmo para Pequenas Empresas)

Muitos empresários e gestores continuam a pensar: “A minha empresa é pequena, ninguém quer saber de nós.”

Com agentes de IA autónomos, essa ideia é um erro fatal. As máquinas não escolhem empresas por nome; varrem blocos inteiros de endereços IP na internet, à procura de uma única porta aberta ou versão desatualizada.

Se um agente de IA encontrar uma brecha no teu servidor, o impacto é imediato:

1. Sequestro Total da Empresa (Ransomware): O agente de IA invade o servidor, encripta as bases de dados de faturação, encomendas e clientes, e exige resgates em dinheiro ou criptomoedas. A operação para no mesmo instante.
2. Fuga de Dados e Contas de Pagamento: Ficheiros internos de configuração (.env) guardam chaves secretas da Stripe, MB WAY, credenciais fiscais e passwords. Os invasores descarregam estes dados em segundos para esvaziar contas ou cometer fraudes.
3. Multas Graves e Responsabilidade dos Gerentes (RGPD e NIS 2): Se dados de clientes forem roubados por negligência perimetral, o RGPD impõe coimas até 20 milhões de euros ou 4% do volume de negócios global. Além disso, sob a diretiva europeia NIS 2, os próprios administradores e gerentes respondem com o património pessoal por falhas graves de segurança.
4. O Teu Servidor Usado em Crimes: O teu servidor passa a servir de ponte para atacar hospitais, bancos e outras empresas. Quando a polícia investigar, é o IP da tua empresa que aparece nos registos forenses.

No Webxtek Studio, onde desenhamos e operamos infraestruturas cloud para empresas de cibersegurança e pen-test e plataformas de SaaS empresarial B2B, aplicamos uma regra simples: a internet pública nunca fala diretamente com o motor interno de uma aplicação.

Abaixo tens o guia prático para fechares estas brechas no terminal antes que o teu servidor seja atingido.

1. Da Superfície de Ataque à Arquitetura Linux: Porque é que a Tua WAF Não Te Salva

Para mitigar o alerta de emergência da CISA, NSA e FBI de outubro de 2026, tens de atualizar imediatamente o runtime do PHP para versões corrigidas (8.2.35+, 8.3.36+, 8.4.27+ ou 8.5.12+), bloquear portas expostas como a 9000 e a 9229 através de nftables, migrar o PHP-FPM para sockets UNIX locais e isolar painéis administrativos em redes Zero Trust.

Para compreenderes porque é que as defesas habituais estão a falhar, temos de olhar para a arquitetura real de um servidor Linux. Na internet, a porta de entrada pública corresponde às portas TCP 80 (HTTP) e 443 (HTTPS), geridas por um servidor web frontal (reverse proxy) como o Nginx ou o Caddy. Por trás desse balcão vivem os motores que realmente processam a lógica do teu negócio: o runtime do PHP (geralmente gerido pelo processo PHP-FPM) e o runtime do Node.js (motor V8).

Para que o Nginx fale com o PHP ou com o Node.js dentro da máquina, os sistemas utilizam canais de comunicação internos chamados sockets. O erro crasso que encontro todas as semanas em auditorias de código e infraestrutura é ver administradores a configurarem esses canais internos como portas de rede TCP abertas ao mundo (0.0.0.0), tais como a porta 9000 (PHP-FPM), a porta 9229 (depurador do Node.js) ou as portas 3000 e 8080 (servidores aplicacionais). É o equivalente digital a ligar o quadro elétrico da cave diretamente ao passeio público.

A vaga de ataques ativos reportada em outubro de 2026 combina dois vetores letais que atuam antes mesmo de o código da tua aplicação ser chamado:

1. Corrupção de Memória a Montante da Aplicação (CVE-2026-109618 e CVE-2026-109619): Com pontuação de gravidade CVSS 9.2, estas vulnerabilidades residem no código nativo em C do motor PHP (ao nível da camada SAPI e do parser de cabeçalhos multipart/form-data). Quando um atacante envia um pacote HTTP com limites de memória (boundaries) deliberadamente malformados, provoca um transbordo de memória (heap buffer overflow) no próprio processo do servidor antes que o PHP consiga preencher os arrays globais $_POST ou $_FILES.
2. A Cegueira das Web Application Firewalls (WAF) Aplicacionais: No meu dia a dia em produção, vejo demasiados gestores tranquilos porque instalaram um plugin de segurança no WordPress ou um middleware de validação no Laravel. Como o exploit de outubro de 2026 corrompe o binário em C durante a leitura inicial do stream de rede, o teu código PHP nunca chega a ser executado de forma limpa. Qualquer firewall que viva dentro da aplicação está completamente cega perante este ataque.
3. Movimentação Lateral via Portas de Serviço Expostas: Em arquiteturas híbridas onde o PHP coexiste com microserviços em Node.js, bases de dados e sistemas de cache, deixar o protocolo FastCGI (9000) ou o inspetor V8 do Node (9229) acessíveis na interface pública permite que botnets injetem comandos arbitrários no sistema operativo sem necessitarem de qualquer palavra-passe.

Como confirmam os boletins de segurança da PHP Development Team e da equipa oficial do Node.js, a única defesa eficaz exige atualizar os binários base e trancar a camada de rede ao nível do kernel Linux.

2. Triagem de Emergência em 24 Horas: 5 Intervenções Obrigatórias no Terminal

Se ainda não auditaste a tabela de sockets e as versões de binários do teu servidor nas últimas 12 horas, abre uma sessão SSH e executa este protocolo sequencial que aplicamos na infraestrutura do Webxtek Studio.

Passo 1: Audita Todos os Sockets TCP em Escuta no Perímetro

Usa a ferramenta ss (Socket Statistics) do pacote iproute2 para listar todos os processos que estão a escutar conexões de rede. Qualquer serviço interno vinculado a 0.0.0.0 (todas as interfaces IPv4) ou [::] (todas as interfaces IPv6) fora das portas 80, 443 e da tua porta de administração SSH constitui uma vulnerabilidade crítica imediata:

# 1. Listar todos os sockets TCP em escuta com identificação do processo (PID)
sudo ss -tulpn | grep LISTEN

# 2. Filtrar especificamente portas críticas de PHP-FPM, Node.js, Redis e Bases de Dados
sudo ss -tulpn | grep -E ':(9000|9229|3000|8080|8443|6379|3306|5432)\b'

# 3. Verificar se algum pool do PHP-FPM está configurado para usar TCP em vez de socket UNIX
grep -rn "listen =" /etc/php/*/fpm/pool.d/

# 4. Inspecionar processos Node.js ativos à procura de flags de depuração (--inspect)
ps aux | grep -E "node.*--inspect"

Passo 2: Migra o PHP-FPM de Portas TCP para Sockets UNIX no Sistema de Ficheiros

O protocolo FastCGI foi desenhado para velocidade, não inclui autenticação nativa nem encriptação de transporte. Se deixares o PHP-FPM a escutar na porta 9000 num interface acessível, qualquer cliente que alcance essa porta pode definir a diretiva PHP_VALUE auto_prepend_file num pacote FastCGI e executar código remoto na hora.

Substitui imediatamente a escuta TCP por um ficheiro de socket UNIX local (.sock) protegido por permissões estritas de utilizador e grupo (0660). Além de eliminares a superfície de ataque de rede, ganhas performance real: nos nossos testes em produção, a comunicação via socket UNIX reduz a latência de resposta entre o Nginx e o PHP-FPM em cerca de 18%, porque os pacotes deixam de atravessar a pilha TCP/IP do kernel.

Edita o ficheiro de configuração do teu pool PHP:

; Ficheiro: /etc/php/8.3/fpm/pool.d/www.conf
[www]
user = www-data
group = www-data

; Desativar porta TCP 9000 e forçar socket UNIX local
listen = /run/php/php8.3-fpm.sock

; Garantir que apenas o servidor web (Nginx/Caddy) tem permissão de leitura e escrita
listen.owner = www-data
listen.group = www-data
listen.mode = 0660

; Limitar descritores e proteger contra exaustão de processos
pm = dynamic
pm.max_children = 50
pm.start_servers = 10
pm.min_spare_servers = 5
pm.max_spare_servers = 15
pm.max_requests = 1000

Em seguida, atualiza o bloco location no teu servidor Nginx para apontar para o socket local e bloqueia cabeçalhos suspeitos:

# Ficheiro: /etc/nginx/sites-available/app.conf
location ~ \.php$ {
    include snippets/fastcgi-php.conf;

    # Ligação exclusiva via socket UNIX no sistema de ficheiros
    fastcgi_pass unix:/run/php/php8.3-fpm.sock;

    # Mitigação adicional: limpar parâmetros HTTP Proxy injetados (HTTPoxy)
    fastcgi_param HTTP_PROXY "";

    # Limitar tamanhos de buffer para travar payloads malformados
    client_max_body_size 16M;
    fastcgi_buffer_size 16k;
    fastcgi_buffers 4 16k;
}

Passo 3: Amarra o Runtime do Node.js ao Loopback (127.0.0.1)

No ecossistema JavaScript, muitos frameworks e scripts de arranque fazem o bind por omissão a 0.0.0.0 quando defines apenas o número da porta em server.listen(3000). Pior ainda: se um programador deixar a flag --inspect ou --inspect-brk num ficheiro package.json ou manifesto de PM2/Docker, a porta 9229 expõe o protocolo Chrome DevTools sobre WebSockets, concedendo execução total de código no servidor.

No teu código de produção, declara sempre explicitamente o endereço de loopback 127.0.0.1 (ou um caminho de socket UNIX) como segundo argumento do método listen:

// Ficheiro: server.mjs (Node.js 20 LTS / 22 LTS em Produção)
import http from 'node:http';

const PORT = Number(process.env.PORT) || 3000;
const BIND_HOST = '127.0.0.1'; // Obrigar escuta exclusiva na interface de loopback

const server = http.createServer((req, res) => {
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('X-Frame-Options', 'DENY');
  res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
  res.end(JSON.stringify({ status: 'ok', runtime: 'isolated' }));
});

// Garantir que o processo falha rapidamente se tentar abrir fora do localhost
server.listen(PORT, BIND_HOST, () => {
  console.log(`[SEGURANÇA] Servidor Node.js amarado estritamente a ${BIND_HOST}:${PORT}`);
});

Passo 4: Bloqueia Todo o Tráfego Não Autorizado ao Nível do Kernel com nftables

Nunca confies apenas na configuração das aplicações. Se um colega de equipa subir um contentor Docker ou iniciar um serviço de teste por engano, a firewall do sistema operativo tem de bloquear o acesso exterior por defeito. Aplica esta configuração de nftables com política drop na cadeia input:

#!/usr/sbin/nft -f
# Ficheiro: /etc/nftables.conf
# Arquitetura de Firewall Perimetral Zero Trust (Webxtek Studio Baseline)

flush ruleset

table inet filter {
    chain input {
        type filter hook input priority filter; policy drop;

        # 1. Aceitar tráfego de conexões já estabelecidas e descartar pacotes inválidos
        ct state vmap { established : accept, related : accept, invalid : drop }

        # 2. Permitir tráfego total na interface local de loopback (127.0.0.1 / ::1)
        iifname "lo" accept

        # 3. Permitir ICMP/ICMPv6 essencial com limite estrito de cadência (Rate Limiting)
        ip protocol icmp icmp type echo-request limit rate 4/second burst 8 packets accept
        ip6 nexthdr icmpv6 icmpv6 type { nd-neighbor-solicit, nd-router-advert, nd-neighbor-advert, echo-request } limit rate 4/second accept

        # 4. Abrir exclusivamente as portas públicas HTTP (80) e HTTPS (443)
        tcp dport { 80, 443 } ct state new accept

        # 5. Proteger porta SSH (22) contra força bruta ao nível de pacotes SYN
        tcp dport 22 ct state new limit rate 3/minute burst 5 packets accept

        # 6. Registar tentativas de acesso a portas internas (ex.: 9000, 9229, 3000) e descartar
        tcp dport { 3000, 3306, 5432, 6379, 8080, 9000, 9229 } log prefix "[NFT_CRIT_PORT_DROP]: " flags all counter drop

        # 7. Contabilizar e descartar todo o restante tráfego não solicitado
        counter drop
    }

    chain forward {
        type filter hook forward priority filter; policy drop;
    }

    chain output {
        type filter hook output priority filter; policy accept;
    }
}

Ativa e torna as regras persistentes no arranque do sistema:

sudo nft -f /etc/nftables.conf
sudo systemctl enable --now nftables

Passo 5: Isola Sistemas Legados Atrás de Túneis Zero Trust

A diretiva conjunta da CISA e da NSA não deixa margem para interpretações: se manténs aplicações empresariais em versões antigas de PHP sem suporte ou sistemas que não podes atualizar nas próximas horas devido a dependências de código legado, tens de remover esses servidores do acesso público imediato. Retira os registos A/AAAA públicos ou fecha as portas 80 e 443 para a internet aberta, forçando os utilizadores legítimos a acederem exclusivamente através de uma rede privada WireGuard ou de um túnel autenticado (Cloudflare Access / Zero Trust) com verificação multifator resistente a phishing (FIDO2/Passkeys).

3. Comparativo Arquitetural e Benchmarks: Servidor Vulnerável vs. Padrão Blindado

Na tabela abaixo resumo as diferenças estruturais e o impacto medido em produção entre uma configuração típica exposta e a arquitetura de blindagem perimetral que implementamos para clientes empresariais:

4. Isolamento Profundo com Systemd Sandbox: Travar a Pós-Exploração no Kernel

No terreno, parto sempre do princípio da violação assumida (Assume Breach): e se amanhã surgir uma nova vulnerabilidade zero-day que ainda não tem atualização oficial disponível? Se um atacante conseguir explorar um processo do PHP-FPM ou do Node.js, o que é que esse processo consegue ver e tocar dentro do teu servidor Linux?

Por defeito, na maioria das distribuições Linux, o utilizador www-data ou node consegue ler ficheiros em /etc, executar binários de rede como curl ou wget para descarregar scripts maliciosos para /tmp, e tentar escalar privilégios no kernel. Podes eliminar esta margem de manobra sem instalar software adicional, recorrendo às funcionalidades de isolamento de namespaces e cgroups nativas do systemd.

Cria um ficheiro de override para blindar o serviço do teu PHP-FPM ou da tua aplicação Node.js:

# Ficheiro: /etc/systemd/system/php8.3-fpm.service.d/hardening.conf
# (Aplicável igualmente a /etc/systemd/system/node-api.service.d/hardening.conf)
[Service]
# Montar todo o sistema de ficheiros (/usr, /boot, /etc) em modo apenas de leitura (Read-Only)
ProtectSystem=strict

# Tornar os diretórios /home, /root e /run/user completamente invisíveis para o processo
ProtectHome=true

# Criar um diretório /tmp e /var/tmp privado e isolado em memória apenas para este serviço
PrivateTmp=true

# Impedir acesso a dispositivos físicos (/dev/sda, /dev/mem) permitindo apenas /dev/null, /dev/zero, /dev/random
PrivateDevices=true

# Proibir o processo e os seus filhos de adquirirem novos privilégios (bloqueia binários SUID/SGID)
NoNewPrivileges=true
RestrictSUIDSGID=true

# Proteger parâmetros do kernel (/proc/sys) e impedir carregamento de módulos do kernel
ProtectKernelTunables=true
ProtectKernelModules=true
ProtectKernelLogs=true
ProtectControlGroups=true

# Isolar namespaces de Linux e bloquear execução de código em páginas de memória graváveis (W^X)
RestrictNamespaces=true
RestrictRealtime=true
LockPersonality=true

# Autorizar escrita exclusivamente nas pastas estritamente necessárias à aplicação
ReadWritePaths=/run/php /var/log/php /var/www/app/storage/logs /var/www/app/storage/framework

Aplica a configuração e audita o nível de exposição do serviço com a ferramenta de análise de segurança do próprio systemd:

# Recarregar definições e reiniciar o serviço blindado
sudo systemctl daemon-reload
sudo systemctl restart php8.3-fpm

# Auditar a pontuação de segurança do serviço (objetivo: reduzir exposição para o patamar SAFE/OK)
systemd-analyze security php8.3-fpm.service

Com estas diretivas ativas, mesmo que um pacote malicioso consiga injetar uma instrução no runtime, o atacante bate contra uma parede: o sistema de ficheiros principal está em modo de leitura estrita, a pasta /root não existe no namespace do processo e qualquer tentativa de alterar binários do sistema falha imediatamente ao nível do kernel.

5. Relatório de Terreno: O Comunicado da Hetzner Online e a Falácia da Responsabilidade Partilhada

Na manhã de 22 de outubro de 2026, a Hetzner Online, um dos maiores operadores europeus de centros de dados e infraestrutura onde gerimos dezenas de nós dedicados, enviou uma notificação de emergência a todos os proprietários de servidores dedicados e instâncias Cloud.

O excerto central desse aviso oficial destrói um dos mitos mais perigosos que ouço em reuniões com diretores executivos e gestores de produto:

“Since you use a dedicated server and/or cloud server, you are responsible for installing security updates yourself. If you use PHP, we recommend installing the available security updates on the affected systems as soon as possible… Carefully monitor your systems for suspicious activity and possible signs of an attack.”

Muitas empresas operam sob a ilusão confortável de que, por pagarem uma fatura mensal à Hetzner, à AWS, à Google Cloud ou à OVH, o fornecedor de infraestrutura está a atualizar o software interno das suas máquinas. Na arquitetura de Infraestrutura como Serviço (IaaS), vigora o modelo de responsabilidade partilhada: o datacenter garante a redundância elétrica, a refrigeração, a integridade física dos discos NVMe e o encaminhamento nos routers de borda. Tudo o que corre do sistema operativo Linux para cima, incluindo a versão do PHP, o fecho de portas no nftables e a proteção das chaves de API, é da tua exclusiva responsabilidade.

A cronologia técnica do incidente na Hetzner ilustra a velocidade com que tens de reagir quando uma vulnerabilidade CVSS 9.2 se torna pública:

• 21 de outubro de 2026, 11:04 UTC: Registo formal do incidente de segurança referente às falhas críticas CVE-2026-109618 e CVE-2026-109619 no ecossistema PHP.
• 21 de outubro de 2026, 14:34 UTC: A equipa de engenharia de plataforma da Hetzner aplica mitigações nos seus sistemas geridos internos (konsoleH, Storage Share, phpMyAdmin e Webmail) seguindo as mitigações provisórias oficiais da equipa do PHP.
• 21 de outubro de 2026, 17:50 UTC: Disponibilização e compilação dos pacotes corrigidos para os ramos modernos do PHP (7.4 e 8.0 até 8.5).
• 22 de outubro de 2026, 04:32 UTC: Conclusão do backporting de segurança de emergência para sistemas legados em PHP 5.6 e 7.3 nos alojamentos partilhados geridos.

Nos teus servidores dedicados e VPS (Virtual Private Servers), nenhum destes patches é aplicado por magia. Se não tiveres rotinas de atualização de segurança automatizadas e monitorização ativa de processos, o teu servidor permanece vulnerável indefinidamente.

6. Playbooks de Especialização e Implementação no Terreno (Topic Cluster de Blindagem)

A resposta ao alerta da CISA, NSA e FBI não termina no fecho perimetral da porta 9000 e da porta 22. Para construíres uma infraestrutura com resiliência de nível militar, desenhei doze playbooks técnicos de especialização direta no terreno, organizados por camadas de arquitetura:

Painéis de Gestão, Isolamento e Acesso Zero-Trust

• cPanel, Plesk e Servidores Linux: Mitigar PHP2Shell e Portas: Como reconfigurar pools FPM, migrar de portas TCP locais para sockets Unix e bloquear portas administrativas públicas (2083, 8443, 8090, 8083).
• HestiaCP: Isolamento SSH com Jailkit e SFTP Seguro: Confinamento em chroot hermético para impedir que developers e aplicações leiam ficheiros fora da sua raiz.
• SSH Zero-Trust: Certificados Efémeros com step-ca: Eliminação definitiva de chaves públicas estáticas no disco através de certificados OpenSSH temporários de 12 horas emitidos via OIDC.

Cadeia de Fornecimento, CI/CD e Auditoria Autónoma

• Ataque Supply Chain LiteLLM: PyPI, GhostAction e Fuga AWS: Protocolo forense para expurgar ficheiros .pth envenenados, auditar imagens Docker e rodar credenciais de cloud comprometidas.
• Cadeia de Contentores: Trivy, SBOM e Cosign: Geração de inventários de componentes (Syft), análise de vulnerabilidades em CI/CD e assinatura criptográfica sem chaves estáticas.
• Agentes de Auditoria de Segurança: Arquitetura Caçador e Verificador: Como desenhar agentes adversariais com sandboxing hermético em MicroVMs para auditar código sem falsos positivos.
• Wazuh SIEM no Linux: FIM e Resposta Ativa Automática: Deteção contínua de alterações de integridade de ficheiros (FIM) e isolamento imediato de processos maliciosos.

Performance Aplicacional, Redes e Computação Bare-Metal

• Redis 8: Sockets Unix, ACLs e Tuning de Memória: Redução de latência de cache em até 45% com eliminação da sobrecarga da pilha TCP de loopback e ACLs granulares.
• PHP 8.4: Tuning de OPcache Preloading e Tracing JIT: Maximização do débito de execução e pré-carregamento determinista de código compilado em RAM.
• Bifurcação PCIe e SR-IOV: Rede e NVMe à Velocidade Real: Eliminação da sobrecarga de pontes de rede em software e suporte a múltiplos NVMe em slots x16 no Proxmox.
• CSP strict-dynamic: Injeção de Nonce na Edge: Proteção do frontend contra injeções XSS através de nonces criptográficos calculados na borda.
• Correr Modelos de IA Locais: Ollama, vLLM e Servidores Privados com GPU: Execução hermética de LLMs em nós dedicados com zero partilha de segredos empresariais.

7. Checklist Executiva de Validação Perimetral

Antes de dares a tua infraestrutura por segura hoje, valida cada um destes cinco pontos no teu ambiente de produção:

1. Verificação da Versão Exata do Binário PHP: Corre php -v e confirma que estás num build corrigido (>= 8.2.35, >= 8.3.36, >= 8.4.27 ou >= 8.5.12). Verifica também a versão do processo php-fpm em execução para garantir que o serviço foi efetivamente reiniciado após o apt upgrade.
2. Eliminação de Portas Internas na Interface Pública: Confirma com sudo ss -tulpn e através de um scan externo (usando nmap -Pn -p- a partir de uma máquina fora da tua rede) que apenas as portas 80 e 443 respondem ao público.
3. Comunicação Exclusiva via Sockets UNIX: Certifica-te de que a porta 9000 desapareceu da tabela de rede e que o Nginx/Caddy comunica com o PHP-FPM exclusivamente através de ficheiros .sock em /run/php/.
4. Isolamento do Motor Node.js: Garante que nenhum processo Node corre com --inspect em produção e que todos os serviços HTTP internos escutam apenas em 127.0.0.1.
5. Auditoria de Logs e Processos Suspeitos: Analisa os ficheiros /var/log/nginx/access.log e journalctl -u php*-fpm das últimas 72 horas à procura de picos anómalos de pedidos POST multipart ou processos filhos desconhecidos (como /bin/sh, curl ou python) gerados pelo utilizador www-data.

Construir software rápido e resiliente exige disciplina diária na forma como proteges a base onde esse código corre. No Webxtek Studio, assumimos essa exigência técnica para que te possas focar no crescimento da tua operação sem sobressaltos. Através de consultoria técnica especializada, infraestruturas blindadas de alojamento gerido e engenharia de websites de alta performance, ajudamos a tua empresa a transformar a segurança e a velocidade da tua arquitetura numa vantagem competitiva real.