CVE-2025-66478 - O assassino de RCE silencioso nas ações do servidor Next.js

Resumo

A divulgação de CVE-2025-66478 em dezembro de 2025 representa um ponto de inflexão crítico para a segurança moderna de aplicativos da Web. À medida que estruturas como o Next.js diluem a fronteira entre cliente e servidor usando Ações do servidorAlém disso, elas introduzem novas superfícies de ataque que os modelos de segurança tradicionais não conseguem resolver. Essa vulnerabilidade não é uma simples falha de injeção; é um bug lógico sofisticado decorrente de uma desserialização insegura que permite Protótipo de poluiçãoque pode ser escalado para Execução remota de código (RCE) em condições específicas.

Este guia definitivo vai além dos avisos básicos. Vamos dissecar a vulnerabilidade no nível do tempo de execução do JavaScript, analisar os padrões exatos de código que criam o risco, explicar por que as defesas de perímetro, como os WAFs, são ineficazes e demonstrar como a validação com reconhecimento de contexto orientada por IA, pioneira na PenligenteA segurança de um novo paradigma é necessária.

A nova fronteira: ações do servidor e riscos de serialização

Ações do servidor Next.js ('usar servidor') revolucionaram o desenvolvimento full-stack, permitindo que os desenvolvedores invoquem funções do lado do servidor diretamente dos componentes do lado do cliente. Essa experiência perfeita é alimentada por mecanismos de serialização complexos e subjacentes que agrupam dados - formulários, objetos e fechamentos - através do limite da rede.

No entanto, a conveniência muitas vezes vem à custa da segurança. O CVE-2025-66478 expõe uma falha fundamental na forma como o Next.js tratou a entrada não confiável durante esse processo de hidratação. A estrutura confiava implicitamente na estrutura dos objetos de entrada, permitindo que os invasores manipulassem as propriedades básicas do objeto JavaScript.

Anatomia da falha: Da poluição do protótipo à RCE

Em sua essência, o CVE-2025-66478 é um Protótipo de poluição vulnerabilidade ativada durante a vinculação dos dados da solicitação aos argumentos da ação do servidor.

O mecanismo: Mesclagem recursiva insegura

A natureza dinâmica do JavaScript permite que os objetos herdem propriedades de seu protótipo. O protótipo raiz é Objeto.protótipo. Se um invasor puder modificar esse protótipo raiz, todos os objetos da instância do aplicativo em execução herdarão essa modificação.

A vulnerabilidade surge quando uma Server Action aceita estruturas de dados complexas (como JSON aninhado ou Dados do formulário) e a estrutura - ou o código do desenvolvedor dentro da ação - executa uma mesclagem ou atribuição recursiva insegura.

O vetor de ataque:

Um invasor envia uma carga útil criada para percorrer a cadeia de protótipos de objetos usando chaves de propriedade especiais, como proto, construtor ou protótipo.

JSON

// Carga útil de ataque conceitual enviada para uma ação de servidor {"userUpdate": { "__proto__": { "isAdmin": true, "execPath": "/bin/sh" // Gadget para possível RCE } } }

Se a lógica do lado do servidor mesclar ingenuamente esse userUpdate em um objeto de usuário ou bloco de configuração existente, o objeto __proto__ é interpretada não como um campo de dados, mas como uma instrução para modificar o protótipo do objeto de destino.

Escalonamento: A cadeia de gadgets de RCE

A poluição por protótipos raramente é o objetivo final; ela é o facilitador. Para um engenheiro de segurança hardcore, a questão crítica é: "Como faço para transformar a poluição em execução?"

Para isso, é necessário encontrar um "Gadget", um trecho de código legítimo dentro do aplicativo ou de suas dependências que usa uma propriedade predefinida de forma perigosa. Ao poluir essa propriedade globalmente, o invasor controla o comportamento do gadget.

Exemplo de cenário de RCE no Node.js:

Considere um processo backend que ocasionalmente gera processos filhos usando child_process.spawn() ou utilitários semelhantes. Geralmente, esses utilitários aceitam um objeto de opções, que pode procurar propriedades como shell, env ou execPath.

1. Poluição: O invasor usa o CVE-2025-66478 em uma ação do servidor para poluir Object.prototype.shell com um valor como /bin/sh ou cmd.exe.
2. Gatilho: Mais tarde, em outro lugar do aplicativo, uma função completamente não relacionada chama gerar('ls', ['-la'], {}).
3. Execução: Como o objeto de opções {} herda do protótipo poluído, desova vê { shell: '/bin/sh' }. O comando agora é executado dentro de um shell, o que permite a injeção de comandos por meio dos argumentos.

