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.
5 steps from start to impact.
Craft malicious MagicYUV media file
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.- Attacker has Python and the public PoC script
- Minimal—PoC is public and one command generates the payload
Deliver file to the target
- 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
- 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)
MagicYUV decoder processes the malformed slice_height
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.- Target runs FFmpeg < 8.1.2
- MagicYUV decoder is enabled (default in all tested builds)
- Patch has been available since June 17, 2026—over 3 months of patch window
ffmpeg -version output scanning; ffmpeg -decoders 2>/dev/null | grep magicyuv confirms decoder presenceHeap corruption → DoS (reliable)
- Step 3 succeeded
- 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
magicyuv in the stack traceHeap corruption → RCE (requires ASLR bypass)
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.- 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
- 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)
--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.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.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.- 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.
The supporting signals.
| In-the-Wild Exploitation | No 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-Concept | Public 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. |
| EPSS | 0.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 Vector | CVSS: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 Versions | FFmpeg < 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 Versions | FFmpeg 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 / Exposure | No 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 Timeline | May 13, 2026: Reported to FFmpeg security team by JFrog. June 17, 2026: FFmpeg 8.1.2 released with fix. June 22, 2026: Public disclosure. |
| Researchers | Discovered by Ori Hollander, JFrog Security Research (JFSA-2026-001676838). RCE chain demonstrated by Yuval Moravchick, JFrog lead researcher. |
| Workaround | Rebuild FFmpeg with --disable-decoder=magicyuv or apply input validation rejecting slice_height values misaligned with chroma subsampling factor. |
Sources.
- JFrog Security Advisory (JFSA-2026-001676838)
- BleepingComputer - FFmpeg fixes PixelSmash flaw
- PixelSmash deep-dive (cybercrime.club)
- Penligent - PixelSmash exploitation analysis
- Ubuntu CVE Tracker - CVE-2026-8461
- Public PoC - anyanything/CVE-2026-8461-PoC
- LinuxSecurity - FFmpeg PixelSmash RCE risk
- Malwarebytes - PixelSmash flaw turns video files into attack tools
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.
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.
#!/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