CVE-2025-69419: OpenSSL Buffer Overflow Vulnerability

CVE-2025-69419 Overview

CVE-2025-69419 is an out-of-bounds write vulnerability in OpenSSL's PKCS12_get_friendlyname() function. When processing a maliciously crafted PKCS#12 file containing a BMPString (UTF-16BE) friendly name with non-ASCII BMP code points, the function can trigger a one-byte write before the allocated buffer. This memory corruption issue affects multiple versions of OpenSSL and can lead to various consequences including Denial of Service.

The vulnerability exists in the OPENSSL_uni2utf8() function, which performs a two-pass conversion of PKCS#12 BMPString (UTF-16BE) to UTF-8. During the second pass, the helper function bmp_to_utf8() incorrectly forwards the remaining UTF-16 source byte count as the destination buffer capacity to UTF8_putc(). For BMP code points above U+07FF, UTF-8 requires three bytes, but the forwarded capacity can be just two bytes, causing a negative return value that results in writing at a negative offset.

Critical Impact

Memory corruption via out-of-bounds write can cause application crashes, Denial of Service, and potentially other security implications when processing untrusted PKCS#12 files.

Affected Products

• OpenSSL 3.6
• OpenSSL 3.5
• OpenSSL 3.4
• OpenSSL 3.3
• OpenSSL 3.0
• OpenSSL 1.1.1

Discovery Timeline

• January 27, 2026 - CVE-2025-69419 published to NVD
• January 29, 2026 - Last updated in NVD database

Technical Details for CVE-2025-69419

Vulnerability Analysis

This out-of-bounds write vulnerability stems from improper buffer capacity handling during UTF-16BE to UTF-8 character conversion in OpenSSL's PKCS#12 parsing functionality. The vulnerability is specifically reachable via the public PKCS12_get_friendlyname() API when parsing attacker-controlled PKCS#12 files.

The core issue lies in the two-pass conversion mechanism within OPENSSL_uni2utf8(). The first pass calculates the required buffer size, while the second pass performs the actual conversion. During the second pass, bmp_to_utf8() incorrectly passes the remaining source byte count rather than the actual available destination buffer capacity to UTF8_putc().

When processing BMP code points above U+07FF (which require 3 UTF-8 bytes for encoding), the function may be told there are only 2 bytes available. This causes UTF8_putc() to return -1, and this negative value is added to the output length without proper validation. The subsequent trailing NUL byte terminator is then written at a negative offset, resulting in a write outside the heap-allocated buffer.

Importantly, PKCS12_parse() uses a different code path that avoids this vulnerability, making PKCS12_get_friendlyname() the primary attack surface. The FIPS modules in versions 3.6, 3.5, 3.4, 3.3, and 3.0 are not affected since the PKCS#12 implementation is outside the OpenSSL FIPS module boundary.

Root Cause

The root cause is an improper buffer capacity calculation in the bmp_to_utf8() helper function during UTF-16BE to UTF-8 conversion. The function incorrectly forwards the remaining UTF-16 source byte count as the destination buffer capacity to UTF8_putc(), rather than tracking the actual available destination buffer space. This logic error allows a negative return value from UTF8_putc() to corrupt the output length tracking, causing the final NUL byte to be written at a negative offset from the buffer start.

Attack Vector

Exploitation of this vulnerability requires an attacker to provide a malicious PKCS#12 file to be parsed by an application using the vulnerable PKCS12_get_friendlyname() function. The attacker must craft a PKCS#12 file with a BMPString friendly name containing specific non-ASCII BMP code points (above U+07FF) to trigger the buffer underflow condition.

The attack is network-accessible when applications accept and process PKCS#12 files from untrusted sources. The attacker can trigger a single zero-byte write before the allocated buffer, which can cause memory corruption leading to application crashes or Denial of Service conditions.

Detection Methods for CVE-2025-69419

Indicators of Compromise

• Unexpected application crashes or segmentation faults when processing PKCS#12 files
• Memory corruption errors in applications using OpenSSL's PKCS12_get_friendlyname() function
• Unusual PKCS#12 files with BMPString friendly names containing non-ASCII characters above U+07FF

Detection Strategies

• Monitor for crashes or abnormal termination in services processing PKCS#12 certificate files
• Implement application-level logging to track PKCS12_get_friendlyname() API calls and their outcomes
• Deploy memory corruption detection tools (AddressSanitizer, Valgrind) in development and testing environments
• Review application logs for errors related to PKCS#12 parsing or UTF-8 conversion failures

Monitoring Recommendations

• Enable core dump analysis for applications processing PKCS#12 files to identify exploitation attempts
• Monitor for sudden increases in PKCS#12 file processing failures or rejections
• Implement file integrity monitoring for uploaded PKCS#12 files to detect potentially malicious submissions
• Configure alerting for repeated crashes in certificate-processing services

How to Mitigate CVE-2025-69419

Immediate Actions Required

• Upgrade OpenSSL to the latest patched version for your release branch immediately
• Audit applications to identify usage of the PKCS12_get_friendlyname() API
• Implement strict input validation for PKCS#12 files from untrusted sources
• Consider using PKCS12_parse() instead of PKCS12_get_friendlyname() where possible, as it uses a different code path

Patch Information

OpenSSL has released security patches addressing this vulnerability across all affected versions. Multiple commits have been published to fix the buffer capacity handling issue:

• OpenSSL Security Advisory (January 27, 2026)
• GitHub Commit 41be0f21
• GitHub Commit 7e9cac98
• GitHub Commit a26a90d3
• GitHub Commit cda12de3
• GitHub Commit ff628933

Organizations should update to the latest patched OpenSSL version available for their deployment. Note that OpenSSL 1.0.2 is not affected by this vulnerability.

Workarounds

• Avoid processing PKCS#12 files from untrusted sources until patches are applied
• If possible, use PKCS12_parse() instead of PKCS12_get_friendlyname() as it follows a different code path
• Implement pre-processing validation to reject PKCS#12 files with suspicious BMPString content
• Deploy web application firewalls or input filters to inspect uploaded certificate files

# Check current OpenSSL version
openssl version -a

# Verify if your application uses the vulnerable function
nm -D /path/to/application | grep PKCS12_get_friendlyname

# Update OpenSSL on Debian/Ubuntu systems
sudo apt update && sudo apt upgrade openssl libssl-dev

# Update OpenSSL on RHEL/CentOS systems
sudo yum update openssl openssl-devel