Skip to main content

GPAC CVE-2026-109827

| EUVDEUVD-2026-98926 LOW
Out-of-bounds Write (CWE-787)
2026-10-13 VulDB GHSA-xg2v-p5jc-x9xf
2.1
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Host crafted MPEG-2 TS file
  2. Delivery
    User processes stream in GPAC
  3. Exploit
    Overflow AIT descriptor array index
  4. Execution
    Out-of-bounds heap write
  5. Impact
    Memory 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.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

GPAC 26.07

Affected Packages

euvd gpac no fix

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

Vendor (VulDB) PRIMARY 2.1 MEDIUM
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
vuln.today AI 6.3 MEDIUM

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.

3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:L
4.0 AV:N/AC:L/AT:N/PR:N/UI:P/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
Low
Vulnerable system: Integrity
Low
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

3
Severity Changed
Oct 13, 2026 - 17:22 NVD
MEDIUM LOW
CVSS changed
Oct 13, 2026 - 17:22 NVD
5.3 (MEDIUM) 2.1 (LOW)
CVE Published
Oct 13, 2026 - 16:45 cve.org
MEDIUM 5.3

DescriptionCVE.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

EPSS Score
0.3%
Top 80% exploitable
Prevalence
Low
niche open-source multimedia framework, limited enterprise production footprint
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High

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.

SignalValue
Severity LOW
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
Low

Priority Score

30
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +10
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

More in Gpac

View all
CVE-2023-46932 CRITICAL POC
9.8 Dec 09

Heap Buffer Overflow vulnerability in GPAC version 2.3-DEV-rev617-g671976fcc-master, allows attackers to execute arbitra

CVE-2023-2840 CRITICAL POC
9.8 May 22

NULL Pointer Dereference in GitHub repository gpac/gpac prior to 2.2.2. Rated critical severity (CVSS 9.8), this vulnera

CVE-2022-36190 CRITICAL POC
9.8 Aug 17

GPAC mp4box 2.1-DEV-revUNKNOWN-master has a use-after-free vulnerability in function gf_isom_dovi_config_get. Rated crit

CVE-2022-1795 CRITICAL POC
9.8 May 18

Use After Free in GitHub repository gpac/gpac prior to v2.1.0-DEV. Rated critical severity (CVSS 9.8), this vulnerabilit

CVE-2021-28300 CRITICAL POC
9.8 Apr 14

NULL Pointer Dereference in the "isomedia/track.c" module's "MergeTrack()" function of GPAC v0.5.2 allows attackers to e

CVE-2020-11558 CRITICAL POC
9.8 Apr 05

An issue was discovered in libgpac.a in GPAC 0.8.0, as demonstrated by MP4Box. Rated critical severity (CVSS 9.8), this

CVE-2018-13005 CRITICAL POC
9.8 Jun 29

An issue was discovered in MP4Box in GPAC 0.7.1. Rated critical severity (CVSS 9.8), this vulnerability is remotely expl

CVE-2023-2838 CRITICAL POC
9.1 May 22

Out-of-bounds Read in GitHub repository gpac/gpac prior to 2.2.2. Rated critical severity (CVSS 9.1), this vulnerability

CVE-2023-0841 HIGH POC
8.8 Feb 15

A vulnerability, which was classified as critical, has been found in GPAC 2.3-DEV-rev40-g3602a5ded.c. Rated high severit

CVE-2022-4202 HIGH POC
8.8 Nov 29

A vulnerability, which was classified as problematic, was found in GPAC 2.1-DEV-rev490-g68064e101-master. Rated high sev

CVE-2021-21850 HIGH POC
8.8 Aug 25

An exploitable integer overflow vulnerability exists within the MPEG-4 decoding functionality of the GPAC Project on Adv

CVE-2021-21849 HIGH POC
8.8 Aug 25

An exploitable integer overflow vulnerability exists within the MPEG-4 decoding functionality of the GPAC Project on Adv

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy