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.
// 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
// 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
# 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

