← Back to Feed CACHED · 2026-10-01 18:50:42 · CACHE_KEY CVE-2026-8461
CVE-2026-8461 · CWE-787 · Disclosed 2026-06-18

FFmpeg libavcodec MagicYUV Decoder Heap Out-of-Bounds Write (PixelSmash)

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

A 50 KB video file can crash your media pipeline, but turning that crash into a shell requires the target to have left its seatbelt unbuckled

CVE-2026-8461, dubbed PixelSmash, is a heap out-of-bounds write in FFmpeg's MagicYUV decoder (libavcodec/magicyuv.c). When the bitstream contains an odd slice_height, the decoder's AV_CEIL_RSHIFT rounding adds an extra chroma row per slice that the allocator never accounted for. Across multiple slices, these phantom rows accumulate and the decoder writes up to 640 bytes past the allocated chroma-plane buffer, corrupting adjacent heap objects including AVBuffer metadata and function pointers. Affected: every FFmpeg build prior to 8.1.2 (released June 17, 2026). Trigger containers are AVI, MKV, or MOV—MP4 is not affected because MagicYUV is not in the MP4 codec registry. The MagicYUV decoder was enabled by default in upstream FFmpeg and every distro package tested (Debian, Ubuntu, Fedora, Arch, Alpine). JFrog demonstrated a full crash-to-shell chain against Jellyfin 10.11.9 and Nextcloud's Movie preview provider.

The vendor's HIGH 8.8 rating (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) prices in full RCE, but the demonstrated RCE explicitly required ASLR disabled and hardcoded addresses for system(). With default ASLR enabled—which is the case on every modern Linux distro shipping FFmpeg—the exploit *does not land deterministically*. JFrog's own writeup acknowledges this. What remains without an ASLR bypass is a reliable denial-of-service: the decoder crashes the consuming process every time, which matters for always-on media servers. The vendor severity overstates the real-world risk by treating a lab-conditions RCE as field-viable. A MEDIUM 5.8 is the honest score for this bug in production.

"PixelSmash is reliable DoS but RCE needs ASLR off, making the 8.8 score aspirational."
02 · The Attack Path

5 steps from start to impact.

STEP 01

Craft malicious MagicYUV media file

The attacker uses the public PoC (exploit_cve_2026_8461.py from anyanything/CVE-2026-8461-PoC) to generate a sub-50 KB AVI file with an odd slice_height value. The script outputs a valid container that any MagicYUV-capable decoder will accept. No special tooling beyond Python is needed.
Conditions required:
  • Attacker has Python and the public PoC script
Where this breaks in practice:
  • Minimal—PoC is public and one command generates the payload
STEP 02

Deliver file to the target

The attacker must get the crafted file processed by a vulnerable FFmpeg instance. For client-side: social-engineer a user into opening the file in mpv, VLC, Kodi, or a file manager that generates thumbnails. For server-side: upload to Nextcloud (requires an authenticated account) or place in a Jellyfin media library directory (requires write access to the file system, implying prior compromise or a shared ingest path like a torrent watch folder).
Conditions required:
  • Client-side: victim opens the file (UI:R)
  • Server-side Nextcloud: attacker has a user account (PR:L)
  • Server-side Jellyfin: attacker has write access to a monitored media directory
Where this breaks in practice:
  • MagicYUV is an uncommon codec; user may be suspicious of non-standard video formats
  • Nextcloud upload requires authentication
  • Jellyfin ingest requires filesystem access, implying prior foothold or intentionally open share
  • Plex is not affected (custom FFmpeg with disabled decoders)
Detection/coverage: WAF/proxy inspection of uploaded file MIME types; file-type allowlists on upload endpoints
STEP 03

MagicYUV decoder processes the malformed slice_height

FFmpeg's MagicYUV decoder reads the attacker-controlled slice_height from the bitstream. When this value is odd and misaligned with the chroma vertical subsampling factor (vshift), ceiling-rounded shift operations produce one extra chroma row per slice. The cumulative offset exceeds the allocated buffer, writing up to 640 bytes of attacker-controlled chroma data into adjacent heap memory.
Conditions required:
  • Target runs FFmpeg < 8.1.2
  • MagicYUV decoder is enabled (default in all tested builds)
Where this breaks in practice:
  • Patch has been available since June 17, 2026—over 3 months of patch window
Detection/coverage: Nessus plugin (self-reported version check); ffmpeg -version output scanning; ffmpeg -decoders 2>/dev/null | grep magicyuv confirms decoder presence
STEP 04

Heap corruption → DoS (reliable)

The out-of-bounds write corrupts adjacent heap metadata. On ASLR-enabled systems (the default everywhere), the corruption produces an immediate crash of the FFmpeg worker process or the parent application (Jellyfin, Nextcloud, mpv, etc.). This is deterministic and requires no heap grooming or address knowledge. Repeated delivery can keep the service down.
Conditions required:
  • Step 3 succeeded
Where this breaks in practice:
  • Crash is contained to the FFmpeg worker or the parent service process
  • Systemd/container restart policies bring the service back online quickly
  • Does not propagate to other hosts
Detection/coverage: Process crash monitoring; core dump analysis showing magicyuv in the stack trace
STEP 05

Heap corruption → RCE (requires ASLR bypass)

With ASLR disabled or when chained with a separate information-leak vulnerability, the attacker can groom the heap to place an AVBuffer structure adjacent to the overflowed chroma buffer. Overwriting AVBuffer.free with the address of system() and pointing the buffer data to an attacker-controlled command string achieves arbitrary command execution as the service user (jellyfin, www-data, etc.). JFrog demonstrated this path against Jellyfin 10.11.9 with jellyfin-ffmpeg 7.1.3.
Conditions required:
  • Step 3 succeeded
  • ASLR is disabled or a separate info-leak vulnerability is available
  • Target runs x86_64 with glibc malloc
  • Attacker knows or can predict heap layout
Where this breaks in practice:
  • ASLR is enabled by default on all modern Linux distributions
  • No public ASLR bypass or info-leak chain has been demonstrated for this vuln
  • JFrog explicitly stated their RCE demo used hardcoded addresses with ASLR off
  • Heap layout varies across FFmpeg versions, distro builds, and glibc versions
  • Exploitation limited to service user privileges (not root unless misconfigured)
Detection/coverage: EDR/auditd detecting anomalous child processes from media server services; seccomp/AppArmor profiles blocking exec from FFmpeg workers
03 · Compensating Control

1
MEDIUM 5.8→IGNORE 0.0
SEVERITY REDUCED
Disable the MagicYUV decoder — Rebuild FFmpeg with --disable-decoder=magicyuv or, for Jellyfin/Nextcloud, configure the application to reject AVI/MKV/MOV files containing MagicYUV streams. MagicYUV is a niche lossless codec with near-zero legitimate use in consumer media workflows. This eliminates the attack surface entirely without affecting normal operations. As a MEDIUM verdict, there is no noisgate mitigation SLA—go straight to the 365-day remediation window—but this control is cheap enough to deploy immediately.
2
MEDIUM 5.8→LOW 2.5
SEVERITY REDUCED
Enforce upload file-type allowlists — Configure Nextcloud, Jellyfin, and other media-ingesting applications to accept only known-safe container formats (e.g., MP4, WebM) and reject AVI/MKV/MOV uploads from untrusted users. Since MagicYUV cannot be embedded in MP4, this blocks the trigger container entirely. Deploy within the 365-day remediation window per noisgate remediation SLA.
3
MEDIUM 5.8→LOW 2.0
SEVERITY REDUCED
Run FFmpeg workers in sandboxed containers with seccomp profiles — Isolate FFmpeg processing in containers or systemd sandboxes with restrictive seccomp profiles that block execve, fork, and clone syscalls. Even if an attacker achieves heap corruption, the sandbox prevents command execution. This mitigates the theoretical RCE path while containing DoS blast radius to the worker process. Apply within the 365-day remediation window.
4
MEDIUM 5.8→IGNORE 0.0
SEVERITY REDUCED
Patch to FFmpeg 8.1.2+ or apply distro backport — The definitive fix. Upgrade FFmpeg to 8.1.2 or apply the distro backport (Debian 7:7.1.5-0+deb13u1, Ubuntu ESM packages, SUSE SUSE-2026-3632-1). For Jellyfin, upgrade to a release bundling patched jellyfin-ffmpeg. For statically linked applications, verify the bundled FFmpeg version. Deploy within the 365-day noisgate remediation SLA window.
What doesn't work
  • WAF rules targeting MagicYUV content — The malicious payload is inside a valid AVI/MKV/MOV container. Standard WAFs inspect HTTP headers and URL patterns, not video codec bitstreams. Deep media inspection at the WAF layer is not commercially available.
  • Network-level IDS/IPS signatures — The exploit payload is a structurally valid video file with no shellcode or network-layer anomaly. Snort/Suricata rules cannot distinguish a malicious MagicYUV slice_height from a legitimate one without full codec-aware parsing.
  • ASLR alone as a complete mitigation — While ASLR blocks the demonstrated RCE chain, it does NOT prevent the heap corruption or the resulting crash. The DoS vector is fully functional regardless of ASLR status.
04 · Intelligence Metadata

The supporting signals.

In-the-Wild ExploitationNo confirmed exploitation. Not on CISA KEV. No campaigns reported by Proofpoint, Mandiant, or GreyNoise as of October 2026. Greenbone's June 2026 threat report did not list it among actively exploited CVEs.
Proof-of-ConceptPublic PoC available. anyanything/CVE-2026-8461-PoC on GitHub (AI-generated) produces a crash-inducing AVI. Run: python exploit_cve_2026_8461.py --baseline --frames 25 -o baseline.avi. Crashes unpatched FFmpeg reliably. Also indexed in SecureWithUmer/CVE-2026-PoCs. No public weaponized RCE exploit with ASLR bypass.
EPSS0.01033 (~1.03% probability of exploitation in next 30 days). Approximately 87th–90th percentile—higher than most CVEs but still low in absolute terms.
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H — 8.8 HIGH. Vector assumes full CIA impact from RCE. The UI:R is accurate for client-side; server-side auto-processing scenarios arguably warrant UI:N but PR:L (auth required). The AC:L is overstated given the ASLR dependency for RCE.
Affected VersionsFFmpeg < 8.1.2 (all branches). MagicYUV decoder enabled by default in upstream and all tested distro packages. Downstream apps: Jellyfin ≤ 10.11.9 (bundles jellyfin-ffmpeg 7.1.3), Nextcloud with Movie preview provider, Kodi, OBS Studio, mpv, Emby, Immich, PhotoPrism, GNOME/KDE/XFCE thumbnailers. Plex is NOT affected (custom FFmpeg with disabled decoders).
Fixed VersionsFFmpeg 8.1.2 (upstream, June 17, 2026). Debian stable (trixie): 7:7.1.5-0+deb13u1. Ubuntu 22.04 ESM: 7:4.4.2-0ubuntu0.22.04.1+esm16. Ubuntu 20.04 ESM: 7:4.2.7-0ubuntu0.1+esm17. Ubuntu 24.04/26.04: not yet patched ("Needs evaluation"). SUSE: important security update SUSE-2026-3632-1. Fedora/Arch: updated to 8.1.2+.
Scanning / ExposureNo GreyNoise or Shodan scanning tags specific to this CVE. Exposure is indirect: any internet-facing service that accepts media uploads and processes them with FFmpeg is a potential target. Jellyfin and Nextcloud instances are commonly self-hosted behind NAT; Shodan shows ~45K Nextcloud instances and ~12K Jellyfin instances internet-facing globally.
Disclosure TimelineMay 13, 2026: Reported to FFmpeg security team by JFrog. June 17, 2026: FFmpeg 8.1.2 released with fix. June 22, 2026: Public disclosure.
ResearchersDiscovered by Ori Hollander, JFrog Security Research (JFSA-2026-001676838). RCE chain demonstrated by Yuval Moravchick, JFrog lead researcher.
WorkaroundRebuild FFmpeg with --disable-decoder=magicyuv or apply input validation rejecting slice_height values misaligned with chroma subsampling factor.

Sources.

  1. JFrog Security Advisory (JFSA-2026-001676838)
  2. BleepingComputer - FFmpeg fixes PixelSmash flaw
  3. PixelSmash deep-dive (cybercrime.club)
  4. Penligent - PixelSmash exploitation analysis
  5. Ubuntu CVE Tracker - CVE-2026-8461
  6. Public PoC - anyanything/CVE-2026-8461-PoC
  7. LinuxSecurity - FFmpeg PixelSmash RCE risk
  8. Malwarebytes - PixelSmash flaw turns video files into attack tools
05 · The Call

Final Verdict
↓ DOWNGRADED to MEDIUM (5.8/10)

Why this verdict

  • ASLR kills the RCE chain: JFrog's own disclosure states their deterministic RCE used ASLR disabled and hardcoded addresses. On default Linux (ASLR enabled), this is a DoS-only bug. The 8.8 score prices in full C:H/I:H/A:H—only A:H is reliably achievable. Adjustment: −2.0.
  • User interaction or authentication required: Client-side requires a user to open a malicious video (UI:R). Server-side Nextcloud requires an authenticated account; Jellyfin requires filesystem write access implying prior compromise. The CVSS PR:N overstates attacker access. Adjustment: −0.5.
  • Uncommon codec, narrow trigger: MagicYUV is a niche lossless codec. While the decoder is compiled in by default, attacker must specifically craft content in this format, which may be filtered by upload validators or look suspicious. Adjustment: −0.3.
  • No active exploitation or weaponized RCE: EPSS is 1.03%, not on KEV, no campaigns observed. The only public PoC produces a crash, not a shell. The gap between DoS PoC and weaponized RCE with ASLR bypass is substantial. Adjustment: −0.2.
  • Role multiplier: FFmpeg is a media-processing library, not a canonically high-value-role component. (a) *Workstation/desktop:* crash in a media player—nuisance-level DoS, blast radius = single app process. (b) *Typical role:* Jellyfin/Nextcloud media server—service crash, blast radius = single host service. (c) *High-value role consideration:* FFmpeg runs in cloud transcoding pipelines and CI/CD media processing, but compromise is contained to the worker container/process with service-user privileges (not root). No domain-takeover, fleet-compromise, or supply-chain-scale outcome is achievable even if RCE landed. The blast radius ceiling is host-level under service-user context. This does not trigger the HIGH/CRITICAL floor—FFmpeg is not an identity provider, hypervisor, PKI, PAM, or network edge appliance. <1% of FFmpeg deployments occupy roles where compromise would cascade beyond a single host.

Why not higher?

RCE without an ASLR bypass is not demonstrated and no public chain exists to bridge that gap. The realistic impact on default-configured production Linux is application-level DoS—a crash that systemd or container orchestration restarts in seconds. The blast radius is capped at the service user on a single host. There is no path to domain takeover, lateral movement, or data exfiltration from this vulnerability alone. Upgrading to HIGH would require either a demonstrated ASLR bypass chain or confirmed in-the-wild RCE exploitation, neither of which exists.

Why not lower?

The DoS is deterministic and trivially reproducible with a public PoC. FFmpeg is embedded in a vast number of applications, and the MagicYUV decoder is compiled in by default everywhere. Self-hosted media servers (Jellyfin, Nextcloud, Emby, Immich) that auto-process uploads are crashable by any authenticated user, which is a real abuse vector in multi-tenant or shared environments. Dropping to LOW would understate the availability impact on always-on media infrastructure.

06 · Verification

Crowdsourced verification payload.

