CVE-2026-97579

Executive Summary

CVE-2026-97579 is a memory-safety defect in the Linux kernel's MediaTek video codec (vcodec) driver. The AV1 decoder slice/tile setup path copies tile column-start and row-start arrays derived from the bitstream into fixed-size mi_col_starts[] and mi_row_starts[] arrays without validating the tile counts against array capacity, allowing an out-of-bounds write. Systems most at risk are those running MediaTek SoCs (Chromebooks, Android-based Linux devices, and embedded/automotive boards) where an attacker who can supply a crafted AV1 bitstream to the hardware decoder can corrupt kernel memory. Given the lack of a published patch, CVSS score, and public exploit, risk is driven primarily by exposure of the AV1 decode path to untrusted media.

Technical Analysis

The vulnerability resides in vdec_av1_slice_setup_tile(), a function in the MediaTek vcodec driver that configures AV1 tile layout for hardware decoding. During AV1 decoding, a frame is partitioned into tiles; the bitstream's tile_info carries the number of tile columns and tile rows, and the decoder must build index arrays (mi_col_starts[], mi_row_starts[]) describing the starting superblock column and row for each tile.

The flaw class is a classic out-of-bounds write (CWE-787) driven by an unvalidated, attacker-influenced length. The function copies tile_cols + 1 entries into mi_col_starts[] and tile_rows + 1 entries into mi_row_starts[] directly from the bitstream-supplied tile_info. The provided description explicitly states the fix is to "bound the copy to the array capacity," confirming that the pre-fix code performed a copy whose size was governed by the attacker-controlled tile count rather than by the compile-time/struct-defined capacity of the destination arrays.

The attack surface is the media decode path: any pipeline that routes an untrusted AV1 stream to the MediaTek hardware decoder — a webpage or app rendering AV1 video, a media player, or a streamed/attached file — can deliver the malformed tile_info. Because the copy occurs during slice/tile setup in the kernel driver, the write lands in kernel memory, not merely userspace heap. The precise downstream consequence (adjacent structure corruption, kernel panic/DoS, or escalable primitive) is not specified in the available data and should not be assumed; the confirmed impact is out-of-bounds kernel write reachable from a crafted bitstream.

No CVSS score, CWE assignment, EPSS value, or affected-version enumeration was published in the supplied data. The analysis above is bounded strictly to the described mechanism.

Exploitation Scenarios

No public proof-of-concept, exploit code, or Nuclei template is available for CVE-2026-97579. The following attack chain is described at the vulnerability-class level; no specific function names beyond vdec_av1_slice_setup_tile(), tile_cols, tile_rows, or the mi_col_starts[]/mi_row_starts[] arrays named in the description are asserted.

1. Reconnaissance / target identification. An attacker identifies a target device whose kernel runs the vulnerable MediaTek vcodec driver — typically an SoC platform (e.g., Chromebook, embedded media device) where the hardware AV1 decoder is exposed and reachable from an application, browser, or media playback path that accepts untrusted content.

2. Triggering the flaw class. The attacker crafts an AV1 bitstream whose tile_info declares tile column/row counts large enough that tile_cols + 1 or tile_rows + 1 exceeds the capacity of the destination mi_col_starts[] / mi_row_starts[] arrays. When the stream reaches vdec_av1_slice_setup_tile(), the unbounded copy overruns the array bounds — the direct analog of an unvalidated-length copy into a fixed-size buffer.

3. Payload / execution method (class-level). The out-of-bounds write is delivered through malformed media rather than a network protocol exploit: whatever adjacent kernel memory follows the arrays is overwritten. Depending on layout, the immediate observable effect may be a kernel fault/panic (denial of service); a controlled adjacent-object overwrite could, in principle, form the basis of a privilege-escalation primitive. No specific corruption target or escalation gadget is claimed here, as the data does not identify one.

4. Post-exploitation impact. The realistic near-term outcome is denial of service via kernel instability triggered by a single crafted file or stream. Where the overwrite can be shaped, the primitive is a kernel-context memory corruption that an attacker with local or rendering-path access could attempt to leverage. No data supports claims of remote code execution or a documented in-the-wild weaponization.

Impact Assessment

This is a local/high-privilege-context kernel memory-corruption defect in a hardware video-decoding driver, not a remotely network-exploitable service flaw. Business impact concentrates on fleets of MediaTek-based endpoints — consumer and enterprise Chromebooks, embedded signage/automotive/media devices — where untrusted AV1 content is routinely processed.

Blast radius factors:

• Availability: high — out-of-bounds kernel writes commonly cause panics or device resets (DoS) from a single malformed stream.
• Confidentiality/Integrity: potentially high if the overwrite is controllable, but unproven from the available data.
• Attack complexity: elevated — the attacker must deliver a bitstream that passes AV1 parsing far enough to reach tile setup and must satisfy the tile-count precondition; exploitability is constrained by bitstream validity checks that precede this function.

No CVSS vector, EPSS score, CISA KEV entry, or affected-version range is available, so quantitative scoring is not asserted. Treat impact as device stability and potential local privilege escalation on affected MediaTek platforms, with priority weighted by exposure of the AV1 decode path to adversarial media.

Detection Guidance

Detections below target the generic signature of this bug: malformed AV1 tile metadata reaching the MediaTek vcodec decoder and the resulting kernel-level memory-corruption symptoms. Because the vulnerability is not network-protocol-oriented, network rules focus on delivery of AV1 content and kernel-fault telemetry rather than a wire exploit packet.

Sigma Rule

title: Linux Kernel MediaTek vcodec AV1 Tile Setup Out-of-Bounds Corruption
id: 3a9f1c20-9759-4b79-8f01-0a2b6c7d9e10
status: experimental
description: Detects kernel fault/KASAN reports tied to the MediaTek vcodec AV1 slice/tile setup path, consistent with CVE-2026-97579.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-97579
author: valtersit.com
date: 2026/01/01
logsource:
  product: linux
  service: kernel
detection:
  selection_symbol:
    - 'vdec_av1_slice_setup_tile'
    - 'mi_col_starts'
    - 'mi_row_starts'
  selection_symptom:
    - 'BUG: KASAN'
    - 'out-of-bounds'
    - 'general protection fault'
    - 'kernel panic'
  selection_driver:
    - 'mediatek'
    - 'vcodec'
  condition: selection_symbol or (selection_symptom and selection_driver)
falsepositives:
  - Legitimate kernel media driver logs during normal AV1 playback
  - Unrelated kernel memory faults containing generic OOB terminology
level: high
tags:
  - attack.t1203
  - cve.2026-97579

YARA Rule

rule CVE_2026_97579_AV1_Tile_Array_Bound
{
    meta:
        description = "Heuristic detection of AV1 tile-info payloads with tile counts large enough to overflow fixed tile-start arrays in MediaTek vcodec (CVE-2026-97579)"
        author = "valtersit.com"
        reference = "https://nvd.nist.gov/vuln/detail/CVE-2026-97579"
        date = "2026-01-01"

    strings:
        // AV1 sequence/frame header marker bytes commonly present in OBU streams
        $av1_obu = { 0A 00 00 00 }   // truncated OBU framing heuristic
        $tile_kw  = "mi_col_starts" nocase

    condition:
        // Placeholder heuristic: a valid AV1 stream container that also carries
        // tile-configuration markers. Final tuning requires a live sample.
        uint16(0) == 0x0000 or $tile_kw
}

Note: No known malicious sample exists for this CVE. The YARA rule is a framework heuristic keyed to AV1 media containers and tile-configuration markers, to be tuned against trusted AV1 parsing output; it is not a validated signature.

Suricata IDS Rule

alert http any any -> $HOME_NET any (msg:"CVE-2026-97579 Possible AV1 Media Delivery to MediaTek vcodec Decode Path"; flow:established,to_client; file_data; content:"|0A 00 00 00|"; depth:4; content:"|00 00 00 00|"; within:64; classtype:attempted-dos; reference:cve,2026-97579; reference:url,nvd.nist.gov/vuln/detail/CVE-2026-97579; sid:202697579; rev:1;)

Caveat: This is a delivery-focused rule for AV1 content reaching an endpoint; the exploit itself occurs in-kernel and is not observable directly on the wire.

Elastic Detection

sequence by host.id with maxspan=30s
  [ process where event.category == "file" and file.mime_type : "video/av01" ]
  [ process where event.category == "process" and
      process.name : ("chrome","chromium","mpv","ffmpeg","vlc") and
      process.args : ("*.av1","*.obu","*.ivf") ]

Complements kernel telemetry (dmesg/journal) where the actual OOB report surfaces.

Splunk SPL Query

index=linux sourcetype=kernel_log OR sourcetype=syslog
| search ("vdec_av1_slice_setup_tile" OR "mi_col_starts" OR "mi_row_starts"
          OR ("vcodec" AND "mediatek" AND ("out-of-bounds" OR "KASAN" OR "panic")))
| stats count min(_time) as first_seen max(_time) as last_seen by host, message
| convert ctime(first_seen) ctime(last_seen)
| sort - last_seen

Wazuh OSSEC Rule

<group name="linux,kernel,cve_2026_97579,">
  <rule id="2026975" level="12">
    <decoded_as>syslog</decoded_as>
    <match>vdec_av1_slice_setup_tile|mi_col_starts|mi_row_starts</match>
    <description>CVE-2026-97579: MediaTek vcodec AV1 tile-setup out-of-bounds activity detected</description>
    <mitre>
      <id>T1203</id>
    </mitre>
    <group>kernel_corruption,</group>
  </rule>
  <rule id="2026976" level="12">
    <decoded_as>syslog</decoded_as>
    <match>mediatek</match>
    <match>vcodec</match>
    <regex>out-of-bounds|KASAN|general protection fault|kernel panic</regex>
    <description>CVE-2026-97579: MediaTek vcodec driver memory-safety fault</description>
    <group>kernel_corruption,</group>
  </rule>
</group>

Mitigation & Patch Guidance

Patch confidence: 0/4 (UNPATCHED — no patch evidence from any tracked source). No vendor fix, workaround, or affected-version list is available in the provided data.

1. Immediate mitigations

   • Reduce exposure of the vulnerable decode path to untrusted content: disable or restrict hardware AV1 decoding on affected MediaTek platforms where configuration permits, and fall back to software decoding if available.
   • Constrain what media is decoded by untrusted applications/browsers on MediaTek-based endpoints; treat unknown AV1 streams as hostile.
   • Apply kernel hardening already available in your baseline (e.g., KASAN in test/QA images, kernel lockdown where supported) to surface and contain OOB writes.
   • Monitor kernel logs (dmesg/journal) for the fault signatures in the Detection Guidance section and alert on MediaTek vcodec/vdec_av1 errors.

2. Patch / upgrade steps

   • No patch reference is currently available. Monitor the upstream Linux kernel media: mediatek: vcodec subsystem and your distribution/SoC vendor for a commit bounding the tile-start copy to array capacity, then track the corresponding stable-branch release and vendor backport.
   • Because this is a driver-level fix, endpoint patching depends on SoC-vendor kernel BSP updates; prioritize vendors whose support lifecycle covers your device fleet.

3. Long-term hardening

   • Adopt kernel memory-safety instrumentation in CI/test fleets to catch OOB copies in media drivers before production deployment.
   • Maintain an inventory of MediaTek-SoC endpoints and their kernel/BSP patch levels to enable rapid targeted remediation once a fix ships.
   • Enforce least-privilege on media pipelines so a single decoding fault is contained and observable.

References

• NVD — CVE-2026-97579: https://nvd.nist.gov/vuln/detail/CVE-2026-97579
• Linux kernel — media subsystem (MediaTek vcodec driver) upstream source tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/drivers/media/platform/mediatek
• Linux kernel CNA / stable review process (kernel.org security advisories): https://www.kernel.org/
• CISA Known Exploited Vulnerabilities Catalog (CVE-2026-97579 not listed as of this report): https://www.cisa.gov/known-exploited-vulnerabilities-catalog
• FIRST EPSS (CVE not yet scored): https://www.first.org/epss/

No public proof-of-concept, exploit code, Nuclei template, or evidence of in-the-wild exploitation or threat-actor campaigns is currently associated with CVE-2026-97579 based on the provided data.