Esse caminho de escalonamento destaca por que o CVE-2025-66478 é classificado como crítico. Ele transforma um erro de manipulação de dados em um comprometimento total do servidor.

O dilema do desenvolvedor: padrões de código vulneráveis vs. seguros

Para identificar essa vulnerabilidade, é necessário procurar por "códigos de identificação" específicos, em que a entrada do usuário é confiável de forma muito implícita em operações de objetos.

O antipadrão (código vulnerável)

O erro mais comum é a conversão direta de Dados do formulário ou JSON não validado em um objeto e passá-lo para funções que realizam mesclagens profundas ou operações de banco de dados que dependem da estrutura do objeto.

JavaScript

`// app/actions/user.js 'use server'

import { db } from '@/lib/db'; // Um utilitário genérico e inseguro de mesclagem profunda frequentemente encontrado em bases de código import { deepMerge } from '@/utils/genericHelpers';

export async function updateProfileSettings(formData) { // PERIGO: conversão de FormData não confiável diretamente em um objeto const rawInput = Object.fromEntries(formData);

// Suponha que getCurrentConfig() retorne um objeto de configuração básica.
const currentConfig = await db.config.findFirst();

// GATILHO DA VULNERABILIDADE:
// Se o deepMerge não bloquear explicitamente o __proto__,
// um invasor pode poluir o tipo de objeto de configuração base.
const newConfig = deepMerge({}, currentConfig, rawInput);

// A configuração poluída é salva ou usada de maneiras perigosas
await db.user.update({
    where: { id: rawInput.userId },
    data: { settings: newConfig }
});

}`

O Padrão Seguro (O Escudo de Zod)

A única defesa robusta contra ataques de atribuição em massa e poluição de protótipos é Validação rigorosa e baseada em esquema. Bibliotecas como Zod atuam como um firewall para a lógica do aplicativo, criando uma lista branca de propriedades permitidas e eliminando todo o resto.

JavaScript

`// app/actions/user.js 'use server'

import { z } from 'zod'; import { db } from '@/lib/db';

// DEFENSE: Defina um esquema rígido. Somente essas chaves serão aprovadas. // Qualquer 'proto' ou chaves desconhecidas são automaticamente removidas. const ProfileSettingsSchema = z.object({ userId: z.string().uuid(), theme: z.enum(['light', 'dark', 'system']), notificationsEnabled: z.boolean(), metadata: z.object({ bio: z.string().max(280).optional(), website: z.string().url().optional() }).strict() // .strict() proíbe chaves desconhecidas em objetos aninhados });

export async function updateProfileSettings(formData) { // ETAPA 1: analisar e validar // safeParse retorna um objeto limpo e tipado, se bem-sucedido, ou erros. const parseResult = ProfileSettingsSchema.safeParse( Object.fromEntries(formData) );

se (!parseResult.success) {
    // Tratar graciosamente a entrada incorreta sem expor as estruturas internas
    console.error('Validação falhou:', parseResult.error);
    lançar novo erro('Dados de solicitação inválidos');
}

// ETAPA 2: usar os dados higienizados
// É garantido que o parseResult.data contenha SOMENTE as chaves definidas.
await db.user.update({
    where: { id: parseResult.data.userId },
    data: {
        theme: parseResult.data.theme,
        notifications: parseResult.data.notificationsEnabled,
        metadata: parseResult.data.metadata
    }
});

}`

Por que as camadas de segurança tradicionais falham

Muitas organizações acreditam erroneamente que suas defesas de perímetro existentes detectarão o CVE-2025-66478. Essa suposição é perigosa.

Cegueira WAF e o protocolo de voo

Os Web Application Firewalls (WAFs) geralmente operam com correspondência regex em relação a elementos HTTP padrão, como parâmetros de URL e corpos JSON, procurando por SQLi (' OU 1=1) ou XSS (<script>) assinaturas.

As ações do servidor Next.js, no entanto, se comunicam usando o Protocolo de voo-um híbrido complexo e de fluxo contínuo de texto e dados binários. Uma carga útil mal-intencionada pode estar profundamente aninhada em uma solicitação multipart/form-data ou ser serializada de forma a ocultar o __proto__ a partir da correspondência simples de strings. Os WAFs que não entendem especificamente o formato de serialização Next.js verão o tráfego benigno.

A lacuna semântica

Além disso, uma carga útil como {"constructor": {"prototype": {"isAdmin": true}}} é um JSON sintaticamente válido. Um WAF não pode determinar se essa é uma solicitação legítima projetada para atualizar um objeto de configuração complexo ou um ataque. Isso requer compreensão semântica da lógica do aplicativo, que os perímetros não possuem.

Validação avançada: A abordagem orientada por IA com a Penligent

Dadas as limitações da auditoria manual e das ferramentas tradicionais, é necessária uma nova abordagem. Penligente utiliza um mecanismo de teste de penetração orientado por IA projetado para entender o contexto do aplicativo.

Além da análise estática: Fuzzing com reconhecimento de contexto

As ferramentas tradicionais de teste estático de segurança de aplicativos (SAST) têm dificuldade em lidar com a natureza dinâmica do JavaScript e, com frequência, sinalizam muitos falsos positivos ou deixam passar fluxos de dados complexos entre os limites do Server Action.

O mecanismo de IA da Penligent analisa a Árvore de Sintaxe Abstrata (AST) do aplicativo para identificar:

1. Fontes: Funções marcadas com 'usar servidor'.
2. Pias: Operações perigosas, como mesclagem de objetos, gravações no banco de dados ou execução de comandos.
3. Fluxo de dados: O caminho que a entrada não confiável percorre da origem ao coletor.

Ao compreender esse contexto, a Penligent gera cargas úteis de fuzzing direcionadas, projetadas especificamente para testar a poluição de protótipos nos caminhos de dados identificados.

Prova de conceito não destrutiva (Safe PoC)

É fundamental comprovar a existência de uma vulnerabilidade sem interromper a produção. A Penligent emprega uma metodologia de "PoC seguro".

Em vez de tentar RCE ou interromper o estado do aplicativo, o agente Penligent tenta poluir uma propriedade benigna e temporária.

• Ação: O agente envia uma carga útil para uma Ação do servidor: {"__proto__": {"penligent_validation_flag_{unique_id}": true}}.
• Verificação: Em seguida, o agente faz uma solicitação subsequente a um endpoint diferente e verifica se esse sinalizador globalmente poluído aparece nos dados de resposta.
• Resultado: Se o sinalizador estiver presente, a vulnerabilidade é confirmada com certeza 100% e impacto zero nos negócios.

Penligent Insight: "Na arquitetura moderna da Web, a segurança deve passar do bloqueio em nível de rede para a validação lógica em nível de aplicativo. A IA é a única maneira escalável de preencher essa lacuna."

A lista de verificação definitiva de remediação

Para as equipes de DevSecOps e arquitetos, é necessária uma ação imediata para proteger os ambientes Next.js.

1. Patch Imediatamente: Atualize todas as instâncias do Next.js para v15.0.4+ ou v14.2.16+. Os patches oficiais contêm proteções em nível de estrutura contra determinados tipos de envenenamento de propriedades durante a serialização.
2. Impor a validação do esquema: Adotar uma política que todos A ação do servidor deve começar com uma validação rigorosa de entrada usando Zod, Yup ou Valibot. Trate a entrada não validada como uma violação crítica de segurança nas revisões de código.
3. Codificação defensiva:
   • Evite usar funções genéricas de "mesclagem profunda" na entrada do usuário.
   • Prefira criar novos objetos com propriedades explícitas em vez de mesclá-los: const newData = { prop1: input.prop1, prop2: input.prop2 };
   • Considere o uso de Object.create(null) para os objetos que conterão a entrada do usuário para garantir que não tenham protótipo.
4. Fortalecimento do tempo de execução (a opção nuclear): Como última linha de defesa, você pode congelar o protótipo do objeto na inicialização do aplicativo. Observe que isso pode quebrar bibliotecas de terceiros que dependem da modificação de protótipos.JavaScript // Em seu instrumentation.js ou layout raiz if (process.env.NODE_ENV === 'production') { Object.freeze(Object.prototype); Object.freeze(Array.prototype); }

Referências e links de autoridade:

• Aviso oficial de segurança do Next.js: CVE-2025-66478
• Entrada no banco de dados nacional de vulnerabilidades (NVD) do NIST
• Guia da OWASP para prevenção da poluição de protótipos
• Entendendo o roteador de aplicativos Next.js e as ações do servidor
• Pesquisa PortSwigger: Poluição de protótipo do lado do servidor