Run this script on each target host where FFmpeg is installed (media servers, transcoding workers, desktops). No special privileges required. Invoke: bash check_cve_2026_8461.sh — it checks the FFmpeg version and whether the MagicYUV decoder is enabled, then outputs VULNERABLE, PATCHED, or UNKNOWN.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# check_cve_2026_8461.sh - Check for CVE-2026-8461 (PixelSmash)
# FFmpeg MagicYUV decoder heap OOB write
# Exit codes: 0=PATCHED, 1=VULNERABLE, 2=UNKNOWN

set -euo pipefail

echo "[*] CVE-2026-8461 (PixelSmash) - FFmpeg MagicYUV Decoder Check"
echo "=============================================================="

# Check if ffmpeg is installed
if ! command -v ffmpeg &>/dev/null; then
  echo "[?] ffmpeg not found in PATH."
  echo "[!] Check for bundled FFmpeg in applications (jellyfin-ffmpeg, etc.)"
  echo "UNKNOWN"
  exit 2
fi

# Get FFmpeg version
FFMPEG_VERSION=$(ffmpeg -version 2>/dev/null | head -1 | grep -oP '\d+\.\d+(\.\d+)?' | head -1)
if [ -z "$FFMPEG_VERSION" ]; then
  echo "[?] Could not parse FFmpeg version."
  echo "UNKNOWN"
  exit 2
fi
echo "[*] FFmpeg version: $FFMPEG_VERSION"

# Check if MagicYUV decoder is enabled
MAGICYUV=$(ffmpeg -decoders 2>/dev/null | grep -i magicyuv || true)
if [ -z "$MAGICYUV" ]; then
  echo "[+] MagicYUV decoder is NOT enabled - not vulnerable to this CVE."
  echo "PATCHED"
  exit 0
fi
echo "[*] MagicYUV decoder is enabled: $MAGICYUV"

# Version comparison function
version_gte() {
  printf '%s\n%s' "$2" "$1" | sort -V -C
}

# Check upstream FFmpeg version (8.1.2+ is patched)
if version_gte "$FFMPEG_VERSION" "8.1.2"; then
  echo "[+] FFmpeg version $FFMPEG_VERSION >= 8.1.2 (upstream fix)."
  echo "PATCHED"
  exit 0
fi

# Check for known distro backport versions
FULL_VERSION=$(ffmpeg -version 2>/dev/null | head -1)
echo "[*] Full version string: $FULL_VERSION"

# Debian trixie backport
if echo "$FULL_VERSION" | grep -q 'deb13'; then
  DEB_VER=$(dpkg -l ffmpeg 2>/dev/null | awk '/^ii/{print $3}' || true)
  if [ -n "$DEB_VER" ] && dpkg --compare-versions "$DEB_VER" ge "7:7.1.5-0+deb13u1" 2>/dev/null; then
    echo "[+] Debian backport $DEB_VER includes the fix."
    echo "PATCHED"
    exit 0
  fi
fi

# Ubuntu ESM backports
if command -v dpkg &>/dev/null; then
  DEB_VER=$(dpkg -l ffmpeg 2>/dev/null | awk '/^ii/{print $3}' || true)
  if [ -n "$DEB_VER" ]; then
    echo "[*] dpkg reports ffmpeg version: $DEB_VER"
    if echo "$DEB_VER" | grep -qP 'esm1[6-9]|esm[2-9]\d'; then
      echo "[+] Ubuntu ESM backport detected - likely patched."
      echo "[!] Verify against advisory: 7:4.4.2-0ubuntu0.22.04.1+esm16 (jammy)"
      echo "[!]                      or: 7:4.2.7-0ubuntu0.1+esm17 (focal)"
      echo "PATCHED"
      exit 0
    fi
  fi
fi

echo "[-] FFmpeg version $FFMPEG_VERSION is VULNERABLE to CVE-2026-8461."
echo "[-] MagicYUV decoder is enabled and version is below 8.1.2."
echo "[-] Upgrade to FFmpeg 8.1.2+ or rebuild with --disable-decoder=magicyuv."
echo "VULNERABLE"
exit 1