CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-61725

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

Alon Barad
Alon Barad
Software Engineer

Nov 21, 2026·12 min read·2 visits

Executive Summary (TL;DR)

Versions of sevenz-rust2 prior to 0.21.1 do not sanitize archive entry filenames during extraction, allowing attackers to achieve arbitrary file write and overwrite via specially crafted 7z archives containing path traversal sequences or absolute file paths.

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Vulnerability Overview

sevenz-rust2 is a pure-Rust library used for compressing and decompressing 7z archives. It provides high-level convenience functions—including decompress, decompress_file, decompress_with_password, and decompress_file_with_password—that allow applications to extract archive contents directly to a specified target directory on the local filesystem. Because the library processes untrusted archive headers during decompression, its file extraction routines represent a primary attack surface for applications handling user-supplied .7z files.

In versions of sevenz-rust2 strictly prior to 0.21.1, the internal extraction engine contains a path traversal vulnerability classified under CWE-22 (Improper Limitation of a Pathname to a Restricted Directory) and CWE-23 (Relative Path Traversal). This bug class is commonly referred to as "Zip-Slip." When iterating through entries inside a 7z archive, the decompression logic trusts the raw filename strings embedded within the archive metadata header.

The extraction utility constructs the output file path by passing the unverified entry filename directly to Rust's standard library std::path::Path::join method alongside the target root directory. Neither the caller function nor the default extraction callback normalizes the path or verifies that the resolved destination remains strictly contained within the intended boundary.

As a result, an unauthenticated attacker can construct a malicious .7z archive containing filenames with relative parent directory indicators (such as ../) or leading root indicators (such as /). When a vulnerable application extracts this archive using the library's default decompression routines, the file writing logic escapes the designated target directory and creates or overwrites arbitrary files anywhere on the filesystem accessible to the host process.

Root Cause Analysis

The 7z archive specification stores entry metadata inside a structured header, representing file and directory paths as UTF-16 encoded strings. The format specification does not enforce syntactic constraints on these strings; an entry name can legally contain leading slashes, Windows drive letters, or arbitrary sequences of relative path traversal operators (..). Consequently, the decompression parser and extraction implementation must enforce boundary constraints before interacting with the host operating system's filesystem APIs.

The root cause of CVE-2026-61725 lies in the interaction between the decompress_impl and default_entry_extract_fn functions located in src/util/decompress.rs. During archive extraction, decompress_impl iterates over each entry in the SevenZReader instance and computes the output file path by executing dest.join(entry.name()). This computed PathBuf is then passed directly to default_entry_extract_fn, which recursively creates parent directories via std::fs::create_dir_all and truncates or creates the target file via std::fs::File::create.

The vulnerability is made possible by two specific design characteristics of Rust's std::path::Path::join method:

  1. Absolute Path Replacement: According to Rust standard library documentation, if the argument passed to Path::join is an absolute path (or starts with a root or prefix component), it completely replaces the existing base path. For example, if dest is /var/app/uploads and entry.name() is /etc/cron.d/persist, calling dest.join(entry.name()) discards /var/app/uploads and returns /etc/cron.d/persist.
  2. Lexical Concatenation of Relative Components: Path::join performs purely lexical concatenation without resolving or collapsing parent directory components (Component::ParentDir / ..). When dest is /var/app/uploads and entry.name() is ../../../home/user/.bashrc, the resulting path becomes /var/app/uploads/../../../home/user/.bashrc. When this path is passed to std::fs::File::create, the operating system kernel resolves the traversal sequences and opens /home/user/.bashrc for writing.

Furthermore, cross-platform separator discrepancies complicate path handling. On Unix platforms, the backslash character (\) is treated by std::path::Path as a standard filename character rather than a path separator, whereas Windows treats both / and \ as separators. Without explicit normalization of separators prior to component evaluation, archive entries authored with Windows-style traversal sequences (..\..\) exhibit inconsistent validation behavior across platforms.

Code Analysis

In versions of sevenz-rust2 up to and including 0.21.0, src/util/decompress.rs implemented the extraction loop and default handler without inspecting the components of entry.name(). The vulnerable implementation is shown below:

// Vulnerable code in src/util/decompress.rs (< 0.21.1)
fn decompress_impl<R: Read + Seek>(
    mut seven: SevenZReader<R>,
    dest: &Path,
    extract_fn: impl Fn(&ArchiveEntry, &mut dyn Read, &PathBuf) -> Result<bool, Error>,
) -> Result<(), Error> {
    if !dest.exists() {
        std::fs::create_dir_all(&dest)?;
    }
    seven.for_each_entries(|entry, reader| {
        // VULNERABILITY: Direct join without component inspection or normalization.
        // An absolute path replaces `dest`; `..` traverses above `dest`.
        let dest_path = dest.join(entry.name());
        extract_fn(entry, reader, &dest_path)
    })?;
 
    Ok(())
}
 
pub fn default_entry_extract_fn(
    entry: &ArchiveEntry,
    reader: &mut dyn Read,
    dest: &PathBuf,
) -> Result<bool, Error> {
    use std::{fs::File, io::BufWriter};
 
    if entry.is_directory() {
        let dir = dest;
        if !dir.exists() {
            std::fs::create_dir_all(dir)?;
        }
        return Ok(true);
    }
    if let Some(parent) = dest.parent() {
        if !parent.exists() {
            // Creates arbitrary parent directories outside `dest` if traversed.
            std::fs::create_dir_all(parent)?;
        }
    }
    // VULNERABILITY: Truncates or creates file at unvalidated path.
    let file = File::create(dest)?;
    let mut writer = BufWriter::new(file);
    std::io::copy(reader, &mut writer)?;
    Ok(true)
}

Maintainer Nils Hasenbanck addressed the vulnerability in commit ef760b61f3535ac8b93006212aef41bfebc237eb (released in version 0.21.1). The patch introduces a dedicated helper function, safe_join, and adds a secondary defense-in-depth check inside default_entry_extract_fn:

// Patched code in src/util/decompress.rs (>= 0.21.1)
fn decompress_impl<R: Read + Seek>(
    mut seven: SevenZReader<R>,
    dest: &Path,
    extract_fn: impl Fn(&ArchiveEntry, &mut dyn Read, &PathBuf) -> Result<bool, Error>,
) -> Result<(), Error> {
    if !dest.exists() {
        std::fs::create_dir_all(&dest)?;
    }
    seven.for_each_entries(|entry, reader| {
        // FIX 1: Replace dest.join() with component-validated safe_join()
        let dest_path = safe_join(&dest, entry.name())?;
        extract_fn(entry, reader, &dest_path)
    })?;
 
    Ok(())
}
 
#[cfg(not(target_arch = "wasm32"))]
fn safe_join(dest: &Path, entry_name: &str) -> Result<PathBuf, Error> {
    use std::path::Component;
 
    // FIX 2: Normalize Windows backslashes to forward slashes across all platforms
    let normalized = entry_name.replace('\\', "/");
    let mut result = dest.to_path_buf();
    
    // FIX 3: Inspect each lexical component of the entry path
    for component in Path::new(&normalized).components() {
        match component {
            Component::Normal(part) => result.push(part),
            Component::CurDir => {}
            // Reject parent traversal (..), leading roots (/), and Windows drive prefixes (C:)
            Component::ParentDir | Component::RootDir | Component::Prefix(_) => {
                return Err(Error::other(format!(
                    "unsafe entry path escapes destination: {entry_name}"
                )));
            }
        }
    }
    Ok(result)
}
 
pub fn default_entry_extract_fn(
    entry: &ArchiveEntry,
    reader: &mut dyn Read,
    dest: &PathBuf,
) -> Result<bool, Error> {
    use std::{fs::File, io::BufWriter, path::Component};
 
    // FIX 4: Defense-in-depth check for direct callers of default_entry_extract_fn
    if dest.components().any(|c| c == Component::ParentDir) {
        return Err(Error::other(format!(
            "unsafe entry path contains a parent-directory component: {}",
            dest.to_string_lossy()
        )));
    }
    // ... [directory and file creation proceeds safely]

Fix Completeness Assessment

The patch in 0.21.1 effectively neutralizes lexical path traversal and absolute path injection. By normalizing \ to / before calling .components(), it guarantees uniform rejection of Windows-formatted paths even when extracted on Unix targets. Rejecting Component::ParentDir altogether is stricter than depth-counting normalization; it prevents any archive entry containing .. (even benign ones such as subdir/../file.txt) from extracting, eliminating off-by-one depth calculation risks.

Two edge-case considerations remain for callers:

  1. Direct Callers of default_entry_extract_fn: As noted in the patch comments, if a developer writes a custom extraction loop using SevenZReader::for_each_entries directly (bypassing decompress_impl and safe_join) and passes dest.join(entry.name()) into default_entry_extract_fn, the defense-in-depth check will block Component::ParentDir (..), but cannot detect an absolute path overwrite because dest has already been replaced by the absolute path before reaching default_entry_extract_fn.
  2. Symlink Traversal: Because 7z archives primarily store regular files and directories in standard extraction workflows across sevenz-rust2 (where default_entry_extract_fn only branches on entry.is_directory() and otherwise calls File::create), symlink creation is not performed by the default extractor. However, if pre-existing symlinks reside inside the target destination directory pointing outside the root, lexical component checking in safe_join does not perform filesystem canonicalization (std::fs::canonicalize) to detect symlink traversal.

Exploitation

Exploiting CVE-2026-61725 requires an application linked against sevenz-rust2 (< 0.21.1) to extract an attacker-supplied .7z archive using any of the library's built-in decompression utilities (decompress, decompress_file, decompress_with_password, or decompress_file_with_password). No authentication or special system configuration is necessary beyond the ability to deliver the archive to the target parser.

Archive Construction

Standard archiving tools (such as the official 7z CLI tool) typically strip leading slashes or reject ../ sequences during archive creation. However, an attacker can construct a malicious archive programmatically using a modified 7z writer, by directly editing the UTF-16 filename strings inside the uncompressed 7z header stream (and recalculating the header CRC32 checksum), or by using SevenZWriter in Rust with custom entry names.

For example, the upstream regression test suite in tests/decompression_tests.rs demonstrates how a malicious archive payload is constructed in memory using the library's own writer:

// Constructing a malicious 7z payload with a relative traversal entry name
let mut buf = Cursor::new(Vec::new());
{
    let mut writer = SevenZWriter::new(&mut buf).unwrap();
    let mut entry = ArchiveEntry::new_file("../sevenz_pwned_relative");
    writer
        .push_archive_entry(entry, Some(b"malicious_payload".as_slice()))
        .unwrap();
    writer.finish().unwrap();
}

Attack Vectors

Depending on the target operating system and the privileges of the process running sevenz-rust2, an attacker can employ three distinct path structures:

  1. Deep Relative Traversal (../): By prepending multiple traversal segments (e.g., ../../../../../../../../home/appuser/.ssh/authorized_keys or ../../../../../../../../home/appuser/.bashrc), the attacker does not need to know the exact directory depth of the extraction temporary folder. Once the .. segments ascend to the filesystem root /, excess .. evaluations remain at /, resolving deterministically to the target path.
  2. Direct Absolute Path Targeting: On Unix systems, naming an archive entry /var/www/html/shell.php or /etc/cron.d/backdoor bypasses the need for relative traversal entirely. When dest.join("/etc/cron.d/backdoor") executes, the base path is dropped and File::create opens /etc/cron.d/backdoor directly.
  3. Windows Startup Persistence: When targeting Windows applications, an attacker can craft an entry using relative traversal targeting the current user's startup folder, such as ..\..\..\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\payload.bat.

> [!NOTE] > In default_entry_extract_fn, std::fs::File::create opens the target path with O_WRONLY | O_CREAT | O_TRUNC. If the target file already exists and is writable by the running process, its existing contents are immediately truncated and replaced with the decompressed stream.

Impact Assessment

CVE-2026-61725 carries a CVSS v3.1 base score of 6.1 (Medium) with the vector CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:L. The Attack Vector is designated as Local (AV:L) with User Interaction Required (UI:R) because standard library usage patterns involve a user or local service initiating extraction on a file provided via an external channel.

However, the effective severity depends heavily on the deployment context of the consuming application. If sevenz-rust2 is integrated into a network-accessible service—such as a web application backend, an automated document processing pipeline, or a CI/CD artifact unpacker—that automatically extracts uploaded .7z archives without human intervention, the vulnerability becomes remotely triggerable over the network.

The primary security consequence is High Integrity Impact (I:H) via arbitrary file creation and overwrite within the security context of the running process:

  • Remote / Local Code Execution: By overwriting executable binaries, shared libraries (.so / .dll), shell configuration files (~/.bashrc, ~/.profile), scheduled task definitions (/etc/cron.d/), or web application scripts, an attacker can escalate the arbitrary file write into code execution.
  • Authentication Bypass: Overwriting ~/.ssh/authorized_keys or application configuration files (such as .env or database configuration files) allows attackers to inject credentials or alter access controls.
  • Denial of Service (A:L): Because File::create truncates existing files before copying the reader stream, an attacker can corrupt critical application state, databases, or lockfiles, rendering the software inoperable.

Confidentiality is not directly impacted by the extraction operation itself (C:N), as the flaw only permits writing data out from the archive to the disk, though subsequent code execution achieved via file overwrite would compromise system confidentiality.

As of the latest threat intelligence metrics, the vulnerability has an EPSS score of 0.00138 (3.24th percentile) and is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. A public proof-of-concept and reproduction repository is available on GitHub (googlesky/CVE-2026-61725), along with functional exploit test cases inside the upstream repository.

Remediation

Upgrading to the Patched Release

All users and downstream dependencies consuming sevenz-rust2 should upgrade to version 0.21.1 or later immediately. Version 0.21.1 enforces strict component validation across all built-in decompression entry points.

Update the dependency declaration in Cargo.toml:

[dependencies]
sevenz-rust2 = ">= 0.21.1"

After updating Cargo.toml, synchronize the lockfile and rebuild the project:

cargo update -p sevenz-rust2
cargo build --release

To verify that no vulnerable versions remain in the dependency tree, audit the lockfile using cargo tree -i sevenz-rust2 or cargo audit.

Workarounds for Unpatched Environments

If immediate upgrading is blocked by dependency constraints or Minimum Supported Rust Version (MSRV) requirements, applications must stop calling decompress, decompress_file, decompress_with_password, and decompress_file_with_password. Instead, developers should instantiate SevenZReader directly and pass a custom closure to for_each_entries that validates every path component prior to touching the filesystem:

use std::fs::{self, File};
use std::io::{self, BufWriter};
use std::path::{Component, Path, PathBuf};
use sevenz_rust2::{ArchiveEntry, Error, SevenZReader};
 
pub fn extract_archive_safely(archive_path: &Path, dest_root: &Path) -> Result<(), Error> {
    let mut reader = SevenZReader::open(archive_path, "".into())?;
    if !dest_root.exists() {
        fs::create_dir_all(dest_root)?;
    }
 
    reader.for_each_entries(|entry, entry_reader| {
        // Normalize Windows separators and validate every path component
        let normalized = entry.name().replace('\\', "/");
        let mut safe_dest = dest_root.to_path_buf();
 
        for component in Path::new(&normalized).components() {
            match component {
                Component::Normal(part) => safe_dest.push(part),
                Component::CurDir => {}
                Component::ParentDir | Component::RootDir | Component::Prefix(_) => {
                    return Err(Error::other(format!(
                        "Rejected unsafe archive entry path: {}",
                        entry.name()
                    )));
                }
            }
        }
 
        if entry.is_directory() {
            fs::create_dir_all(&safe_dest)?;
        } else {
            if let Some(parent) = safe_dest.parent() {
                fs::create_dir_all(parent)?;
            }
            let file = File::create(&safe_dest)?;
            let mut writer = BufWriter::new(file);
            io::copy(entry_reader, &mut writer)?;
        }
        Ok(true)
    })
}

> [!WARNING] > Do not rely solely on Path::starts_with after calling dest.join(entry.name()) as a workaround. In Rust, Path::starts_with operates lexically without resolving .. components; therefore, /tmp/dest/../../etc/passwd lexically starts with /tmp/dest, causing a naive starts_with check to return true while still allowing directory traversal at the OS level.

Official Patches

GitHub / sevenz-rust2Upstream patch commit implementing safe_join and parent directory validation.
GitHub / sevenz-rust2Official v0.21.1 release containing the fix for CVE-2026-61725.
GitHub Security AdvisoryOfficial GitHub Security Advisory GHSA-qh76-45cr-8xrc.

Fix Analysis (1)

Technical Appendix

CVSS Score
6.1/ 10
CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:L
EPSS Probability
0.14%
Top 97% most exploited

Affected Systems

sevenz-rust2 Cargo package (< 0.21.1)

Affected Versions Detail

Product
Affected Versions
Fixed Version
sevenz-rust2
hasenbanck
< 0.21.10.21.1
AttributeDetail
CVE IDCVE-2026-61725 (GHSA-qh76-45cr-8xrc)
Weakness ClassCWE-22 / CWE-23 (Path Traversal / Zip-Slip)
Affected Componentsevenz-rust2 (< 0.21.1) in src/util/decompress.rs
CVSS v3.1 Score6.1 Medium (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:H/A:L)
EPSS Score0.14% (3.24th Percentile)
ImpactArbitrary File Write and Overwrite outside destination root
Exploit StatusProof-of-Concept Publicly Available
Patched Versionsevenz-rust2 v0.21.1

MITRE ATT&CK Mapping

T1083File and Directory Discovery
Discovery
T1005Data from Local System
Collection
T1059Command and Scripting Interpreter
Execution
T1037Boot or Logon Initialization Scripts
Persistence
T1053Scheduled Task/Job
Persistence
CWE-22
Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal')

The software uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the software does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory.

Known Exploits & Detection

GitHubIndependent reproduction and proof-of-concept analysis repository for CVE-2026-61725.
GitHubUpstream regression tests in tests/decompression_tests.rs demonstrating relative and absolute path traversal archive payloads.

Vulnerability Timeline

Vulnerability reported by @lintowe via GitHub Issue #116.
2026-06-23
Fix committed (ef760b61f3535ac8b93006212aef41bfebc237eb) and version 0.21.1 released to crates.io.
2026-06-23
GitHub Security Advisory GHSA-qh76-45cr-8xrc and CVE-2026-61725 published.
2026-10-30
NVD and CVE records updated with CVSS v3.1 metrics.
2026-11-02

References & Sources

  • [1]Official CVE Record (CVE-2026-61725)
  • [2]GitHub Security Advisory (GHSA-qh76-45cr-8xrc)
  • [3]National Vulnerability Database (NVD) Entry
  • [4]Upstream Git Fix Commit (ef760b61f3535ac8b93006212aef41bfebc237eb)
  • [5]Upstream Git Release Tag (v0.21.1)
  • [6]CVEProject cvelistV5 Record
  • [7]Reproduction and PoC Reference Repository

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•43 minutes ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
1 views•12 min read
•about 3 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 4 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
5 views•10 min read
•about 5 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
5 views•9 min read
•about 6 hours ago•CVE-2026-132275
7.5

CVE-2026-132275: Exponential Resource Consumption via Nested <use> References in svglib

svglib versions prior to 2.3.1 contain an uncontrolled resource consumption vulnerability in the svg2rlg() renderer. When parsing SVG documents containing nested <use> elements, SvgRenderer.renderUse() recursively resolves and deep-copies referenced subtrees without enforcing a global expansion limit. Although the library detects and blocks direct circular references, an attacker can construct an acyclic directed reference graph with high fan-out (an SVG analogue to the XML Billion Laughs attack). Processing a crafted SVG payload of less than 2 KB triggers exponential node duplication, exhausting CPU and memory in applications that convert user-supplied SVGs or HTML documents embedding SVG content.

Amit Schendel
Amit Schendel
4 views•9 min read
•about 7 hours ago•CVE-2026-132277
5.3

CVE-2026-132277: Quadratic Memory Growth and Denial of Service in Inscriptis HTML-to-Text Library

CVE-2026-132277 (also tracked as GHSA-q87h-c5m7-659j) is an uncontrolled resource consumption and algorithmic complexity vulnerability in the Inscriptis Python library (versions 2.0.0 through 2.7.5). When rendering sibling HTML table elements inside a block-level parent container, the parser fails to pop the parent block's inline padding prefix from the internal canvas prefix stack upon closing the block. Consequently, each subsequent sibling table inherits and accumulates the indentation prefixes of all preceding tables. This causes the output string length and memory allocation of get_text() to grow quadratically with the number of sibling tables, allowing a compact untrusted HTML payload to trigger denial of service via memory exhaustion.

Amit Schendel
Amit Schendel
5 views•10 min read