/

CVE-2026-53755

Severity:

HIGH RISK

(8.6)

SSRF via Proxy Configuration (CWE-918) in Crawl4AI

CVE-2026-53755

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Metadata Exposure

Severity:

HIGH RISK

(8.6)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A server-side request forgery (SSRF) flaw in Crawl4AI's Docker API allows attackers to abuse proxy configuration fields to route Chromium traffic to internal services and cloud-metadata endpoints.

Because only the crawl target URL was validated and the Docker API was unauthenticated by default, a crafted request with a benign crawl URL but malicious proxy settings could expose otherwise unreachable internal resources.

Affected context

This vulnerability appears in Crawl4AI deployments that expose the Docker API server and allow browser or crawler configuration to influence Chromium's outbound network traffic. It manifests when SSRF protections focus solely on the main crawl target URL but do not validate or restrict proxy-related parameters, resolver rules, or extra browser flags. In practice, it becomes relevant wherever the Docker API endpoints are reachable without strong authentication and can configure the underlying headless browser's egress behavior.

Exploit preconditions

  • Attack surface: HTTP requests to the Docker API endpoints such as /crawl, /crawl/stream, and /crawl/job.
  • Required access: Network reachability to the Docker API server; in default setups, no authentication is required.
  • Trigger point: Submission of a browser_config and/or crawler_config that sets proxy fields (e.g., proxy_config.server, deprecated proxy, or extra_args flags like --proxy-server, --proxy-pac-url, --proxy-bypass-list, --host-resolver-rules).
  • Why exploitation is possible: The SSRF destination check was applied only to the primary crawl target URL and did not inspect proxy settings or resolver rules, allowing the browser to connect to internal IPs and sensitive metadata services while still presenting a valid external crawl URL.

Why this happens

The underlying issue is incomplete validation of outbound request destinations in a system that programmatically controls a headless browser's network configuration. Crawl4AI enforced SSRF checks on the crawl target URL but treated proxy and host resolution parameters as trusted configuration, leaving them outside the protection logic. This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server component can be coerced into issuing arbitrary network requests because not all egress-controlling inputs (such as proxy servers and resolver rules) are vetted or constrained.

Potential impact

  • May allow access to internal HTTP services and APIs that are not directly exposed to the internet.
  • Could enable retrieval of cloud provider metadata, potentially leaking credentials or instance configuration.
  • Can facilitate network reconnaissance inside private infrastructure (port scanning, service probing via HTTP).
  • May be combined with other weaknesses on internal services to escalate privileges or obtain sensitive data.

General mitigation guidance

Mitigation revolves around treating all egress-controlling inputs as untrusted and applying consistent destination validation across them. Common defensive patterns include:

  • Applying SSRF checks not only to the primary target URL but also to proxy settings, PAC URLs, bypass lists, host resolver rules, and other fields that influence network routing.
  • Restricting where the browser can connect by enforcing allowlists of domains or networks and denying access to link-local and metadata endpoints.
  • Minimizing the configurability of proxy and resolver options for untrusted clients, and separating trusted administrative configuration from user-supplied crawl parameters.
  • Running browser and crawler components with least-privilege network access, segmented away from sensitive internal services and metadata endpoints.

How teams detect issues like this

Detection typically focuses on identifying unvalidated network-routing inputs and observing abnormal egress behavior. Useful approaches include:

  • Static analysis or configuration linting that flags usages where user-controlled fields (proxy settings, resolver rules, extra browser flags) are passed directly to network clients or browsers without destination checks.
  • Code review practices that look for SSRF protections limited to single URL parameters instead of generalized egress validation, along with attention to any "extra_args" or proxy configuration hooks.
  • Runtime monitoring of outbound traffic from crawler containers, watching for connections to internal IP ranges, link-local addresses, and known cloud metadata endpoints.
  • Policy enforcement through API gateways or service meshes that constrain which hosts crawler services can reach, complemented by automated security testing that attempts to abuse proxy-related parameters.

Sources

SourceLink
github.comgithub.com/unclecode/crawl4ai/security/advisories/GHSA-6qhc-x826-342c

Frequently asked

questions

Yes, it is remotely exploitable wherever the Crawl4AI Docker API is network-accessible. Exploitation allows the attacker to drive Chromium to make outbound requests to internal services and metadata endpoints, but the scope is limited to what the crawler container can reach on the network.

An attacker needs only network access to the Docker API server. In typical default configurations, no authentication is required, so any party that can send requests to /crawl, /crawl/stream, or /crawl/job can attempt exploitation.

The safest pattern is to centralize egress control and validate all destinations regardless of how they are specified—URL, proxy server, PAC script, bypass list, or resolver rules—while disallowing access to internal and metadata networks. Reducing or removing user control over proxy and resolution parameters further lowers the risk.

Future designs should treat all network path and routing inputs as untrusted, implement allowlist-based outbound filtering, isolate crawler components from sensitive networks, and embed security reviews and automated checks that specifically examine proxy and extra-argument handling in HTTP clients and browser automation frameworks.

Find out what's already
exploitable in your codebase.