Skip to main content

OpenAPV CVE-2026-79113

| EUVDEUVD-2026-91869 MEDIUM
Integer Overflow or Wraparound (CWE-190)
2026-10-03 mitre GHSA-cqc9-4w54-7f36
5.1
CVSS 4.0 · Vendor: mitre
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted APV bitstream file
  2. Delivery
    Victim decodes it with OpenAPV
  3. Exploit
    Integer overflow bypasses buffer-size check
  4. Execution
    Heap overflow in read_bitstream
  5. Impact
    Decoder crash or memory corruption

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires the OpenAPV decoder (oapvd / the oapv_app_dec application) to parse an attacker-crafted APV bitstream on versions before 1.1.1.0; the malformed stream signals frame width/height or VLC coefficient values that overflow an int size calculation and bypass the buffer-size check in read_bitstream. The key limiting factor is the LOCAL attack vector (AV:L): the attacker cannot trigger this remotely without first delivering the malicious file to a workflow or tool that decodes it. No special non-default configuration or authentication is required (PR:N) - any decode of untrusted APV input on an affected build is sufficient - but the realistic impact is constrained (vendor-rated LOW C/I/A), pointing to crash or limited corruption rather than straightforward code execution.

Impact

This is a medium-severity, low-priority issue in practical terms. The vendor-supplied CVSS 4.0 vector (base 5.1) rates attack vector as LOCAL (AV:L), meaning an attacker cannot reach the flaw over a network directly - a maliciously crafted APV bitstream must be delivered to and processed by the OpenAPV decoder on the target host. Although PR:N indicates no privileges are required, the local vector and the conservative impact ratings (VC:L/VI:L/VA:L) sharply limit real-world risk: a heap-based buffer overflow driven by an integer overflow (CWE-190) most plausibly results in a decoder crash or limited memory corruption rather than reliable remote code execution, which is consistent with the vendor scoring only LOW across confidentiality, integrity, and availability. No EPSS score, CISA KEV listing, or public exploit was provided in the input, so there is no signal of active or probable widespread exploitation. The signals are internally consistent - there is no CVSS-vs-description conflict - but the LOW impact metrics for a heap overflow are notably conservative; defenders handling untrusted video with this decoder should still patch, while treating this as routine hardening rather than an urgent threat.

Exploit ScenarioDerived

An attacker crafts a malformed APV bitstream in which signaled frame dimensions or VLC coefficient values trigger an integer overflow that bypasses the decoder's buffer-size check. When a victim decodes this file with a vulnerable OpenAPV build (before 1.1.1.0) - for example via the oapv_app_dec tool or an integrated decode pipeline - the undersized allocation is overflowed in read_bitstream, corrupting the heap. No public exploit code was identified in the provided data, and the local attack vector means the attacker must first get the file onto a system where it will be decoded.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 03, 2026

Decoding an attacker-crafted APV bitstream with the Academy Software Foundation's OpenAPV reference implementation before version 1.1.1.0 can overflow a heap buffer in the read_bitstream/decoder path, because integer wraparound in the frame buffer-size calculation lets a too-small allocation pass the internal size check. The affected component is the oapvd decoder and the oapv_app_dec sample application; no authentication or non-default configuration is required, but the attack vector is local (AV:L), so exploitation requires the victim to open or process a malicious .apv-style file. Vendor-rated impact is limited (low confidentiality, integrity, and availability per the assessed CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:L vector), consistent with a crash or constrained memory corruption rather than reliable code execution, and no public exploit code or CISA KEV active-exploitation record was identified at time of analysis.

RemediationAI

Upgrade OpenAPV to version 1.1.1.0 or later, which is the vendor-released patched version referenced by the upstream release comparison; the fix is carried in commit https://github.com/AcademySoftwareFoundation/openapv/commit/b5cc54bc786040ba3ac54020e7320e0add51e107 (merged via pull request https://github.com/AcademySoftwareFoundation/openapv/pull/226, issue https://github.com/AcademySoftwareFoundation/openapv/issues/219). The patch hardens four points: it widens the frame-buffer size computation from int to s64 so the stride-times-height product cannot wrap past the imgb->bsize[c] check, adds an explicit read_size >= MAX_BS_BUF guard in read_bitstream (app/oapv_app_dec.c), converts the VLC symbol accumulator to u32 with a masked shift count so malformed streams cannot trigger signed-overflow or out-of-range shift undefined behavior, and adds malformed-bitstream rejection for DC/AC coefficient values (abs_dc_diff > 32767, negative run, negative level). Where immediate upgrading is not possible, compensating controls are to refuse to decode APV bitstreams from untrusted or unverified sources, sandbox or containerize the decoder process with restrictive memory and CPU limits and a seccomp profile, run decode jobs under a low-privilege account with no access to production storage, and validate file provenance and size before feeding input to oapvd; these reduce reachability and blast radius but do not remove the underlying heap overflow, and sandboxing carries a performance cost for high-bitrate professional video workflows. Note that this is a local (AV:L) issue, so perimeter controls such as network filtering are not an effective mitigation; the exposure is gated by delivering a malicious file to a decoding workflow. Vendor guidance is available via https://aswf.io and the upstream repository.

Affected VersionsENISA

OpenAPV 0 <1.1.1.0

Affected Packages

euvd openapv fix: 1.1.1.0

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

OpenAPV is the Academy Software Foundation's open-source implementation of the APV (Advanced Professional Video) intra-only codec, used for high-bitrate professional video capture and post-production workflows; the vulnerable code is in the bitstream parsing layer (src/oapv_vlc.c, src/oapv.c) and the file reader (app/oapv_app_dec.c). The root cause class is CWE-190 (Integer Overflow or Wraparound): in dec_frm_prepare() the required frame buffer size was computed as an int product of required_stride and comp_h, so a malformed stream signaling large 24-bit frame width/height values could wrap the product and present a small positive value that incorrectly satisfied the imgb->bsize[c] < required_bsize guard, after which the decoder writes past the undersized heap allocation. The same malformed-input surface includes missing bounds enforcement in read_bitstream (no check that read_size stays below MAX_BS_BUF), signed-overflow undefined behavior and unbounded shift counts in the VLC coefficient decoder (dec_vlc_read_1bit_read/dec_vlc_read, where symbol was a signed int and the shift was later masked with 1u << (k & 31) to keep the shift count in [0,31]), and absent range validation on decoded DC/AC coefficient values (abs_dc_diff > 32767, negative run, negative level). The upstream fix therefore combines a widened s64 size computation, an explicit bitstream-buffer overflow check, unsigned arithmetic to make wraparound behavior defined, and malformed-bitstream rejection paths, which is why the CVE is tagged both Buffer Overflow and Integer Overflow. The CPE entry cpe:2.3:a:aswf:openapv:*:*:*:*:*:*:*:* is a wildcard version match, but the upstream compare link v0.3.0.0...v1.1.1.0 indicates the patched baseline is 1.1.1.0.

Know when Openapv 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 (mitre) PRIMARY 5.1 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N
vuln.today AI 5.9 MEDIUM

Flaw is reached only by locally decoding a crafted file (AV:L); no privileges or special config needed (PR:N); heap overflow yields limited corruption/crash, so C/I/A each Low.

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

Primary rating from Vendor (mitre).

CVSS VectorVendor: mitre

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
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

1
Patch available
Oct 03, 2026 - 02:00 EUVD

DescriptionCVE.org

OpenAPV before 1.1.1.0 has a read_bitstream heap-based buffer overflow.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Low
niche, newly-released professional video codec with limited production deployment
Data Quality
6 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor GitHub VulDB

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Medium
Technical Impact
Partial

Priority Score

26
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +26
PoC: 0
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.

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Vendor StatusVendor

SUSE

Severity: Moderate

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