Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessHost crafted MPEG-2 TS file
-
DeliveryUser processes stream in GPAC
-
ExploitOverflow AIT descriptor array index
-
ExecutionOut-of-bounds heap write
-
ImpactMemory corruption / possible code execution
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires GPAC (≤26.07.0) to parse an attacker-controlled MPEG-2 transport stream whose AIT (Application Information Table) section declares more application descriptors than the fixed application_descriptors_id array can hold, triggering the out-of-bounds write when index_app_desc_id exceeds the array bounds. The key LIMITING factor is user interaction (UI:P in the vector): the vulnerable code path only runs when someone - or an automated workflow - feeds the malicious stream into GPAC, so there is no unsolicited remote trigger. No authentication or special privileges are needed (PR:N), and no non-default configuration is required beyond invoking the M2TS/AIT parsing path; realistic risk is therefore concentrated in environments that automatically ingest untrusted media (transcoding services, upload processors). |
| Impact | This is a medium-severity (CVSS 4.0 base 5.3) out-of-bounds write in GPAC's MPEG-2 TS AIT parser, and the signals converge on a moderate-to-low real-world priority rather than an emergency. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:P) indicates no authentication is required and low attack complexity, but it explicitly requires user interaction (UI:P) - the victim must process an attacker-supplied media stream - which caps the impact metrics at Low across confidentiality, integrity, and availability (VC:L/VI:L/VA:L), with no scope change. The exploit maturity is marked E:P (proof-of-concept), consistent with the publicly posted POC archive; this means publicly available exploit code exists but is distinct from confirmed active exploitation. The CVE is NOT in CISA KEV and no EPSS probability was supplied in the input, so widespread opportunistic exploitation cannot be inferred. SSVC-style reasoning: exploitation is at 'proof-of-concept,' it is not automatable (requires a user to open a crafted file), and technical impact is partial (memory corruption bounded to Low per the vendor scoring). Net: a legitimate bug to patch on a normal cycle, not a drop-everything issue, unless GPAC is used in an automated/server-side media-processing pipeline that ingests untrusted streams. |
| Exploit ScenarioDerived | An attacker crafts a malicious MPEG-2 transport stream containing an AIT (Application Information Table) with more application descriptors than the fixed-size descriptor array can hold, then delivers it via a web download, email attachment, or streaming URL. When a user or an automated pipeline processes the file with a vulnerable GPAC build (≤26.07.0), gf_m2ts_decode_ait writes past the bounds of application_descriptors_id, corrupting adjacent heap memory. A public proof-of-concept (poc_gpac_g1.zip) has been released, lowering the barrier to reproduction. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 13, 2026
An out-of-bounds write in GPAC's MPEG-2 transport stream AIT parser (versions up to and including 26.07.0) allows remote attackers to corrupt memory by supplying a crafted stream whose AIT section declares more application descriptors than the fixed application_descriptors_id array can hold. Exploitation requires user interaction - someone or an automated workflow must feed the malicious stream into GPAC's M2TS/AIT parsing path - but no authentication or privileges are needed (CVSS:4.0 base 5.3; assessed CVSS:3.1 AV:N/AC:L/PR:N/UI:R, C:L/I:L/A:L). Publicly available exploit code exists (a PoC archive is linked from the VulDB entry and the upstream issue), though there is no evidence of confirmed active exploitation (not in CISA KEV); the practical risk is concentrated in services that automatically ingest untrusted media, such as transcoding pipelines and upload processors.
RemediationAI
Apply the upstream fix identified by the vendor as commit 6d2c21a1a688abb20d0111b608db3b6f44d348f4 (drawn from pull request https://github.com/gpac/gpac/pull/3932), which adds the missing bounds check on index_app_desc_id and skips the remainder of an oversized descriptor loop; note that this is an upstream fix available (PR/commit) and a released patched version number was not independently confirmed from the available data, so verify that your build or distribution has incorporated the commit before treating the issue as closed. Until a patched binary is deployed, the most effective compensating control is to keep untrusted files away from the M2TS/AIT parsing path: disable or refuse MPEG-2 transport stream input to MP4Box/gpac-based tooling (for example, do not run m2ts demuxing or AIT inspection against user-supplied uploads), accepting the trade-off that legitimate broadcast/TS workflows must be handled by a separate, isolated instance. Where TS processing is unavoidable, run the parser in a sandbox or container with restricted memory and filesystem access and constrain it with strict resource limits, since the impact of an out-of-bounds write is memory corruption and may be escalated to control-flow or heap-manipulation attacks. Pre-screen or re-mux inbound transport streams so that AIT sections with unusually large application descriptor lists are rejected before reaching GPAC, and monitor ingestion points for crash/abnormal-exit patterns that would indicate an exploitation attempt; these measures reduce - but do not eliminate - exposure and are inferior to applying the upstream commit. Additional context and disclosure details are at https://vuldb.com/vuln/417465, https://vuldb.com/vuln/417465/cti, and https://github.com/gpac/gpac/issues/3930.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The affected code, gf_m2ts_decode_ait in src/media_tools/ait.c, parses the Application Information Table carried in MPEG-2 transport streams - the DVB/MPEG signalling structure that describes interactive applications broadcast alongside audio/video. Each AIT entry contains an application_descriptors_loop_length describing a list of descriptors, and GPAC stores decoded descriptor identifiers in the fixed-size array application->application_descriptors_id, indexed by application->index_app_desc_id. The vulnerable loop reads each descriptor tag with gf_bs_read_int(bs,8) and writes into that array without validating that index_app_desc_id remains within GF_ARRAY_LENGTH(application->application_descriptors_id). An AIT section advertising an oversized descriptor list therefore drives the index past the array bound and produces an out-of-bounds write (CWE-787, memory corruption / buffer overflow, matching the vendor tags). Because the offending data is read through a bitstream reader from attacker-controlled stream bytes, the bypass is triggered purely by parsing rather than by any protocol-level authentication. The upstream fix (commit 6d2c21a1a688abb20d0111b608db3b6f44d348f4, PR #3932) adds an explicit bounds check before the descriptor tag read: if index_app_desc_id reaches the array length, it logs a warning, skips the remaining descriptor-loop bytes with gf_bs_skip_bytes, and breaks out of the loop, preserving stream synchronization without further writes. The absence of such a check in all earlier versions is the root cause, and the EPSS/CVSS:4.0 Exploit Maturity value of 'P' (proof-of-concept) reflects the public PoC rather than observed in-the-wild abuse.
Know when Gpac gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:P/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
File is delivered remotely but requires the victim to process it (AV:N, UI:R); no auth needed (PR:N); OOB write yields bounded memory corruption, so C/I/A each Low.
Primary rating from Vendor (VulDB).
CVSS VectorVendor: VulDB
Lifecycle Timeline
3DescriptionCVE.org
A vulnerability has been found in GPAC up to 26.07.0. This vulnerability affects the function gf_m2ts_decode_ait of the file src/media_tools/ait.c of the component AIT Parser. Such manipulation leads to out-of-bounds write. The attack may be launched remotely. The exploit has been disclosed to the public and may be used. The name of the patch is 6d2c21a1a688abb20d0111b608db3b6f44d348f4. Applying a patch is advised to resolve this issue.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Heap Buffer Overflow vulnerability in GPAC version 2.3-DEV-rev617-g671976fcc-master, allows attackers to execute arbitra
NULL Pointer Dereference in GitHub repository gpac/gpac prior to 2.2.2. Rated critical severity (CVSS 9.8), this vulnera
GPAC mp4box 2.1-DEV-revUNKNOWN-master has a use-after-free vulnerability in function gf_isom_dovi_config_get. Rated crit
Use After Free in GitHub repository gpac/gpac prior to v2.1.0-DEV. Rated critical severity (CVSS 9.8), this vulnerabilit
NULL Pointer Dereference in the "isomedia/track.c" module's "MergeTrack()" function of GPAC v0.5.2 allows attackers to e
An issue was discovered in libgpac.a in GPAC 0.8.0, as demonstrated by MP4Box. Rated critical severity (CVSS 9.8), this
An issue was discovered in MP4Box in GPAC 0.7.1. Rated critical severity (CVSS 9.8), this vulnerability is remotely expl
Out-of-bounds Read in GitHub repository gpac/gpac prior to 2.2.2. Rated critical severity (CVSS 9.1), this vulnerability
A vulnerability, which was classified as critical, has been found in GPAC 2.3-DEV-rev40-g3602a5ded.c. Rated high severit
A vulnerability, which was classified as problematic, was found in GPAC 2.1-DEV-rev490-g68064e101-master. Rated high sev
An exploitable integer overflow vulnerability exists within the MPEG-4 decoding functionality of the GPAC Project on Adv
An exploitable integer overflow vulnerability exists within the MPEG-4 decoding functionality of the GPAC Project on Adv
EUVD-2026-98926
GHSA-xg2v-p5jc-x9xf
NVD
CVE.org
EPSS
VulDB
Exploit-DB