Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain valid API key
-
DeliverySubmit extraction job with malicious JSON schema
-
Exploit$ref in default/enum bypasses AJV, resolved by ref parser
-
ExecutionTrigger dereference error to capture file/endpoint contents
-
ImpactRead error response exfiltrating files or cloud metadata credentials
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Command injection prevention
MITRE ATT&CK
1 technique across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires a valid, authenticated Firecrawl API request to the extraction endpoint (the description states 'an authenticated attacker,' which conflicts with the vendor CVSS PR:N - treat authentication as required). The attacker must supply a crafted JSON schema with a $ref placed specifically inside a default, const, or enum field, because those keywords are not traversed by AJV validation and therefore bypass sanitization while still being resolved by json-schema-ref-parser's default file/http resolvers. Successful data return depends on triggering a dereference error so the resolved content is embedded in the persisted error message surfaced through the API. Limiting factors: the target file must be readable by the extract worker process, SSRF targets must be reachable from the worker's network position, and instances running 2.11.32 or later, or configurations that block $ref-bearing schemas, are not exploitable. |
| Impact | This is a genuine high-priority issue rather than a CVSS-inflated one: the impact is concrete (read any file the extract worker can access, plus SSRF to cloud-metadata and internal services), and the fix commit itself proves exploitability with working regression tests. The vendor CVSS 4.0 vector (AV:N/AC:L/PR:N/UI:N, VC/VI/VA:H) scores 9.3, but there is a material conflict: the description explicitly says 'an authenticated attacker,' which contradicts PR:N - realistic exploitation requires a valid Firecrawl API key, so effective privilege is low rather than none, and defenders running the hosted API or a multi-tenant self-hosted instance should treat any key-holder as a potential attacker. Confidentiality impact is the clear win for the attacker (file exfiltration + metadata credential theft via SSRF); the vendor's VI:H/VA:H rating is arguably generous since the primary mechanism is read/exfiltration, not modification or denial. There is no CISA KEV entry and no public exploit identified, and no EPSS score was provided, so exploitation is currently theoretical-but-trivial rather than observed in the wild - still, given that a self-hosted Firecrawl on a cloud VM exposes instance-metadata credentials through this SSRF, even a modest operator should patch promptly. Weighing the signals together: high technical impact, low practical barrier (authenticated network access), no confirmed active exploitation - prioritize as a fast-track patch. |
| Exploit ScenarioDerived | An attacker with a valid Firecrawl API key submits an extraction job whose JSON schema hides a $ref such as file:///proc/self/environ or http://169.254.169.254/latest/meta-data/iam/security-credentials/ inside a default or enum field that AJV skips but the ref parser still resolves. They intentionally malform the reference so dereferencing fails, and the resolved file/endpoint content is captured in the persisted error message returned by the extraction API, exfiltrating local secrets or cloud IAM credentials. No public exploit is identified, but the vendor's own regression tests demonstrate the exact file:// and metadata-endpoint vectors. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 10, 2026
Arbitrary file read and SSRF in Firecrawl before 2.11.32 lets an API caller exfiltrate files from the extraction worker and reach internal/external HTTP endpoints by abusing JSON-schema dereferencing. The extract feature passes user-supplied schemas to the json-schema-ref-parser library with default resolvers, so a $ref placed inside default, const, or enum fields (which AJV does not traverse) is resolved against the local filesystem or network; a deliberately triggered dereference error then leaks the resolved file contents back through the extraction API's persisted error message. No public exploit or CISA KEV listing is identified at time of analysis, but the fix commit ships security regression tests demonstrating the file:// and metadata-endpoint attack paths.
RemediationAI
Vendor-released patch: upgrade to Firecrawl 2.11.32, which removes the json-schema-ref-parser dependency and substitutes a resolver that inlines only internal (#/...) pointers while leaving file:// and http(s):// $refs untouched (fix commit 053630fc5203df91b707a6a523e33db5896a1ee8; advisory GHSA-3p54-jg6f-68r8). If you cannot upgrade immediately, reject or strip user-supplied schemas that contain $ref keys - particularly inside default, const, and enum fields - before they reach the extraction service; note this may break legitimate callers relying on internal schema references. As defense-in-depth for self-hosted workers, run the extract worker with a locked-down egress policy to block outbound access to link-local metadata (169.254.169.254) and internal ranges, and run it under a least-privilege filesystem account or sandbox so an arbitrary read cannot reach secrets, .env files, or credentials - with the trade-off that overly strict egress rules can break legitimate crawling of external targets, so scope network controls to the worker's schema-resolution path rather than its crawl fetches.
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
Firecrawl converts websites into LLM-ready markdown/structured data; its extraction pipeline (apps/api/src/lib/extract/helpers/dereference-schema.ts) accepts a caller-provided JSON Schema to shape structured output. The vulnerable code called dereference() from @apidevtools/json-schema-ref-parser with default resolver settings, which enable the built-in file and http(s) resolvers. JSON Schema $ref pointers are normally resolved only within the document, but this library will fetch external and local references (e.g. file:///etc/passwd, http://169.254.169.254/latest/meta-data/). Crucially, AJV validation does not descend into default, const, or enum keywords, so a $ref hidden there bypasses schema sanitization yet is still resolved by the ref parser. The advisory is tagged Command Injection (CWE-77), but the true root cause is insecure external-reference resolution - behaviorally CWE-611 (external entity/reference) combined with CWE-22 (path traversal / arbitrary file read) and CWE-918 (SSRF); the CWE-77 mapping appears mismatched with the described mechanism. The fix removes the dependency and replaces it with a bespoke resolver that inlines only internal pointers and passes file:// and http(s):// refs through verbatim, capped at MAX_REF_RESOLUTIONS (50,000) to prevent recursion abuse.
Know when Firecrawl 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:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Description states an authenticated attacker so PR:L not PR:N; arbitrary file read plus SSRF to other systems gives C:H and S:C, with no genuine integrity or availability impact (I:N/A:N).
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Firecrawl turns entire websites into LLM-ready markdown or structured data. Prior to 2.11.32, a critical arbitrary file read vulnerability exists in Firecrawl's extraction functionality due to unsafe schema dereferencing of user-supplied JSON schemas in apps/api/src/lib/extract/helpers/dereference-schema.ts. The affected code invokes the json-schema-ref-parser dependency with default resolver settings, allowing external and local file references to be resolved during schema processing. An authenticated attacker can supply a malicious schema containing a $ref within default, const, or enum fields that are not traversed by AJV validation. By triggering a dereference error, file contents from the extract worker filesystem may be included in persisted error messages returned through the extraction API, enabling arbitrary file reads and SSRF against internal or external HTTP endpoints. This issue is fixed in version 2.11.32.
Executive ViewAI
Firecrawl before version 2.11.32 contains a critical vulnerability allowing arbitrary file read and server-side request forgery through JSON-schema parameter exploitation. The flaw enables exfiltration of sensitive data from extraction worker systems and unauthorized access to internal infrastructure. Organizations running affected versions face immediate risk of data breach and lateral network compromise.
No vendor-released patch identified at time of analysis. Interim mitigations include: disable Firecrawl if not operationally essential; enforce strict network segmentation limiting API access; reject or validate JSON-schema parameters to prevent $ref injection; implement comprehensive audit logging of all extraction requests; rotate all API credentials with Firecrawl access; evaluate alternative web extraction solutions pending patch release.
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
Server-Side Request Forgery exploits applications that fetch remote resources based on user-supplied URLs.
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
Arbitrary local file read in firecrawl-mcp-server 3.20.2 allows any caller of the firecrawl_parse MCP tool to extract se
Firecrawl's Playwright scraping service through version 2.8.0 permits attackers to bypass SSRF protections and access in
EUVD-2026-55806
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB