CVE-2026-17510

Executive Summary

CVE-2026-17510 is a NULL pointer dereference vulnerability (CWE-476) in the Crypt::OpenSSL::PKCS12 Perl module, affecting all versions prior to 1.98. The flaw exists in the print_attribute() function, which incorrectly handles zero-length BMPSTRING attributes when parsing PKCS#12 files via the info_as_hash() method, leading to a crash (denial of service). Applications that process untrusted PKCS#12 files — such as certificate management tools, email clients, or file parsers implemented in Perl — are affected, allowing remote attackers to cause process termination by supplying a crafted malicious PKCS#12 file.

Technical Analysis

The vulnerability resides in the print_attribute() function within the XS (C) layer of the Crypt::OpenSSL::PKCS12 module. The root cause is improper buffer management when handling attributes with a zero-length BMPSTRING value.

Code Path Analysis:

print_attribute() 
  → Renew(*attribute, length, char)   // reallocates buffer based on attribute byte length
  → strncpy(buffer, source, length)   // copies attribute data
  → strlen(buffer)                     // NULL pointer dereference here
  → newSVpvn(buffer, strlen(buffer))   // Perl scalar creation

When a BMPSTRING attribute has a declared length of zero, the Renew() macro performs a zero-size reallocation. In Perl's memory management, this translates to a free() operation that returns NULL, leaving the buffer pointer as NULL. The subsequent strncpy() call with zero length copies nothing (which is benign), but when the caller dereferences the NULL buffer pointer within strlen() to pass to newSVpvn(), the process crashes with a segmentation fault.

Why the malformed attribute passes ASN.1 validation:

• A BMPSTRING is encoded with a length field. A zero-length BMPSTRING has a valid length byte of 0x00.
• BMPSTRING uses 2-byte (UCS-2) encoding, meaning the length must be even. Zero is even, so the ASN.1 BER/DER decoder accepts it as a valid encoded value.
• The ASN.1 parser in OpenSSL does not reject zero-length BMPSTRING values, allowing the malformed value to reach the vulnerable code.

Attack Surface:

• Entry Point: info_as_hash() — a public method that parses a PKCS#12 file and returns its contents as a Perl hash reference.
• Vulnerable Function: print_attribute() — called internally during parsing to format attribute values.
• Vector: Local file processing; the attacker supplies a malicious PKCS#12 file (e.g., via a web upload, email attachment parser, or configuration file handler).

Notable Non-Affected Paths:

• info() method prints attribute values directly without buffer sizing and is not affected.
• UTF8STRING, OCTET STRING, and BIT STRING attribute arms in print_attribute() allocate length + 1 or length * 4 + 1 bytes, ensuring a valid pointer even when length is zero — these vectors are unaffected.

Exploitation Scenarios

Attack Chain (Local Denial of Service):

1. Reconnaissance/Identification: The attacker identifies a target application that uses Crypt::OpenSSL::PKCS12 version < 1.98 with info_as_hash() to process PKCS#12 files. Common targets include Perl-based certificate management tools, email security gateways, or file-processing web applications. The attacker fingerprints the target by observing response patterns, inspecting HTTP headers for Perl/Plack frameworks, or through version disclosure in error messages.

2. Crafting the Malicious PKCS#12: Using OpenSSL command-line tools or a Python/custom script, the attacker creates a legitimate PKCS#12 file, then modifies the certificate attributes section to include a BMPSTRING attribute with a zero length. Technically:

   • Generate a valid certificate and key: openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem
   • Create a normal PKCS#12 bundle: openssl pkcs12 -export -out normal.p12 -inkey key.pem -in cert.pem
   • Use a hex editor or a custom Perl/Python script to locate an attribute value in the localKeyID or friendlyName attribute and replace its length field with 0x00, ensuring the BMPSTRING content length bytes are set to zero while maintaining valid DER structure.

3. Trigger/Delivery: The attacker delivers the malicious .p12 file to the target through any input channel the application exposes:

   • If the target is a web application with a certificate upload feature, the attacker uploads the file directly via HTTP multipart POST.
   • If the target is a mail parsing daemon, the attacker sends an email with the .p12 as an attachment.
   • If the target processes configuration files, the attacker replaces the configuration and triggers a reload.

4. Exploitation: The target application calls info_as_hash() on the malicious PKCS#12 file. The parser iterates the attributes and reaches the zero-length BMPSTRING. Inside print_attribute():

   • Renew() returns NULL (because realloc size is 0).
   • strncpy() with length 0 is a no-op, leaving pointer NULL.
   • strlen(NULL) triggers SIGSEGV — the process crashes.

5. Post-Exploitation Impact: The application process terminates. If this is a long-running daemon without automatic restart, it remains down until an operator intervenes. In a web environment, this could result in the entire request worker pool crashing if the worker process handles concurrent requests. Repeated exploitation allows indefinite denial of service. The attacker gains no code execution, but can take the service offline at will.

Impact Assessment

Business Impact: High availability risk. The vulnerability provides an unauthenticated (in most web scenarios) denial-of-service vector against any service processing untrusted PKCS#12 files. The crash is deterministic and trivially reproducible, making DoS attacks highly reliable.

Affected Systems: Any environment running Crypt::OpenSSL::PKCS12 versions 0.x through 1.97. This includes:

• Perl-based certificate management and PKI tooling.
• Web applications with certificate upload/import features (e.g., VPN portal provisioning, S/MIME key import).
• Email processing pipelines that inspect PKCS#12 attachments.
• Enterprise secrets management tools written in Perl.

Blast Radius: Medium. The vulnerability is local-to-the-parsing-process and does not provide RCE, information disclosure, or memory corruption beyond the NULL dereference (no write primitive). The primary impact is availability (integrity and confidentiality are unaffected). As CVSS is N/A, the qualitative assessment is based on the CWE-476 class — typically rated Medium (5.0–6.5) when the attack vector is local/adjacent and impact is limited to availability. In web-facing scenarios where the PKCS#12 file can be uploaded by unauthenticated users, the severity estimate rises to High (7.5+) because availability is easily compromised remotely.

Contextual Risks: The crash occurs in the main thread of the calling process. If the application runs with elevated privileges (e.g., a service account), a crash will not lead to privilege escalation but will disrupt the service. Memory safety is not fully compromised — no arbitrary code execution is achievable through this flaw.

Detection Guidance

Sigma Rule

title: Crash in Crypt::OpenSSL::PKCS12 via Malformed PKCS#12 File
id: 3f1b5c9a-7e22-4d31-9c4d-5a77f4e91bc2
status: experimental
description: Detects attempts to exploit CVE-2026-17510 by passing a PKCS#12 file containing a zero-length BMPSTRING attribute to Crypt::OpenSSL::PKCS12.
logsource:
  category: application
  product: generic
  service: perl
detection:
  selection_crash:
    - ApplicationError|contains: 'strlen'
    - ApplicationError|contains: 'Segmentation fault'
    - ApplicationError|contains: 'NULL pointer'
  selection_context:
    - ProcessCommandLine|contains|all:
        - 'pkcs12'
        - 'info_as_hash'
        - '.p12'
    - ApplicationLog|contains: 'Crypt::OpenSSL::PKCS12'
  condition: selection_crash and selection_context
  timeframe: 5m
falsepositives:
  - Legitimate application bugs resulting in generic segfaults
  - Non-malicious malformed files (user error)
level: medium
tags:
  - attack.t1203
  - cve.2026.17510
  - cwe.476

YARA Rule

rule CVE_2026_17510_Malicious_PKCS12_BMPSTRING
{
    meta:
        author = "Valters IT Security"
        description = "Detects PKCS#12 files containing zero-length BMPSTRING attributes targeting CVE-2026-17510"
        cve = "CVE-2026-17510"
        cwe = "CWE-476"
        date = "2026-01-15"
        severity = "high"
    strings:
        // Look for the localKeyID or friendlyName attribute OID (1.2.840.113549.1.9.21)
        $oid_lockeyid = { 06 09 2A 86 48 86 F7 0D 01 09 15 }
        // ASN.1 BMPSTRING tag (0x1E) followed by zero length (0x00)
        $bmpstring_zero = { 1E 00 }
        // ASN.1 BMPSTRING tag (0x1E) followed by any length then zero-length content
        $bmpstring_short = { 1E 00 }
        // DER sequence containment check marker
        $der_next = { 30 }
    condition:
        uint32(0) == 0x00000000 and
        any of them and
        #bmpstring_zero >= 1
}

Suricata IDS Rule

alert http any any -> $HOME_NET any (msg:"CVE-2026-17510 - Malicious PKCS#12 file with zero-length BMPSTRING attribute detected"; flow:established,to_server; content:"multipart/form-data"; http.content_type; pcre:"/(PKCS12|\.p12|application\/x-pkcs12)/i"; content:"filename=\""; http.client_body; content:".p12"; pcre:"/\\x30\\x82[\\x00-\\xff]{2}\\x30[\\x00-\\xff]{2}\\x06\\x09\\x2A\\x86\\x48\\x86\\xF7\\x0D\\x01\\x09\\x15/"; pcre:"/\\x1E\\x00[\\x00-\\xff]{0}/"; classtype:attempted-dos; sid:202617510; rev:1; metadata:created_at 2026_01_15, cve CVE-2026-17510, cwe CWE-476, attack_target Client_Endpoint, deployment Perimeter, tag DoS;)

Elastic Detection

sequence by host.name, process.pid with maxspan=30s
  [ process where event.action == "exec" and process.args : ("*.p12", "*.pfx") and process.args : ("info_as_hash*") ]
  [ event where event.kind == "event" and event.category == "process" and process.exit_code == -11 and
    process.name : ("*perl*") and
    process.command_line : ("*PKCS12*", "*.p12*") ]
  [ error where error.message : ("*NULL pointer*", "*strlen*", "*Segmentation fault*") ]

Splunk SPL Query

(index=os_log OR index=windows OR index=main) 
  sourcetype=*perl* OR sourcetype=*syslog* OR sourcetype=WinEventLog:Application
  ("segmentation fault" OR "SIGSEGV" OR "NULL pointer" OR "strlen" OR "Signal 11")
  AND ("PKCS12" OR "pkcs12" OR ".p12" OR "info_as_hash")
  | eval severity = "high"
  | eval tactic = "T1203 - Exploitation for Client-Side Execution"
  | stats count by host, source, _time, severity, tactic
  | sort - _time
  `cti_indicators` 

Wazuh OSSEC Rule

<group name="cve-2026-17510,">
  <rule id="100286" level="12">
    <decoded_as>syslog</decoded_as>
    <match>segmentation fault|SIGSEGV|NULL pointer|strlen</match>
    <description>CVE-2026-17510: Possible NULL pointer dereference in Crypt::OpenSSL::PKCS12 info_as_hash() on Perl (PKCS#12 parsing crash)</description>
    <match>PKCS12|pkcs12|\.p12|info_as_hash</match>
    <group>perl,application,cve-2026-17510,</group>
    <mitre>
      <id>T1203</id>
    </mitre>
    <field name="cve">CVE-2026-17510</field>
    <field name="cwe">CWE-476</field>
    <alert>always</alert>
    <options>no_full_log</options>
  </rule>
</group>

Mitigation & Patch Guidance

Patch Confidence: 0/4 — UNPATCHED — no patch evidence from any tracked source. The vendor (project maintainer of Crypt::OpenSSL::PKCS12) has not released an official fix as of this report. Expect an updated version ≥ 1.98.

1) Immediate Mitigations (until patch is available):

• Sanitize input: Before passing untrusted PKCS#12 files to info_as_hash(), pre-validate the file structure. Reject files containing zero-length BMPSTRING attributes. A simple check can scan for the byte sequence 1E 00 (BMPSTRING tag + zero length) in the DER structure.
• Use an isolated parsing process: Run info_as_hash() in a forked child process or a separate worker. If it crashes, the parent process can detect the child death and restart it without terminating the main application.
• Switch to safe API: Use the info() method instead of info_as_hash() where possible — info() prints attributes without buffer sizing and is not affected.
• Restrict untrusted input: Do not accept PKCS#12 uploads from unauthenticated/untrusted users. Add authentication and file validation at the web application layer.
• Memory limit wrapper: Run the parsing under a resource-limited container (e.g., using ulimit -c 0, setrlimit) to minimize impact of repeated crashes.

2) Patch/Upgrade Steps:

• Monitor the CPAN module page (https://metacpan.org/pod/Crypt::OpenSSL::PKCS12) for version 1.98 or later.
• Once released, upgrade:

  cpan -i Crypt::OpenSSL::PKCS12
  # or
  cpanm Crypt::OpenSSL::PKCS12@1.98
  

• For Debian/Ubuntu systems using the distribution package, update via apt update && apt upgrade libcrypt-openssl-pkcs12-perl.

3) Long-Term Hardening:

• Adopt stronger validation: Implement ASN.1 DER validation using a hardened parser (e.g., Convert::ASN1 with strict length checks) before any OpenSSL parsing occurs.
• Memory-safe alternatives: Consider migrating long-term to alternative Perl modules with better memory management (e.g., newer XS implementations, or use Crypt::OpenSSL::X509 which has different parsing logic), or write a thin wrapper in a memory-safe language (Rust/Python) for PKCS#12 parsing.
• Run-time protections: Use OS-level ASLR, stack canaries, and supervisor restart policies (systemd Restart=on-abort, supervisord autorestart) for services that process untrusted files.
• Active monitoring: Deploy the detection rules above (Sigma, Suricata, Wazuh) across endpoints and network perimeters.

References

1. NVD Entry: https://nvd.nist.gov/vuln/detail/CVE-2026-17510
2. CPAN Module Page (vendor): https://metacpan.org/pod/Crypt::OpenSSL::PKCS12
3. Perl Bug/Issue Tracker (CPAN RT): https://rt.cpan.org/Public/Dist/Display.html?Name=Crypt-OpenSSL-PKCS12
4. CWE-476 Reference (NULL Pointer Dereference): https://cwe.mitre.org/data/definitions/476.html
5. MITRE ATT&CK T1203 (Exploitation for Client-Side Execution): https://attack.mitre.org/techniques/T1203/

Threat Actor Activity: No known threat actor campaigns have been observed exploiting this CVE as of this report's date. There is no evidence of exploitation in the wild, and no public exploit code has been released. The vulnerability is exclusively a denial-of-service primitive with no confirmed privilege escalation or code execution path. CVE-2026-17510 is NOT present on the CISA Known Exploited Vulnerabilities (KEV) catalog and is not yet scored by FIRST.org EPSS.