Heap Buffer Overflow in stable-diffusion.cpp

Compliance Impact

The vulnerability in stable-diffusion.cpp allows for heap buffer overflow through crafted .ckpt files, potentially leading to process crashes or code execution. This can impact confidentiality, integrity, and availability of systems using affected versions.

Such impacts on confidentiality, integrity, and availability could affect compliance with standards and regulations like GDPR and HIPAA, which require protection of sensitive data and system reliability.

However, the vulnerability requires loading untrusted checkpoint files, so compliance risk depends on whether untrusted or malicious files are processed.

Mitigations include upgrading to patched versions, avoiding untrusted .ckpt files, and using safer formats like .safetensors, which can help maintain compliance.

Useful 0 Not Useful 0

Executive Summary

CVE-2026-47749 is a heap buffer overflow vulnerability in the stable-diffusion.cpp library, specifically in the SHORT_BINUNICODE parsing of PyTorch checkpoint (.ckpt) files.

The issue is caused by sign confusion in the opcode length field, where a crafted .ckpt file can use a negative signed value to trigger a memcpy operation with an extremely large length, leading to immediate heap corruption.

This vulnerability can cause process crashes and potentially allow code execution depending on the heap layout.

It affects versions of stable-diffusion.cpp prior to master-584-0a7ae07 and requires loading a malicious .ckpt file from an untrusted source.

The issue has been fixed in version master-584-0a7ae07 by restricting checkpoint loading.

Useful 0 Not Useful 0

Impact Analysis

If you use affected versions of stable-diffusion.cpp to load untrusted .ckpt model files, a maliciously crafted checkpoint file could cause heap corruption.

This can lead to application crashes and, depending on the heap layout, may allow an attacker to execute arbitrary code.

Such impacts affect the confidentiality, integrity, and availability of the affected application.

The attack requires local loading of a malicious file, but no special privileges are needed.

Useful 0 Not Useful 0

Detection Guidance

This vulnerability arises when an application using stable-diffusion.cpp loads a malicious .ckpt PyTorch checkpoint file that triggers a heap buffer overflow. Detection involves monitoring for crashes or abnormal behavior in applications loading .ckpt files, especially if these files come from untrusted sources.

Since the issue is triggered by loading crafted .ckpt files, you can detect attempts by checking for the presence and usage of such files in your environment.

Suggested commands to help detect potential exploitation attempts include:

• Use file integrity monitoring or hash checks on .ckpt files to detect unexpected or untrusted files.
• Monitor application logs for crashes or errors related to stable-diffusion.cpp or model loading.
• Use system tools like `strace` or `ltrace` on the application process to observe file access and memory operations when loading .ckpt files.
• Run commands to find .ckpt files, for example: `find /path/to/models -name '*.ckpt'` to audit checkpoint files.
• If you have debugging enabled, use tools like `gdb` to catch heap corruption or crashes during model loading.

Useful 0 Not Useful 0

Mitigation Strategies

Immediate mitigation steps include:

• Upgrade stable-diffusion.cpp to version master-584-0a7ae07 or later, which contains the patch that fixes this vulnerability.
• Avoid loading .ckpt checkpoint files from untrusted or unknown sources to prevent exploitation.
• Prefer using safer model formats such as .safetensors instead of .ckpt files.
• If upgrading immediately is not possible, implement strict validation or sandboxing around the loading of .ckpt files to limit potential damage.

Useful 0 Not Useful 0