Skip to main content

fulgur EUVDEUVD-2026-82425

| CVE-2026-68537 HIGH
Uncontrolled Resource Consumption (CWE-400)
2026-09-17 https://github.com/fulgur-rs/fulgur GHSA-4rf6-qx84-q9fv
7.5
CVSS 3.1 · Vendor: https://github.com/fulgur-rs/fulgur
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Reach fulgur-backed HTML-to-PDF endpoint
  2. Delivery
    Submit tiny HTML with tall non-painting replaced box
  3. Exploit
    Bypass tag-gated childless-collapse defense
  4. Execution
    Renderer allocates ~10,000-page per-page loop
  5. Impact
    CPU/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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

fulgur < 0.19.0

Affected Packages

cargo fulgur fix: 0.19.0, 0.26.0

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

Vendor (https://github.com/fulgur-rs/fulgur) PRIMARY 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (https://github.com/fulgur-rs/fulgur).

CVSS VectorVendor: https://github.com/fulgur-rs/fulgur

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

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:hidden image,
  • 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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 73% exploitable
Prevalence
Low
niche Rust HTML/CSS-to-PDF crate, limited and unclear production adoption
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Rust

View all
CVE-2024-3566 CRITICAL POC
9.8 Apr 10

Command injection via Windows CreateProcess argument parsing affects multiple language runtimes and tooling (Node.js, PH

CVE-2021-31162 CRITICAL POC
9.8 Apr 14

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

CVE-2021-28879 CRITICAL POC
9.8 Apr 11

In the standard library in Rust before 1.52.0, the Zip implementation can report an incorrect size due to an integer ove

CVE-2026-58491 CRITICAL POC
9.3 Sep 21

Stored cross-site scripting and open redirect in Warpgate's SSO endpoints (versions prior to 0.25.5) allow an unauthenti

CVE-2021-29922 CRITICAL POC
9.1 Aug 07

library/std/src/net/parser.rs in Rust before 1.53.0 does not properly consider extraneous zero characters at the beginni

CVE-2026-77620 HIGH POC
8.7 Sep 22

Denial of service in the Vector observability pipeline's `logstash` source (versions 0.15.0 through 0.56.x) allows a rem

CVE-2019-12083 HIGH POC
8.1 May 13

The Rust Programming Language Standard Library 1.34.x before 1.34.2 contains a stabilized method which, if overridden, c

CVE-2021-28878 HIGH POC
7.5 Apr 11

In the standard library in Rust before 1.52.0, the Zip implementation calls __iterator_get_unchecked() more than once fo

CVE-2021-28875 HIGH POC
7.5 Apr 11

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

CVE-2019-16760 HIGH POC
7.5 Sep 30

Cargo prior to Rust 1.26.0 may download the wrong dependency if your package.toml file uses the `package` configuration

CVE-2024-24576 CRITICAL POC
10.0 Apr 09

Rust is a programming language. Rated critical severity (CVSS 10.0), this vulnerability is remotely exploitable, no auth

CVE-2018-1000810 CRITICAL
9.8 Oct 08

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

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy