Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach fulgur-backed HTML-to-PDF endpoint
-
DeliverySubmit tiny HTML with tall non-painting replaced box
-
ExploitBypass tag-gated childless-collapse defense
-
ExecutionRenderer allocates ~10,000-page per-page loop
-
ImpactCPU/memory exhaustion denies host and co-tenants
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires that the target application expose fulgur's HTML/CSS-to-PDF conversion to attacker-supplied input - i.e., a service that accepts untrusted HTML (typically a multi-tenant/network-facing conversion endpoint) and passes it to fulgur < 0.26.0 without first validating or constraining CSS dimensions. The trigger is a childless box resolving to a pathologically tall height (large height/vh) via any non-painting replaced element: an unresolved img src, a visibility:hidden image, an undecodable image format, or an empty <svg> (plus a trailing-sibling variant). No authentication or user interaction is required by the vendor vector (PR:N/UI:N), and the payload is only a few bytes. Limiting factors: the flaw is inert if fulgur is only fed trusted/first-party HTML, if untrusted CSS heights are validated/capped before rendering (the documented workaround), or if the crate is already upgraded to 0.26.0+. Versions < 0.19.0 are worse (unbounded pages / non-terminating loop, tracked as GHSA-j5cx-ph8g-95v3). |
| Impact | The vendor CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) reflects a pure availability impact and is internally consistent with the description: a few bytes of attacker-supplied HTML amplify into ~10,000 blank PDF pages, exhausting CPU and memory and denying service to the host and co-tenants. The AV:N choice is a deliberate library worst-case assessment - the advisory itself notes (per CVSS v3.1 User Guide §3.7) that fulgur performs no network I/O and that a concrete deployment splitting HTML ingestion from rendering could legitimately assess AV:L environmentally, so treat 7.5 as an upper bound rather than a universal value. No EPSS score, no CISA KEV listing, and no public POC are present in the input, so there is no evidence of active or automated exploitation; this is a real, low-complexity, unauthenticated DoS but is NOT a confirmed in-the-wild threat. Real priority is moderate: the flaw is trivially triggerable against any exposed multi-tenant fulgur conversion service, but overall risk is bounded by the crate's apparently niche deployment footprint and by the availability-only impact (no confidentiality or integrity loss). The most important limiting caveat is that exploitability hinges on whether the embedding application actually exposes fulgur to untrusted, network-supplied HTML - verify that per deployment. |
| Exploit ScenarioDerived | An attacker submits a trivially small HTML payload (e.g. a childless box with a huge CSS height such as an <img> with an unresolved src, a visibility:hidden image, an undecodable image, or an empty <svg>) to a multi-tenant service that uses fulgur to render HTML/CSS to PDF. The non-painting replaced element bypasses the childless-collapse defense and amplifies into ~10,000 blank pages, driving CPU and memory exhaustion that denies service to the host and all co-tenants. No public exploit code is identified at time of analysis, though the technique is fully described in the advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 17, 2026
Denial of service in the fulgur Rust crate affects all versions prior to 0.26.0, where a childless HTML box styled to a pathologically tall height (large height or vh values) is amplified into roughly MAX_PAGES (10,000) blank PDF pages despite producing no visible output, exhausting CPU and memory on the host and any co-tenants. The flaw is reachable by unauthenticated remote attackers (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, base 7.5) whenever a network-facing service passes attacker-supplied HTML/CSS into fulgur's conversion path, and the trigger payload is only a few bytes. Vendor-released patch: 0.26.0 (PR #575); no public exploit identified at time of analysis, and the crate itself performs no network I/O, so exposure depends entirely on the embedding application's deployment.
RemediationAI
Vendor-released patch: 0.26.0. Upgrade the fulgur crate to 0.26.0 or later (fix delivered in PR #575, https://github.com/fulgur-rs/fulgur/pull/575); the patch removes the tag-only replaced-content gate so any pathologically tall childless box collapses regardless of whether it is a replaced element, closing the unresolved-src, visibility:hidden, undecodable-format, empty-<svg>, and trailing-sibling vectors at once. Update the dependency in Cargo.toml/Cargo.lock and rebuild, then verify no version constraint still resolves below 0.26.0 transitively. If upgrading cannot be done immediately, the documented compensating control is to validate or constrain untrusted CSS before handing HTML to fulgur - in particular reject or clamp very large height and vh values on elements, since a few bytes of CSS are sufficient to trigger the amplification; the trade-off is that aggressive height clamping can distort legitimate long documents and requires sanitizing CSS in the caller rather than at render time. Environments still on versions below 0.19.0 face the additional unbounded-page and non-terminating-loop variant (GHSA-j5cx-ph8g-95v3) and should treat the upgrade as urgent. Consult the vendor advisory (https://github.com/fulgur-rs/fulgur/security/advisories/GHSA-4rf6-qx84-q9fv) and RustSec RUSTSEC-2026-0201 (https://rustsec.org/advisories/RUSTSEC-2026-0201.html) for the authoritative fix details.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in cargo
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
fulgur is a Rust library that converts untrusted HTML/CSS into PDF, typically embedded in multi-tenant server-side rendering pipelines. The root cause is CWE-400 (Uncontrolled Resource Consumption): in crates/fulgur/src/pagination_layout.rs, the childless-collapse defense that should reduce a pathologically tall, output-less box to a single page slice was gated by a tag-only is_replaced_content check matching <img>/<svg>. Because that gate keyed on tag name rather than on whether the replaced element actually paints, any non-painting replaced element escaped the collapse logic - an unresolved src, a visibility:hidden image, an undecodable image format, or an empty <svg> - as did a trailing-sibling variant of the same gap. The pagination loop then advanced page_index up to the MAX_PAGES ceiling (10,000), allocating and running a per-page iteration for each blank page and driving the document to ~MAX_PAGES fragments. The fix removes the tag-only gate so any childless box exceeding the page cap collapses to one slice and the occupied space is bounded (cursor reset so following siblings resume on the next page), which also closes the trailing-sibling case in the same change. Note that the maintainers explicitly treat even a resolved image stretched with an enormous height as the same amplifier, since no legitimate single image occupies a range above ~10M px. Separately, versions before 0.19.0 had no page-count cap at all, permitting an unbounded variant and a non-terminating loop on non-finite heights (tracked as GHSA-j5cx-ph8g-95v3).
Know when Rust 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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Library worst-case is an unauthenticated network service rendering untrusted HTML (AV:N/AC:L/PR:N/UI:N); trivial payload causes CPU/memory exhaustion, so A:H with no confidentiality or integrity impact.
Primary rating from Vendor (https://github.com/fulgur-rs/fulgur).
CVSS VectorVendor: https://github.com/fulgur-rs/fulgur
DescriptionCVE.org
fulgur converts untrusted HTML/CSS into PDF, commonly on a server that processes input supplied by many tenants. In versions prior to 0.26.0, a childless box that resolves to a pathologically tall height was amplified into thousands of blank PDF pages, even when it produces no visible output.
The childless-collapse defense that would normally collapse such a box was gated by a tag-only "replaced content" check, so any non-painting replaced element bypassed it, including:
- an unresolved
src(the common offline-first case), - a
visibility:hiddenimage, - an undecodable image format, and
- an empty
<svg>.
A trailing-sibling variant of the same gap was also open. A few bytes of HTML therefore amplified into roughly MAX_PAGES (10,000) blank pages; the renderer allocates and runs a per-page loop over them, producing CPU and memory exhaustion. An attacker able to submit HTML to a fulgur-based conversion service can trigger this with a trivially small payload, denying service to the host and any co-tenants.
Patches
Fixed in 0.26.0 (PR #575). The tag-only gate was removed so that any pathologically tall childless box collapses regardless of whether it is a replaced element, closing the missing-src, visibility:hidden, undecodable-format, and empty-<svg> vectors at once, along with the trailing-sibling variant.
Workarounds
Upgrade to 0.26.0 or later. If upgrading is not immediately possible, validate or constrain untrusted CSS (in particular very large height / vh on elements) before passing HTML to fulgur.
Related
Versions prior to 0.19.0 additionally lacked any page-count cap, allowing an unbounded (rather than 10,000-page) variant of this amplification and a non-terminating loop on non-finite heights. That earlier variant is tracked separately as GHSA-j5cx-ph8g-95v3.
Attack Vector rationale
fulgur performs no network I/O of its own; it renders HTML/CSS handed to it by the embedding application. This advisory scores the crate independent of any specific adopting program, so per the CVSS v3.1 User Guide §3.7 (scoring library vulnerabilities related to incoming data) the Attack Vector is assessed as Network for the reasonable worst-case deployment - a network-facing service that renders untrusted, attacker-supplied HTML without user interaction. A concrete system that receives the HTML in one component and passes it to fulgur in a separate component may assess a lower environmental Attack Vector (Local, per §3.10).
References
- Fix: https://github.com/fulgur-rs/fulgur/pull/575
Technical POC Analysis
CWE-400 (Uncontrolled Resource Consumption): amplification of a few bytes of HTML into ~MAXPAGES (10,000) blank PDF pages.
Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.
Executive ViewAI
Any network-facing service that converts untrusted HTML into PDFs with the fulgur Rust crate (all versions prior to 0.26.0) can be knocked offline by an unauthenticated remote attacker sending only a few bytes of CSS. The trigger forces the library to generate roughly 10,000 empty PDF pages, consuming host CPU and memory until the service, and any workloads sharing that host or cluster, are starved. Leadership should care because the vulnerable component sits directly on the internet-facing request path and the cost of an attack is negligible relative to the availability risk it creates for customer-facing document generation.
Apply vendor patch.
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
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
Command injection via Windows CreateProcess argument parsing affects multiple language runtimes and tooling (Node.js, PH
In the standard library in Rust before 1.52.0, a double free can occur in the Vec::from_iter function if freeing the ele
In the standard library in Rust before 1.52.0, the Zip implementation can report an incorrect size due to an integer ove
Stored cross-site scripting and open redirect in Warpgate's SSO endpoints (versions prior to 0.25.5) allow an unauthenti
library/std/src/net/parser.rs in Rust before 1.53.0 does not properly consider extraneous zero characters at the beginni
Denial of service in the Vector observability pipeline's `logstash` source (versions 0.15.0 through 0.56.x) allows a rem
The Rust Programming Language Standard Library 1.34.x before 1.34.2 contains a stabilized method which, if overridden, c
In the standard library in Rust before 1.52.0, the Zip implementation calls __iterator_get_unchecked() more than once fo
In the standard library in Rust before 1.50.0, read_to_end() does not validate the return value from Read in an unsafe c
Cargo prior to Rust 1.26.0 may download the wrong dependency if your package.toml file uses the `package` configuration
Rust is a programming language. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitable, no auth
The Rust Programming Language Standard Library version 1.29.0, 1.28.0, 1.27.2, 1.27.1, 127.0, 126.2, 126.1, 126.0 contai
EUVD-2026-82425
GHSA-4rf6-qx84-q9fv
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB