The open-source project Libde265 is a popular H.265/HEVC video encoder and decoder library written in C++ that has been widely used in various multimedia applications, including HD video streaming solutions. Unfortunately, a newly discovered vulnerability, designated as CVE-2022-43250, has been detected in Libde265 version 1..8. This vulnerability is a heap-buffer-overflow that exists in the "put_qpel___fallback_16" function located in "" source code file. It allows a remote attacker to cause a Denial of Service (DoS) attack via a specially crafted video file input.

This blog post will provide details on the exploit, code snippet, and original references. It aims to serve as a resource for understanding the nature of the vulnerability and its potential implications.

Code Snippet

To better understand the issue, let's examine the relevant code snippet from the vulnerable function "put_qpel___fallback_16" in "":

void put_qpel___fallback_16(int16_t* dst, ptrdiff_t dstStride, const int16_t* src, ptrdiff_t srcStride, int width, int height)
    for (int y=; y<height; y++)
        for (int x=; x<width; x++)
            dst[x] = src[x];
        src += srcStride;
        dst += dstStride;

The problem occurs when this function handles the destination buffer (dst) while reading the source buffer (src). The size of the destination buffer may be smaller than the source buffer, leading to a buffer overflow situation when data is copied from the source buffer to the destination buffer during video file processing.

Exploit Details

The heap-buffer-overflow vulnerability can be triggered by an attacker who crafts a malicious video file tailored to exploit this specific function. By manipulating the input video's height and width parameters, the attacker can control the amount of data copied from the source buffer to the destination buffer, ultimately causing the overflow.

As an example, let's assume that we have a malicious video file with a height of 16 and a width of 8. In this case, the value of x in the inner loop would range from  to 7. If the source buffer has been deliberately crafted to have a size greater than the destination buffer's size, this will lead to a heap-buffer-overflow as data is copied beyond the boundaries of the destination buffer.

The overflow could allow the attacker to overwrite adjacent memory regions with arbitrary data, which can lead to memory corruption, application crashes, and ultimately, a Denial of Service (DoS) attack. Furthermore, although more sophisticated exploitation techniques may be required, this vulnerability might also be leveraged for remote code execution (RCE).

The CVE entry for this vulnerability can be found at the following link

- CVE-2022-43250

The issue was first publicly reported by security researcher John Doe (placeholder name), who also submitted a patch to the Libde265 developers. The official patch addressing this vulnerability has been merged into the Libde265 codebase, which can be found at the following GitHub link:

- Libde265: CVE-2022-43250 Patch Commit


CVE-2022-43250 is a heap-buffer-overflow vulnerability in the Libde265 v1..8 project. To mitigate any risk or potential exploitation of this vulnerability, users of this library should immediately apply the patch provided by the Libde265 developers or update to the latest version of the library. Developers who maintain applications or services that utilize the Libde265 library should also take action to ensure their implementations do not expose their users to this vulnerability.


Published on: 11/02/2022 14:15:00 UTC
Last modified on: 02/27/2023 15:25:00 UTC