CVE-2026-64835

Executive Summary

Business Impact: This vulnerability affects FFmpeg, a ubiquitous multimedia framework used across media streaming platforms, video editing software, security camera systems, and content delivery networks. Attackers can weaponize this flaw by crafting malicious ADX or AAX audio files. The primary attack vector involves social engineering (convincing a user or automated system to process a malicious file) or supply-chain attacks where a malicious file is ingested by a backend media processing pipeline. The likely attacker profile ranges from opportunistic threat actors seeking to deploy malware on media servers to targeted attackers aiming to disrupt broadcasting or surveillance systems.

Vulnerability Class & Attack Vector: This is an out-of-bounds (OOB) memory access vulnerability in the ADX audio decoder (libavcodec/adxdec.c). The attack vector is network-accessible via file upload or processing, but requires user interaction (e.g., a user or automated process opening the crafted file). No authentication is required to trigger the vulnerability.

Urgency Assessment: The CVSS score of 8.8 (High) combined with an EPSS probability of 0.0% indicates a high-impact vulnerability with currently no known active exploitation. However, the lack of a patch and the availability of technical details in the NVD description make this a high-priority target for both defenders and attackers. The window for proactive defense is narrow.

Key Facts:

• Vendor: FFmpeg
• Affected Versions: 4.4 through 8.1.2
• Patch Status: Unpatched as of 2026-07-22
• CISA KEV: Not listed.

CVSS Breakdown & Threat Level

Qualitative Severity: High

CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H

• AV:N (Network): The vulnerability can be triggered by supplying a crafted file over a network (e.g., via HTTP upload, RTSP stream, or file share).
• AC:L (Low): No special conditions are required beyond the attacker providing a crafted file. The decoder will process the malformed data without additional complexity.
• PR:N (None): The attacker does not need any authentication or privileges on the target system.
• UI:R (Required): The victim must perform some action, such as opening the file with FFmpeg or a service that uses FFmpeg for decoding. This is a standard requirement for file-format vulnerabilities.
• S:U (Unchanged): A successful exploit compromises the security of the vulnerable component (FFmpeg process) but does not affect other system components.
• C:H/I:H/A:H (High/High/High): The OOB write can lead to arbitrary code execution, allowing the attacker to read, modify, or delete data and cause a denial of service.

EPSS Interpretation: The 0.0% EPSS probability means that as of the report date, there is no evidence of exploitation in the wild. This is typical for a very recent CVE. Defenders should not be complacent; this score will likely increase as PoC code becomes available.

Historical Comparison: This vulnerability is similar to CVE-2023-50028 (FFmpeg OOB write in the AVI demuxer) and CVE-2024-31578 (FFmpeg heap buffer overflow in the AV1 decoder). All three are memory corruption bugs in FFmpeg decoders triggered by crafted media files, highlighting a recurring pattern of insufficient state validation during mid-stream parameter changes.

Temporal & Environmental Considerations: With no patch available, the temporal score remains high. Organizations using FFmpeg in high-value or internet-facing media processing pipelines should consider this a critical risk despite the lack of active exploitation.

Technical Deep Dive & Attack Mechanics

Root Cause Analysis: The vulnerability lies in the adx_decode_frame function within libavcodec/adxdec.c. The ADX decoder maintains an internal state array prev[] to store previous audio samples for predictive decoding. The size of this array is determined by the number of audio channels parsed from the stream header.

The flaw occurs when AV_PKT_DATA_NEW_EXTRADATA side data is received mid-stream. This side data signals a change in the stream's codec parameters, including a potential change in the number of audio channels. The adx_decode_frame function correctly re-parses the new header, but it fails to reallocate or resize the prev[] state array based on the new channel count. The decoder continues to use the old, stale channel count for subsequent prev[] array accesses.

Step-by-Step Exploitation:

1. Crafting the File: An attacker creates a valid ADX or AAX audio file with an initial header declaring, for example, 2 channels. The prev[] array is allocated for 2 channels.
2. Mid-Stream Header Change: The attacker inserts a new header (via AV_PKT_DATA_NEW_EXTRADATA) that declares a different number of channels, e.g., 6 channels.
3. Triggering the OOB Access: When the decoder processes audio frames after the header change, it attempts to read from and write to prev[0], prev[1], ..., prev[5]. However, the array only has space for prev[0] and prev[1]. Accesses to prev[2] through prev[5] are out-of-bounds.
4. Memory Corruption: The OOB write corrupts adjacent heap memory, which can be leveraged to overwrite function pointers or other critical data structures, leading to arbitrary code execution.

Attack Surface:

• File Upload: Web applications that allow users to upload audio files for processing.
• Media Servers: Streaming servers (e.g., using FFmpeg for transcoding) that ingest user-provided streams.
• Video Editing Software: Desktop applications that use FFmpeg as a backend.
• Security Cameras: DVR/NVR systems that decode audio from camera feeds.

Pre-conditions:

• The target must use a vulnerable version of FFmpeg (4.4 through 8.1.2).
• The attacker must be able to supply a crafted ADX or AAX file to the decoder.
• The decoder must process the file in a context where AV_PKT_DATA_NEW_EXTRADATA is honored.

Why Standard Defenses May Fail:

• File Validation: Standard file format validators may not check for mid-stream header changes.
• Sandboxing: While a sandbox can limit the impact of code execution, the OOB write itself can still cause a denial of service.
• ASLR/DEP: These mitigations make exploitation harder but do not prevent the OOB access itself.

Vulnerable vs. Patched Code Analysis

Vulnerable Code (Pseudocode):

static int adx_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                            int *got_frame, AVPacket *avpkt)
{
    ADXContext *s = avctx->priv_data;
    // ... initial parsing ...
    if (avpkt->side_data_elems > 0) {
        // Re-parse header from side data
        // BUT: s->channels is NOT updated here
    }
    // Decode using stale s->channels
    for (int ch = 0; ch < s->channels; ch++) {
        // OOB access to s->prev[ch] if channels changed
        s->prev[ch] = ...;
    }
}

Patched Code (Expected Logic):

static int adx_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                            int *got_frame, AVPacket *avpkt)
{
    ADXContext *s = avctx->priv_data;
    // ... initial parsing ...
    if (avpkt->side_data_elems > 0) {
        // Re-parse header from side data
        int new_channels = parse_channels_from_side_data(avpkt);
        if (new_channels != s->channels) {
            // Reallocate s->prev array
            av_freep(&s->prev);
            s->prev = av_mallocz_array(new_channels, sizeof(int16_t));
            s->channels = new_channels;
        }
    }
    // Safe access using updated s->channels
    for (int ch = 0; ch < s->channels; ch++) {
        s->prev[ch] = ...;
    }
}

Patch Sufficiency: The fix is straightforward: reallocate the prev[] array when the channel count changes. This is a standard pattern in FFmpeg for handling dynamic stream parameters. No regression is expected as long as the reallocation is done correctly.

Timeline & Disclosure History

• CVE Publication Date: 2026-07-22T18:17:05.917
• Estimated Discovery: The vulnerability was likely discovered through internal code auditing or fuzzing, given the specific nature of the bug.
• Disclosure Process: The CVE was published by the NVD. No vendor advisory or GitHub Security Advisory is available as of this report.
• Known Exploitation: No known active exploitation as of 2026-07-22.
• CISA KEV: Not listed.

Threat Intelligence Context

Threat Actor Profile: This vulnerability is most likely to be exploited by:

• Cybercriminals: For deploying ransomware or coin miners on media servers.
• Nation-State Actors: For targeted attacks against media organizations or surveillance systems.
• Script Kiddies: Once a PoC is publicly released, for opportunistic attacks.

Attack Campaign Context: No specific campaigns are associated with this CVE at this time.

Geographic Targeting: No specific geographic pattern is discernible.

Industry Verticals Most at Risk:

• Media & Entertainment: Streaming services, video editing studios.
• Security & Surveillance: DVR/NVR manufacturers and operators.
• Telecommunications: Voicemail and conferencing systems.
• Gaming: Games that use FFmpeg for cutscene or audio decoding.

Connection to Similar Vulnerabilities: This is part of a broader class of "mid-stream parameter change" vulnerabilities in FFmpeg, similar to those found in the AVI demuxer and various codec decoders.

Exploitation & Lab Setup

Red Team Section

Lab Setup:

1. Environment: Ubuntu 22.04 LTS VM with Docker installed.
2. Vulnerable FFmpeg: docker run -it --rm jrottenberg/ffmpeg:4.4-ubuntu
3. Crafting the Payload: Use a hex editor or a Python script to create a malformed ADX file.
   • Start with a valid 2-channel ADX file.
   • Locate the header and modify the channel count field.
   • Insert a new header mid-stream with a different channel count (e.g., 6 channels).
4. Triggering the Vulnerability:

   ffmpeg -i malicious.adx -f null -
   

   This will cause FFmpeg to decode the file and trigger the OOB access.

Exploitation Walkthrough:

1. Craft the File: Use a Python script to generate the malformed ADX file.
2. Deliver the File: Host the file on a web server or send it via email.
3. Trigger: The victim (or automated system) runs FFmpeg on the file.
4. Expected Output: FFmpeg will crash with a segmentation fault (SIGSEGV) or, if the heap is carefully arranged, execute arbitrary code.

Post-Exploitation: An attacker achieving code execution can:

• Exfiltrate data from the server.
• Install a backdoor.
• Pivot to other systems on the network.

Blue Team Section

Detection:

• Process Crashes: Monitor for FFmpeg processes crashing with SIGSEGV.
• File Analysis: Scan for ADX/AAX files with inconsistent channel counts between the initial header and mid-stream headers.
• Network Traffic: Look for unusual outbound connections from FFmpeg processes (post-exploitation).

Indicators of Compromise (IOCs)

No confirmed IOCs available — the following patterns are illustrative of exploitation attempts:

• File Hashes: [EXAMPLE — not a real IOC] sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
• Network Connections: Outbound connections from ffmpeg process to an external IP on port 443 or 80.
• Process Anomalies: ffmpeg process spawning cmd.exe or /bin/sh.
• Log Entries:
  • Syslog: ffmpeg[PID]: segfault at ADDR ip IP sp SP error 6 in libavcodec.so
  • Application log: Error while decoding stream #0:0: Invalid data found when processing input

Detection Engineering

YARA Rule

rule CVE-2026-64835_Detection {
    meta:
        description = "Detects exploitation of CVE-2026-64835 in Ffmpeg"
        author = "Valters IT Hub"
        date = "2026-07-22"
        reference = "https://www.valtersit.com/cve/cve-2026-64835"
    strings:
        $adx_header = { 41 44 58 00 }  // "ADX\0" magic bytes
        $aax_header = { 41 41 58 00 }  // "AAX\0" magic bytes
        $channel_change = { 00 00 00 06 }  // Example: 6 channels in mid-stream header
    condition:
        ($adx_header or $aax_header) and $channel_change
}

Sigma Rule (SIEM)

title: CVE-2026-64835 Ffmpeg Exploitation Detection
id: b0795120-c4cf-4d7b-856b-2773497da8f0
status: experimental
description: Detects exploitation attempts targeting CVE-2026-64835 in Ffmpeg
author: Valters IT Hub
date: 2026-07-22
references:
    - https://www.valtersit.com/cve/cve-2026-64835
logsource:
    category: process_creation
    product: linux
detection:
    selection:
        Image|endswith: '/ffmpeg'
        CommandLine|contains: 'adx'
    condition: selection
falsepositives:
    - Legitimate processing of ADX files
level: high

Suricata IDS Rule

alert tcp any any -> any any (msg:"CVE-2026-64835 Ffmpeg ADX Exploitation Attempt"; flow:to_server,established; content:"|41 44 58 00|"; depth:4; content:"|00 00 00 06|"; within:100; sid:1000001; rev:1;)

Elastic (EQL) Query

process where event.type == "start" and process.name == "ffmpeg" and process.command_line : "*adx*"

Splunk SPL Query

index=linux_secure sourcetype=linux_secure process=ffmpeg "adx" | table _time, host, process, command

Wazuh Rule

<group name="ffmpeg,">
  <rule id="100001" level="12">
    <if_sid>530</if_sid>
    <field name="process">ffmpeg</field>
    <match>adx</match>
    <description>CVE-2026-64835: Ffmpeg ADX decoder exploitation attempt</description>
    <mitre>
      <id>T1203</id>
    </mitre>
  </rule>
</group>

Remediation & Mitigation

Immediate Actions (0-24 hours):

• No patch available. The primary mitigation is to avoid processing untrusted ADX or AAX files.
• Network-Level: Block uploads of .adx and .aax files at the web application firewall (WAF) or reverse proxy.
• Authentication: Ensure that only authenticated users can upload media files for processing.

Short-term (1-7 days):

• Configuration Hardening: If FFmpeg is used in a pipeline, consider using a separate, sandboxed process for decoding untrusted files.
• Monitoring: Implement the detection rules above to alert on any FFmpeg crashes or suspicious file processing.
• Vulnerability Scanning: Use a tool like trivy to scan for vulnerable FFmpeg versions:

  trivy image jrottenberg/ffmpeg:4.4-ubuntu
  

Long-term:

• Architecture: Migrate to a more secure media processing library or use a dedicated media server with built-in input validation.
• Developer Training: Educate developers on the dangers of mid-stream parameter changes and the importance of state validation.

Validation: To confirm you are no longer vulnerable, upgrade to a patched version once available. Until then, verify that no untrusted ADX/AAX files are being processed.

References & Resources

• NVD: https://nvd.nist.gov/vuln/detail/CVE-2026-64835
• CVE.org: https://www.cve.org/CVERecord?id=CVE-2026-64835
• Vendor advisory: See vendor security page
• OSV: https://osv.dev/vulnerability/CVE-2026-64835 (if applicable)
• Related CWE: https://cwe.mitre.org/data/definitions/787.html
• MITRE ATT&CK: https://attack.mitre.org/techniques/T1203/

Report generated by Valters IT Hub Neural Engine v25 | 2026-07-22 | https://www.valtersit.com/cve/cve-2026-64835