Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain network-path or DNS-control position
-
DeliveryCrawler directed to HTTPS target
-
ExploitPresent forged/self-signed TLS certificate
-
ExecutionChromium accepts (--ignore-certificate-errors)
-
PersistInject forged content and capture cookies/headers
-
ImpactPoison downstream LLM/RAG pipeline
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A07:2025 - Authentication Failures
ASVS 5.0
V12 - Secure Communication Certificate validation
|
| Exploitation Conditions | Exploitation requires the attacker to control the network path (man-in-the-middle) or DNS resolution for a host the crawler is directed to fetch, and to induce or wait for the server to crawl that attacker-influenced HTTPS host. All Docker deployments are affected in their default setup even though the API server reports TLS verification as enabled (when CRAWL4AI_ALLOW_INSECURE_TLS is not set), because the hard-coded --ignore-certificate-errors launch flag overrides the ignore_https_errors=False context option; library users who explicitly set ignore_https_errors=False are likewise unprotected. The /crawl and /crawl/stream endpoints build the browser from the request body, so config.yml-based flag stripping never reaches them. A separate consequence: operators who set CRAWL4AI_CHROMIUM_SANDBOX=true still run Chromium with --no-sandbox (renderer sandbox disabled), though no code execution or container escape is demonstrated. Limiting factors: the required MITM/DNS position (CVSS AC:H/AT:P), affected versions <= 0.9.4 (fixed in 0.9.5), and the fact that the Docker /crawl endpoint itself requires a valid API bearer token. The only stated workaround is incomplete - keep the crawler on a trusted network path and DNS resolver; updating to 0.9.5 is the complete fix. |
| Impact | This is a genuine but conditional risk rather than a mass-exploitable critical flaw. The CVSS 4.0 vector (AV:N/AC:H/AT:P/PR:N/UI:N) scores 8.3 High, but the AC:H and AT:P metrics reflect the key gating condition: the attacker must hold a privileged position - on the network path (man-in-the-middle) or in control of DNS for a host the crawler is directed to visit. Without that position the flaw cannot be triggered, so this is not a remote spray-and-pray vulnerability despite PR:N. Impact is skewed toward integrity (VC:L/VI:H): the attacker mainly injects forged content that then feeds downstream LLM/RAG pipelines, with lesser confidentiality exposure of cookies and headers the crawl sends. Signals are consistent but modest: not listed in CISA KEV, no EPSS score provided in the input, and the vuln.today decision label is 'this_week' (not act_now/emergency). A proof-of-concept walkthrough exists in the GHSA advisory. The notable dissonance is operator expectation versus reality - the Docker API server reports TLS verification as ON while every launched Chromium silently runs with --ignore-certificate-errors - which raises practical risk because defenders may wrongly believe they are protected. Net: a real priority to patch this week for anyone crawling over untrusted network paths, but not an emergency given the required attacker positioning and absence of KEV/active-exploitation signals. |
| Exploit ScenarioDerived | An attacker who sits on the network path or controls DNS for a host the Crawl4AI server is asked to crawl presents a forged or self-signed TLS certificate; because Chromium is always launched with --ignore-certificate-errors, the crawler accepts it, returns attacker-controlled content that flows into LLM/RAG pipelines, and exposes the cookies and headers the crawl sends. A proof-of-concept exists in the GHSA advisory, crawling a self-signed HTTPS origin that a normal client rejects. The CVSS AC:H/AT:P reflects that the attacker must first achieve this man-in-the-middle or DNS-control position, which bounds realistic exploitation. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 29, 2026
Crawl4AI through 0.9.4 launches every locally managed Chromium instance with hard-coded --ignore-certificate-errors (and --ignore-certificate-errors-spki-list), so crawls silently accept forged TLS certificates; an attacker who controls the network path or DNS for a crawled host can substitute page content that feeds downstream LLM/RAG pipelines and observe the request data, cookies and headers the crawl sends. The same hard-coded flag list forces --no-sandbox, so operators who set CRAWL4AI_CHROMIUM_SANDBOX=true still run Chromium without the renderer sandbox. All Docker deployments are affected in their default configuration and library users who set ignore_https_errors=False are equally unprotected, despite the API server reporting TLS verification as on; CVSS 4.0 scores this 8.3 with AC:H/AT:P reflecting the required man-in-the-middle position, and the CVSS 3.1 assessment is AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N. No active exploitation is confirmed (not in CISA KEV), but the GitHub advisory publishes a step-by-step proof-of-concept reproduction on a default 0.9.4 Docker image; the fixed release is 0.9.5.
RemediationAI
Upgrade to Crawl4AI 0.9.5, which is the complete fix: --ignore-certificate-errors and --ignore-certificate-errors-spki-list are removed from both default launch flag lists, insecure TLS becomes controlled solely by the ignore_https_errors context option (added only by the CDP-managed subprocess when it is True), CRAWL4AI_CHROMIUM_SANDBOX=true now reaches every browser including those built from a request body by removing --no-sandbox and passing chromium_sandbox=True to Playwright, and the posture test now checks the real launch flags with new tests crawling a self-signed origin across all three launch paths. Operators should verify the deployed image tag actually corresponds to 0.9.5 rather than only pinning the pip package, since the advisory reproduces the issue against the 0.9.4 Docker image with default settings. No complete workaround exists: setting ignore_https_errors=False through the context option has no effect because the launch flag overrides it, stripping flags from BrowserConfig.extra_args or config.yml does not reach the hard-coded copies or the /crawl and /crawl/stream request-body paths, and CRAWL4AI_ALLOW_INSECURE_TLS only documents intent rather than changing behaviour. The only stated mitigation, which is partial, is to keep the crawler on a trusted network path and DNS resolver - the trade-off is that this constrains where the crawler may be pointed and does not help when the crawled host itself is attacker-influenced. See the GitHub advisory at https://github.com/unclecode/crawl4ai/security/advisories/GHSA-j2qh-f73r-mg3q for the vendor's fix notes.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Crawl4AI is a Python crawling framework (pip package crawl4ai, CPE cpe:2.3:a:unclecode:crawl4ai) that drives Chromium through Playwright and exposes a Docker API server on port 11235. The root cause is CWE-295 (improper certificate validation) combined with CWE-1188 (insecure default). BrowserManager._build_browser_args() and ManagedBrowser.build_browser_flags() in crawl4ai/browser_manager.py unconditionally append --no-sandbox, --ignore-certificate-errors and --ignore-certificate-errors-spki-list to every local Chromium launch. The design intends TLS verification to be opt-out: enforce_egress() in deploy/docker/egress_broker.py sets the Playwright context option ignore_https_errors=False and strips TLS-weakening flags from BrowserConfig.extra_args, but because a launch-level flag applies to the entire browser and the hard-coded flags are appended later at launch time, the context option is inert. The sandbox path is similarly broken: _browser_extra_args() in deploy/docker/server.py removes --no-sandbox only from config.yml-derived flags, Playwright adds its own when chromium_sandbox is unset, and the /crawl and /crawl/stream endpoints construct their browser from the request body so config.yml flags never reach them. The vendor's own posture test (test_security_default_posture.py) inspected config.yml rather than the real launch flags and therefore missed the divergence between documented and actual browser behaviour. The fix moves insecure mode to the ignore_https_errors context option (only the CDP-managed subprocess, whose default context accepts no such option, adds the flag, and only when ignore_https_errors is True), propagates chromium_sandbox=True to every launch path, and rewrites the posture test to assert the real launch flags with new tests crawling a self-signed origin across all three launch paths.
Know when Crawl4ai gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:H/AT:P/PR:N/UI:N/VC:L/VI:H/VA:N/SC:N/SI:N/SA:N
AC:H because the attacker must first achieve a man-in-the-middle or DNS-control position; PR:N/UI:N as the victim needs no auth or interaction; C:L for exposed cookies/headers, I:H for forged content, A:N, S:U since no sandbox escape is shown.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
2DescriptionCVE.org
Crawl4AI before 0.9.5 contains an improper certificate validation vulnerability that allows network attackers to intercept crawls because Chromium always launches with --ignore-certificate-errors. Man-in-the-middle or DNS-controlling attackers can serve forged content to the crawler and read cookies and headers sent, while hard-coded --no-sandbox also overrides CRAWL4AI_CHROMIUM_SANDBOX.
Articles & Coverage 1
Technical POC Analysis
CWE-295 (Improper Certificate Validation), with a secondary CWE-1188 (insecure default) flavor: the product does not merely mis-validate one certificate, it globally disables validation at browser la…
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Crawl4AI, a web crawling library used in AI/LLM data pipelines, through version 0.9.4 silently disables TLS certificate verification and the Chromium sandbox in all default deployments, including Docker. This means any network attacker who can intercept traffic (e.g., via DNS spoofing or rogue Wi-Fi) can inject forged content into LLM/RAG outputs and steal crawl headers and cookies. Leadership should care because poisoned AI training or retrieval data can corrupt business decisions, and the absence of a patch leaves every default Crawl4AI deployment exposed.
No vendor-released patch identified at time of analysis. Interim mitigations: manually patch Chromium launch flags to remove --ignore-certificate-errors and --no-sandbox; enforce strict network egress filtering and trusted DNS; disable crawling of untrusted sites until patched; monitor for anomalous crawl content changes.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Remote code execution in Crawl4AI Docker API before 0.8.0 via hooks parameter. The /crawl endpoint accepts Python code i
Authentication bypass in Crawl4AI Docker API server (versions prior to 0.8.7) allows remote unauthenticated attackers to
Arbitrary local file disclosure in Crawl4AI's Docker API (versions before 0.8.0) lets unauthenticated remote attackers r
Remote code execution in Crawl4AI's Docker API server (versions prior to 0.9.0) lets unauthenticated attackers run arbit
Arbitrary file write in Crawl4AI (the open-source LLM-friendly web crawler by unclecode) before version 0.9.0 lets a mal
Arbitrary file write in Crawl4AI Docker API server before 0.8.8 lets unauthenticated remote attackers escape the ALLOWED
Arbitrary JavaScript execution in Crawl4AI's Docker API server (versions before 0.8.7) lets remote attackers submit code
Server-side request forgery in Crawl4AI's Docker API server (versions before 0.8.7) allows remote unauthenticated attack
Server-side request forgery in Crawl4AI (unclecode) versions 0.7.0 through 0.9.3 lets unauthenticated, remote API client
Server-side request forgery in Crawl4AI before 0.8.7 allows unauthenticated remote attackers to coerce the server into f
Crawl4AI <=0.4.247 is vulnerable to SSRF in /crawl4ai/async_dispatcher.py. Rated critical severity (CVSS 9.1), this vuln
Arbitrary file write in Crawl4AI's Docker API server (versions before 0.8.7) lets remote unauthenticated attackers overw
EUVD-2026-113185
GHSA-495r-f2mc-w3jj
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB