/

CVE-2026-57572

Severity:

CRITICAL RISK

(10.0)

Command Injection (CWE-88) in Crawl4AI Docker API

CVE-2026-57572

Analyzed

Vulnerability type

Category:

Command Injection

CWE:

CWE-88, CWE-94

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(10.0)

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

Crawl4AI's Docker API previously passed user-supplied extra browser arguments directly into Chromium's launch command without restriction, enabling crafted switches to alter child-process execution.

Because the Docker API was unauthenticated by default, a single network request could result in arbitrary command execution as the container's runtime user.

Affected context

This vulnerability occurs in deployments of Crawl4AI that expose the Docker API server and use it to launch Chromium-based crawling jobs.

The issue manifests when request parameters, specifically browser_config.extra_args, are treated as trusted and appended to Chromium's command-line without validation or sanitization.

Environments where the Docker API is reachable over a network, especially when left unauthenticated or reachable from untrusted segments, are at heightened risk because they expand the attack surface to arbitrary remote clients.

Exploit preconditions

  • Attack surface: Network-exposed Crawl4AI Docker API endpoint that accepts crawl configuration requests.
  • Required access: Ability to send HTTP requests to the Docker API; no authentication required in the default configuration.
  • Trigger point: Submission of a request containing malicious browser_config.extra_args that introduces Chromium switches such as --no-zygote and overrides child-process launch commands.
  • Why exploitation is possible: The application concatenates request-controlled arguments directly into Chromium's launch configuration, allowing attackers to inject flags that cause Chromium to fork or exec arbitrary commands under the container's runtime user without any command validation or execution policy.

Why this happens

The underlying bug stems from treating user-controlled configuration parameters as safe to embed directly in a process launch command, mapping to CWE-88: Argument Injection or Modification.

Crawl4AI's Docker API allowed browser_config.extra_args from requests to flow unfiltered into Chromium's command-line, which includes powerful switches capable of changing how child processes are spawned.

By combining these switches with flags such as --no-zygote, attackers can coerce Chromium into executing arbitrary binaries or shell commands, effectively turning configuration input into execution control.

At a broader level, this reflects a pattern where runtime options and process arguments are constructed from untrusted data without validating allowable values, restricting dangerous switches, or isolating configuration from execution semantics.

Potential impact

  • Remote execution of arbitrary commands within the container as the runtime user.
  • Complete compromise of the crawler container, including access to any data, environment variables, and mounted volumes it can reach.
  • Use of the compromised container as a pivot point for further attacks against connected services, networks, or backing data stores.
  • Deployment of malicious tooling (e.g., cryptominers, backdoors, scanners) from within the affected environment.
  • Disruption or poisoning of crawling workflows, including exfiltration or manipulation of scraped data.

General mitigation guidance

Effective mitigation focuses on preventing untrusted inputs from controlling process launch behavior and constraining execution capabilities.

Common defensive patterns include:

  • Treating all remote configuration fields as untrusted and enforcing strict allowlists for command-line options, disallowing any switches that alter process execution or spawn arbitrary commands.
  • Decoupling user-facing configuration from low-level browser or engine flags, exposing only high-level, pre-vetted options instead of raw argument injection.
  • Normalizing and validating configuration structures before they reach process-launch code, rejecting unknown or malformed values rather than passing them through.
  • Running browser and crawler processes under least-privilege accounts with minimized filesystem and network access, reducing the blast radius if a process is abused.
  • Applying network-level controls to restrict access to management APIs such as the Docker API server, including authentication, authorization, and segmentation from untrusted clients.
  • Favoring secure-by-default API designs that avoid hidden power features in configuration fields, making dangerous behaviors opt-in and guarded by strong controls.

How teams detect issues like this

Detection efforts can focus on both code-level signals and runtime behavior patterns.

At the code level:

  • Use static analysis rules to flag process-launch code that interpolates request parameters, environment variables, or configuration fields directly into command-line arguments.
  • During code review, pay attention to any API endpoints that accept "extra args" or "flags" and trace how those values propagate to execution APIs such as exec, process builders, or browser-launch utilities.
  • Define secure coding policies that ban direct inclusion of untrusted strings into command-lines and enforce strict argument validation, using automated linters or CI checks to enforce these policies.

At runtime:

  • Monitor Docker logs and application logs for unusual Chromium launch patterns, including presence of rarely used switches like --no-zygote or unexpected binary paths in child processes.
  • Implement anomaly detection around container behavior, including sudden command executions unrelated to normal crawling activity or unexpected outbound network connections.
  • Use container security tools to detect unusual process trees, privilege escalations, and deviations from a baseline profile of expected Chromium invocation commands.

Sources

SourceLink
github.comgithub.com/unclecode/crawl4ai/commit/60886d1a0c52682e4c83a7cef9dfac417fff6bd2
github.comgithub.com/unclecode/crawl4ai/security/advisories/GHSA-r253-r9jw-qg44

Frequently asked

questions

The vulnerability is broadly exploitable in any environment where the Crawl4AI Docker API is reachable from an attacker, because the API was unauthenticated by default and allowed direct control over Chromium's launch arguments. A single crafted request could result in remote code execution without prior access to the container.

An attacker only needs network access to the Docker API endpoint. No valid credentials or prior foothold inside the system are required in the default configuration, making this a high-impact remote attack vector.

The most robust fix pattern is to eliminate the ability for user-supplied data to directly modify process launch commands. Restrict configuration fields to predefined, validated options, enforce strict allowlists for browser arguments, and ensure that any execution-related switches cannot be influenced by external requests.

Future prevention should combine design and implementation safeguards: avoid exposing raw argument or flag injection in APIs, validate and normalize all configuration inputs, apply least-privilege principles to runtime accounts, and enforce security reviews around any code that builds or executes commands. Complement these practices with automated checks in CI and regular review of management endpoints to ensure they are authenticated, authorized, and properly segmented from untrusted networks.

Find out what's already
exploitable in your codebase.