CVE-2026-134682 — Gpac Gpac (26.07.0) — CWE-416
CVE-2026-134682 is a MEDIUM severity Denial-of-Service (DoS) vulnerability (CWE-416) (CVSS 6.9/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 a use-after-free vulnerability in scene graph teardown that allows attackers to trigger access to freed memory via crafted scene files. A node shared across multiple PROTO node_code lists is freed by gf_sg_reset(), and gf_sg_proto_del() then calls gf_node_unregister() on the dangling pointer, crashing MP4Box.
🎯 What is this vulnerability?
CVE‑2026‑134682 is a classic use‑after‑free (CWE‑416) flaw that occurs in the scene‑graph teardown path of GPAC MP4Box (v26.07.0).
When a scene file contains a PROTO node that references a node_code list, the following sequence happens:
1. gf_sg_reset() walks the scene graph and frees every node that is no longer needed.
2. If a node is shared across multiple PROTO node_code lists, the first gf_sg_reset() frees the node but does not clear the pointer in the other lists.
3. Later, gf_sg_proto_del() is called to delete the PROTO definition. It invokes gf_node_unregister() on the dangling pointer that still points to the freed node.
4. gf_node_unregister() dereferences the freed pointer, leading to a segmentation fault (crash) or, in a worst‑case scenario, arbitrary memory corruption.
Key missing check: The code does not verify that a node pointer is still valid before unregistering it. No authentication or privilege checks are involved because the vulnerability is triggered by a local user who can supply a crafted scene file.
The CVSS vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:L/VA:H) reflects that the flaw is local, requires low effort, needs no authentication, and results in high availability impact (service crash) with only low confidentiality/integrity impact.
⚡ Attack Chain
Below is a realistic, step‑by‑step exploitation flow that an attacker could follow on a system where GPAC MP4Box is installed and used to process user‑supplied scene files.
| Step | Action | Technical Detail |
|---|---|---|
| 1. Discovery & Reconnaissance | Identify the presence of GPAC MP4Box and its version. | • which mp4box or mp4box -version on the target host.<br>• If the tool is exposed via a web service (e.g., a media‑transcoding API), the attacker can probe the endpoint for a “User‑Agent” header that contains “GPAC” or query /status if the API exposes it. |
| 2. Crafting the malicious scene file | Build a .scene file that triggers the use‑after‑free. | The file must:<br>• Define a PROTO node that contains a node_code list referencing a node that will be freed.<br>• Reference the same node in two different PROTO definitions so that the first reset frees it while the second still holds a pointer.<br>Example (illustrative; actual syntax may vary slightly):<br>``scene\n# Define a reusable node\nNODE MyNode {\n type: \"Video\";\n source: \"input.mp4\";\n}\n\n# First PROTO that will free the node\nPROTO ProtoA {\n node_code: MyNode;\n}\n\n# Second PROTO that still holds a dangling pointer after reset\nPROTO ProtoB {\n node_code: MyNode;\n}\n\n# Use the PROTOs in a scene graph\nScene {\n ProtoA;\n ProtoB;\n}\n`\n> Note: The exact syntax of GPAC scene files may differ; the above is a conceptual illustration. The attacker only needs to ensure that the same node instance is referenced in two PROTOs. |
| 3. Delivery | Provide the crafted scene file to MP4Box. | • If MP4Box is run locally by a user, the attacker simply runs:<br>`bash\nmp4box -scene malicious.scene -o out.mp4\n`\n• If MP4Box is invoked by a web service, the attacker uploads the scene file via the service’s file‑upload endpoint (e.g., POST /api/convert with multipart/form-data). |
| 4. Exploitation | MP4Box processes the file, triggers gf_sg_reset(), frees the node, then gf_sg_proto_del() attempts to unregister the dangling pointer, causing a crash. | The crash manifests as a segmentation fault (Segmentation fault (core dumped)`) or a core dump file. The process exits with a non‑zero status. |
| 5. Post‑exploitation | Impact is Denial‑of‑Service. | • The service that relies on MP4Box (e.g., a media‑transcoding daemon) stops responding.<br>• If the service is running under a privileged account, the crash could be used to trigger a local privilege escalation via a separate vulnerability (not part of this CVE).<br>• In a multi‑tenant environment, the attacker can cause a service outage for all users. |
Important: This CVE does not provide remote code execution or data exfiltration. The only guaranteed impact is a crash that leads to service unavailability.
🌍 Real World Impact
| Impact | CVSS Component | Interpretation |
|---|---|---|
| Confidentiality | VC:L | Low – no data leakage. |
| Integrity | VI:L | Low – no data tampering. |
| Availability | VA:H | High – the process crashes, causing a DoS. |
| Authentication | AT:N | No authentication required. |
| Privilege | PR:N | No special privileges needed. |
| User Interaction | UI:P | Requires a user to run MP4Box with the malicious file (or a service to process it). |
Practical consequences
- Media‑processing pipelines (e.g., video transcoding services, streaming platforms) that rely on GPAC MP4Box will become unavailable when a crafted scene file is processed.
- Embedded devices (set‑top boxes, media players) that use MP4Box for on‑device transcoding can be taken offline.
- Batch processing jobs that run under a cron job or a CI/CD pipeline will fail, potentially causing build or deployment delays.
- In a multi‑tenant SaaS offering, a single malicious user could disrupt service for all tenants.
- GPAC MP4Box 26.07.0 (and any builds that embed this version without patching the scene‑graph teardown logic).
- Upgrade to GPAC MP4Box ≥ 26.07.1 (or the latest stable release). The upstream patch removes the dangling pointer by clearing the node reference before calling
gf_node_unregister(). - Block large scene files:
SecRule REQUEST_FILENAME "@rx \.scene$" "id:1001,phase:2,deny,log,msg:'Blocked scene file upload'" - Rate‑limit uploads:
SecRule REQUEST_HEADERS:Content-Type "multipart/form-data" "id:1002,phase:2,block,log,msg:'Rate limit exceeded'" - Validate file content: Use a custom ModSecurity rule that checks for repeated
PROTOtokens (requires a custom Lua script). - High priority for environments where MP4Box is exposed to untrusted input (media‑transcoding services, web‑based editors, embedded devices).
- Medium priority for internal or isolated use (e.g., a lab environment or a single‑user workstation).
- Immediate action: Apply the patch or upgrade to the latest GPAC release.
- If patching is delayed: Implement the sandbox/workaround strategy and monitor for crashes.
🛡️ Remediation & Mitigation
1. Exact affected versions
2. Upgrade recommendation
3. Workarounds (if upgrade is not immediately possible)
| Workaround | How to apply | Notes |
|---|---|---|
| Disable scene graph processing | If the application can be configured to skip scene files (e.g., use a different media format or a different processing path), do so. | Not applicable if scene files are required. |
| Validate scene files before processing | Implement a pre‑processing step that parses the scene file and ensures that no node is referenced in more than one PROTO node_code list. | Requires custom code or a third‑party validator. |
| Run MP4Box in a sandbox | Execute the binary inside a container or a restricted chroot with no network access. | Limits impact to the container; still a crash but isolated. |
Set ulimit -c 0 | Disable core dumps to avoid leaking memory contents. | Does not prevent the crash but reduces forensic data. |
4. Detection
| Indicator | Log Pattern / IoC | How to detect |
|---|---|---|
| Segmentation fault | Segmentation fault (core dumped) in system logs or application stdout | Monitor /var/log/syslog, /var/log/messages, or application logs for this string. |
| Core dump file | Presence of core files in /var/lib/mp4box/ or /tmp/ | Watch for new files matching core.* or core in the working directory. |
| Repeated crashes | mp4box process exit code 139 (SIGSEGV) | Use process monitoring tools (e.g., systemd unit with Restart=on-failure) to alert on repeated failures. |
| Unusual scene file uploads | Files with .scene extension containing repeated PROTO definitions | Inspect upload logs for patterns such as PROTO appearing >1 time per file. |
5. Mitigation via WAF / ModSecurity
Because the vulnerability is triggered by a local file processed by a command‑line tool, a WAF cannot directly mitigate it. However, if the tool is exposed through a web API, you can:
⚠️ Urgency
| Metric | Value | Interpretation |
|---|---|---|
| CVSS Score | 6.9 | Medium severity |
| Availability Impact | High | Service outage is the primary risk |
| Exploit Complexity | Low | Requires only a crafted scene file and local execution |
| CISA KEV | No | No known exploit in the wild at the time of publication |
| Patch Availability | Yes | Fixed in 26.07.1 |
Priority Recommendation
Summary
CVE‑2026‑134682 is a local use‑after‑free that causes MP4Box to crash when processing a crafted scene file. The flaw is CWE‑416 and results in a high‑impact DoS with no confidentiality or integrity compromise. The simplest mitigation is to upgrade to a patched version; otherwise, isolate the tool or validate input to prevent the crash.
[🤖 CVE Professor AI Security Engine]
FOFA Query