FFmpeg vulnerabilities

In FFmpeg versions from 0.5 up to, but not including, 9.0, there is an uninitialized heap memory disclosure vulnerability in the native TIFF decoder in libavcodec/tiff.c. An attacker can supply a crafted TIFF file with a valid Deflate-compressed strip that terminates successfully after producing fewer bytes than declared. The tiff_unpack_zlib() function allocates a heap buffer sized for the full declared strip but copies all declared rows via memcpy() regardless of how many bytes zlib actually decompressed, causing unwritten bytes that can contain stale data from prior heap allocations to be incorporated into decoded image output.

In FFmpeg versions from 3.0 up to, but not including, 9.0, there is an uninitialized heap memory read vulnerability in the native Screenpresso decoder (libavcodec/screenpresso.c) that allows attackers to recover sensitive memory contents by supplying a crafted SPV1 packet with a valid zlib stream that decompresses fewer bytes than the full frame requires. The screenpresso_decode_frame() function fails to validate the produced byte count before calling av_image_copy_plane() to copy the complete frame dimensions from the persistent ctx->inflated_buf buffer, causing unwritten heap memory from prior allocations or prior frames to be copied into decoded output.

In FFmpeg versions from 3.0 up to, but not including, 9.0, there is an uninitialized heap memory read vulnerability in the native RSCC decoder (libavcodec/rscc.c) that allows attackers to disclose heap memory contents by supplying a crafted video file with a compressed tile that decompresses fewer bytes than the declared tile geometry requires. When rscc_decode_frame() calls av_image_copy_plane() without validating the decompressed byte count against the tile dimensions, the unwritten suffix of the persistent intermediate buffer ctx->inflated_buf is copied into the decoded frame.

FFmpeg versions from 0.5 up to, but not including, 9.0 contain a signed integer overflow vulnerability in the DVB subtitle parser that allows attackers to trigger a heap buffer overflow by supplying a crafted WTV file. The overflow causes the bounds-check guard expression to wrap to INT_MIN, bypassing the PARSE_BUF_SIZE comparison and invoking memcpy() with attacker-controlled data into a heap buffer, resulting in an out-of-bounds heap write and potential memory corruption or code execution.

FFmpeg 7.0 through 8.1.2, fixed in commit 4da9812, contains a heap out-of-bounds write vulnerability in the vf_quirc filter. An attacker can supply a crafted PGS/SUP subtitle file with mismatched frame dimensions, causing data to be copied beyond the allocated buffer, leading to heap corruption and potential code execution.

FFmpeg through version 8.1.2, fixed in commit b506faf, contains a heap out-of-bounds write vulnerability in the native PNG and APNG encoders. An attacker can supply a crafted PNG image with a malicious eXIf chunk, causing tens of thousands of bytes to be written past the buffer boundary, leading to heap corruption and potential code execution.

FFmpeg through version 8.1.2, fixed in commit aafb5c6, contains a signed integer overflow vulnerability in the MACE6 audio decoder. An attacker can supply a crafted CAF file with a malicious bytes_per_packet value, causing an integer overflow and undersized buffer allocation, leading to a heap out-of-bounds write and potential code execution.

FFmpeg through 8.1.2 contains an information disclosure vulnerability in the LCL/ZLIB video decoder that allows attackers to expose uninitialized heap memory by supplying a valid zlib stream that inflates to fewer bytes than the expected frame size. The zlib_decomp() function in lcldec.c treats short decompression as non-fatal and continues to the RGB24 conversion path, copying uninitialized heap contents into the attacker-observable AVFrame output, potentially defeating ASLR in long-lived media processing services.

FFmpeg through 8.1.2 contains an uncontrolled resource consumption vulnerability in the IAMF demuxer that allows an unauthenticated attacker to cause multi-gigabyte memory allocation from a 17-byte input file by supplying a crafted count_label field. The mix_presentation_obu() function in libavformat/iamf_parse.c calls av_calloc(count_label, sizeof(*language_label)) with an attacker-controlled value before validating available OBU data, enabling an allocation amplification of approximately 126 million bytes per input byte that exhausts process memory or triggers an OOM-kill during format probing.

In FFmpeg up to version 8.1.2, there is a heap out-of-bounds write vulnerability in the vf_hqdn3d filter. An attacker can supply a crafted video where frame resolution increases between frames and filter reinitialization is disabled, leading to heap memory corruption.

An out-of-bounds write vulnerability in the vf_swaprect video filter in FFmpeg versions 3.0 through 8.1.2. An attacker can supply a crafted NV12 frame with odd width, causing heap corruption and potential code execution.

A vulnerability in the vf_floodfill video filter in FFmpeg versions 3.4 through 8.1.2 causes an out-of-bounds write on the heap. When config_input() allocates a stack based on initial frame dimensions and a larger frame is processed, filter_frame() pushes neighbors beyond the original allocation, leading to heap corruption and potential code execution.

A vulnerability in FFmpeg through version 8.1.2 allows heap corruption via a crafted ffconcat file processed with the -safe 0 flag. The TY demuxer's demux_audio() function decrements packet size without bounds checking, resulting in a negative size that, when converted to size_t in shorten_decode_frame(), causes reads beyond the source and writes beyond the Shorten decoder's bitstream buffer.

FFmpeg versions 2.7 through 8.1.2 contain an out-of-bounds write vulnerability in the TDSC video decoder that allows remote attackers to cause heap corruption by supplying a crafted AVI file.

FFmpeg versions 4.4 through 8.1.2 contain an out-of-bounds memory access vulnerability in the ADX audio decoder. An attacker can supply a crafted ADX or AAX audio file with a mid-stream channel layout change, causing the use of a stale channel count and out-of-bounds memory access.

FFmpeg versions 0.6.3 through 8.1.2 contain an infinite loop vulnerability in the RTP/ASF demuxer (libavformat/rtpdec_asf.c). The rtp_asf_fix_header function fails to validate a minimum chunksize, allowing a remote attacker to send a crafted RTP/ASF stream causing CPU exhaustion and denial of service.

FFmpeg versions 0.7.1 through 8.1.2 contain an out-of-bounds read vulnerability in the S/PDIF muxer. An attacker can supply a crafted DTS stream with a core_size larger than the actual packet length, causing unauthorized memory reads.

A double-free vulnerability in the NVIDIA NVDEC hardware decoder in FFmpeg versions 4.4 through 8.1.2. Attackers can trigger memory corruption by supplying a crafted video file, causing a double-free of the decoder context.

In FFmpeg versions 8.0 through 8.1.2, a stack buffer overflow vulnerability exists in the Vulkan HEVC hardware decoder. A remote attacker can supply a crafted HEVC/H.265 bitstream with a malicious vps_num_hrd_parameters value exceeding HEVC_MAX_SUB_LAYERS, causing overflow of stack-allocated arrays in the vk_hevc_end_frame function, potentially achieving arbitrary code execution.

FFmpeg versions 2.1 through 8.1.2 contain a heap buffer overflow vulnerability in the VobSub subtitle demuxer. Supplying a malicious .sub/.idx file with excessive stream IDs can cause out-of-bounds writes and potential code execution.

An out-of-bounds read vulnerability in FFmpeg within Google Chrome prior to version 150.0.7871.47 allows a remote attacker to read sensitive information from process memory by crafting a malicious video file.

FFmpeg's RASC video decoder performs 32-bit reads/writes before row-boundary checks and validates DLTA region in pixels instead of bytes. A crafted RASC stream can cause out-of-bounds heap write and read, leading to memory corruption.

Vulnerability in FFmpeg's libavcodec library, in the MagicYUV decoder, causing an out-of-bounds write. This can lead to denial of service and, in some cases, remote code execution.

A flaw was found in FFmpeg that a remote attacker could exploit by providing a specially crafted MPEG-PS/VOB media file containing a malicious DVD subtitle stream. The vulnerability is caused by a signed integer overflow in the DVD subtitle parser's fragment reassembly bounds checks, leading to a heap out-of-bounds write. Successful exploitation can result in a denial of service (application crash) and potentially lead to arbitrary code execution.

In FFmpeg 8.0, there is an integer overflow vulnerability in the yuv2ya16_X_c_template function in libswscale/output.c.

Use-after-free vulnerability in the SANM decoder (animation format) in FFmpeg. With a crafted file using subversion <2, an invalid frame size in a FOBJ chunk causes an early return and stores the raw frame in ctx->stored_frame without setting dimensions. A subsequent FTCH chunk re-decodes the frame, initializes buffers and frees the previous buffer, while the GetByteContext object still references the freed memory, leading to a use-after-free write (allocator metadata corruption).

A heap-buffer-overflow write in the JPEG2000 decoder in FFmpeg. An attacker could potentially achieve remote code execution or cause denial of service via the channel definition cdef atom of JPEG2000.