CVE-2026-41445
Integer Overflow in KissFFT Causes Heap Buffer Overflow
Publication date: 2026-04-20
Last updated on: 2026-04-20
Assigner: VulnCheck
Description
Description
CVSS Scores
EPSS Scores
| Probability: | |
| Percentile: |
Meta Information
Affected Vendors & Products
| Vendor | Product | Version / Range |
|---|---|---|
| kissfft | kissfft | * |
Helpful Resources
Exploitability
| CWE ID | Description |
|---|---|
| CWE-122 | A heap overflow condition is a buffer overflow, where the buffer that can be overwritten is allocated in the heap portion of memory, generally meaning that the buffer was allocated using a routine such as malloc(). |
| CWE-190 | The product performs a calculation that can produce an integer overflow or wraparound when the logic assumes that the resulting value will always be larger than the original value. This occurs when an integer value is incremented to a value that is too large to store in the associated representation. When this occurs, the value may become a very small or negative number. |
Attack-Flow Graph
AI Powered Q&A
Can you explain this vulnerability to me?
CVE-2026-41445 is a high-severity vulnerability in KissFFT versions before commit 8a8e66e. It involves an integer overflow in the kiss_fftndr_alloc() function, where the calculation for the allocation size uses signed 32-bit integer arithmetic. If the multiplication of dimensions exceeds the maximum value for a signed 32-bit integer (INT_MAX), the calculation overflows, causing malloc() to allocate a smaller buffer than intended.
When the kiss_fftndr() function processes data with specially crafted dimensions that trigger this overflow, it writes beyond the allocated buffer, leading to a heap buffer overflow. This can cause memory corruption and potentially allow an attacker to execute arbitrary code or crash the application.
The vulnerability is classified under CWE-190 (Integer Overflow or Wraparound) and CWE-122 (Heap-based Buffer Overflow).
How can this vulnerability impact me? :
This vulnerability can have serious impacts including unauthorized memory corruption due to heap buffer overflow. An attacker can exploit this by providing crafted input dimensions that cause the integer overflow and subsequent buffer overflow.
The consequences include potential arbitrary code execution, application crashes, denial of service, and compromise of confidentiality, integrity, and availability of the affected system.
How can this vulnerability be detected on my network or system? Can you suggest some commands?
This vulnerability arises from an integer overflow in the kiss_fftndr_alloc() function when processing crafted dimensions that cause the allocation size calculation to exceed the 32-bit signed integer limit. Detection would involve identifying usage of vulnerable KissFFT versions prior to commit 8a8e66e and monitoring for abnormal or crafted dimension inputs that could trigger the overflow.
Since the vulnerability is in a library function, direct network detection commands are not straightforward. However, you can check the version of KissFFT in your environment or software dependencies to see if it is before the fixed commit.
- Use package management or source code inspection commands to identify KissFFT version or commit, for example:
- grep -r 'kiss_fftndr_alloc' /path/to/kissfft/source or binaries to check for presence of vulnerable code.
- Check git commit history if you have the source: git log -p -1 8a8e66e33d692bad1376fe7904d87d767730537f
- Monitor application logs or crash reports for heap buffer overflow symptoms when processing FFT data with large or unusual dimensions.
What immediate steps should I take to mitigate this vulnerability?
The primary mitigation is to update KissFFT to include the fix introduced in commit 8a8e66e, which addresses the integer overflow by changing variable types to size_t, adding overflow checks, and correcting memory size calculations.
- Upgrade KissFFT to the version including or after commit 8a8e66e.
- If upgrading is not immediately possible, avoid processing FFT data with large or crafted dimensions that could trigger the overflow.
- Implement input validation to ensure dimension parameters do not exceed safe limits before calling kiss_fftndr_alloc().
- Monitor applications using KissFFT for unusual crashes or memory corruption symptoms.
How does this vulnerability affect compliance with common standards and regulations (like GDPR, HIPAA)?:
The vulnerability in KissFFT (CVE-2026-41445) allows attackers to trigger a heap buffer overflow, potentially leading to unauthorized memory writes. This can compromise the confidentiality, integrity, and availability of data processed by affected systems.
Such compromises can impact compliance with common standards and regulations like GDPR and HIPAA, which require protection of sensitive data and system integrity. Exploitation of this vulnerability could lead to data breaches or system disruptions, thereby violating these regulatory requirements.