Skip to main content
Vulnerability Database/CVE-2026-79113

CVE-2026-79113: OpenAPV Heap Buffer Overflow Vulnerability

CVE-2026-79113 is a heap-based buffer overflow in OpenAPV versions before 1.1.1.0 affecting the read_bitstream function. This article covers technical details, affected versions, security impact, and mitigation strategies.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-79113 Overview

CVE-2026-79113 is a heap-based buffer overflow in the read_bitstream function of OpenAPV, the Academy Software Foundation's reference implementation of the Advanced Professional Video codec. The flaw affects OpenAPV versions prior to 1.1.1.0 and is classified under CWE-190: Integer Overflow or Wraparound. An attacker who supplies a crafted bitstream to a vulnerable decoder can trigger an out-of-bounds heap write during input parsing.

Critical Impact

Processing an attacker-controlled APV bitstream can corrupt heap memory in the decoder process, enabling denial of service and potentially local code execution in applications that embed the OpenAPV library.

Affected Products

  • OpenAPV versions prior to 1.1.1.0
  • Applications and media pipelines embedding the OpenAPV decoder library (oapv)
  • Downstream builds using the read_bitstream path in app/oapv_app_dec.c

Discovery Timeline

  • 2026-10-03 - CVE-2026-79113 published to the National Vulnerability Database
  • 2026-10-06 - Last updated in NVD database

Technical Details for CVE-2026-79113

Vulnerability Analysis

The vulnerability resides in the OpenAPV decoder's bitstream ingestion logic. The read_bitstream routine in app/oapv_app_dec.c reads access unit (AU) bytes from input into a fixed-size buffer bs_buf without validating read_size against the MAX_BS_BUF ceiling. When the incoming AU exceeds the compiled buffer size, the loop writes past the end of the heap allocation.

A related defect in src/oapv.c compounds the issue. Frame width and height are signaled using 24-bit fields, so the product required_stride * comp_h can exceed INT_MAX. Because the pre-patch code stored this result in a 32-bit int, the multiplication wrapped and a too-small required_bsize could satisfy the sanity check against imgb->bsize[c], allowing undersized image buffers to pass validation.

Root Cause

The root cause is twofold: a missing boundary check in the bitstream read loop and a 32-bit integer multiplication that wraps on large frame geometries. Together these omissions let an attacker steer heap writes beyond the destination buffer during parsing of a crafted APV sample.

Attack Vector

Exploitation requires local delivery of a malicious APV file or stream to a process that decodes it. The decoder parses attacker-controlled bytes before any sanity check rejects the oversized AU, so no authentication or user interaction beyond opening the file is required.

c
// Patch excerpt from app/oapv_app_dec.c adding the missing bounds check
                     logerr("ERR: Cannot read bitstream!\n");
                     return -1;
                 }
+                if(read_size >= MAX_BS_BUF) {
+                    logerr("ERR: bitstream buffer overflow\n");
+                    return -1;
+                }
                 bs_buf[read_size] = b;
                 read_size++;
                 au_size--;
// Source: https://github.com/AcademySoftwareFoundation/openapv/commit/b5cc54bc786040ba3ac54020e7320e0add51e107
c
// Patch excerpt from src/oapv.c promoting the size calculation to s64
     for(int c = 0; c < imgb->np; c++) {
         int comp_w = aligned_w >> (c > 0 ? get_chroma_sft_w(ctx->fh.fi.chroma_format_idc) : 0);
         int comp_h = aligned_h >> (c > 0 ? get_chroma_sft_h(ctx->fh.fi.chroma_format_idc) : 0);
+        // frame_width/height are signaled in 24 bits, so the required buffer
+        // size can exceed INT_MAX; compute in s64 so the product does not wrap
+        // and let a too-small (int) bsize incorrectly pass the check
         int required_stride = comp_w * byte_depth;
-        int required_bsize = required_stride * comp_h;
+        s64 required_bsize = (s64)required_stride * comp_h;
 
-        if(imgb->bsize[c] < required_bsize) {
+        if((s64)imgb->bsize[c] < required_bsize) {
             return OAPV_ERR_INVALID_ARGUMENT;
         }
     }
// Source: https://github.com/AcademySoftwareFoundation/openapv/commit/b5cc54bc786040ba3ac54020e7320e0add51e107

Detection Methods for CVE-2026-79113

Indicators of Compromise

  • Decoder processes terminating with SIGSEGV or heap corruption aborts while parsing APV content
  • APV files whose declared access unit size approaches or exceeds the MAX_BS_BUF compile-time constant
  • APV streams reporting frame dimensions whose product with byte depth exceeds INT_MAX

Detection Strategies

  • Inventory build artifacts for the oapv library and flag any version earlier than 1.1.1.0
  • Instrument decoder builds with AddressSanitizer or HWASan in test pipelines to surface the out-of-bounds write
  • Hash sample files against the regression corpus referenced in GitHub Issue #219

Monitoring Recommendations

  • Alert on repeated crashes of media processing services tied to APV file ingestion
  • Capture core dumps from decoder workers to confirm heap metadata corruption near bs_buf
  • Track outbound process behavior from media services for signs of post-crash code execution attempts

How to Mitigate CVE-2026-79113

Immediate Actions Required

  • Upgrade OpenAPV to version 1.1.1.0 or later across all build pipelines and runtime deployments
  • Rebuild and redistribute any application statically linking the oapv library after the upgrade
  • Restrict decoding of untrusted APV content until the patched binary is in place

Patch Information

The fix is delivered in the merged pull request GitHub Pull Request #226, landed in commit b5cc54bc. It adds the MAX_BS_BUF guard in read_bitstream and promotes required_bsize to s64 to prevent integer wraparound. Review the full set of changes in the v0.3.0.0...v1.1.1.0 comparison.

Workarounds

  • Sandbox APV decoding in a least-privilege process or container with no network egress
  • Pre-validate APV inputs by rejecting files whose signaled AU size exceeds the local MAX_BS_BUF
  • Disable APV decoding paths in media applications that do not require the format
bash
# Verify the installed OpenAPV version and upgrade from source
git clone https://github.com/AcademySoftwareFoundation/openapv.git
cd openapv
git checkout v1.1.1.0
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --parallel
# Confirm the patched commit is included
git log --oneline | grep b5cc54bc

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.