CVE-2025-14547

Executive Summary

CVE-2025-14547 is an integer underflow vulnerability in Silicon Labs’ implementation of PSA Crypto and SE Manager EC-JPAKE APIs. The flaw resides in the Zero-Knowledge Proof (ZKP) parsing logic, where an attacker can trigger an integer underflow condition. This underflow leads to a hard fault in the system, causing a temporary denial of service (DoS). The vulnerability affects devices using Silicon Labs’ cryptographic libraries and SE Manager firmware, potentially impacting IoT, embedded, and secure element applications. No public exploit code or patch is currently available, and the CVSS score is listed as 0.0, indicating incomplete assessment. The EPSS score is 0.0%, suggesting low exploitation likelihood at this time, but the lack of a patch makes it a latent risk.

Supply Chain & Package Security

This vulnerability is not related to NPM, PyPI, Go, or Ruby packages. It affects Silicon Labs’ proprietary firmware and cryptographic libraries used in embedded systems and secure elements. Organizations using Silicon Labs hardware (e.g., EFR32, EFM32, or Secure Vault devices) should monitor for firmware updates from Silicon Labs.

CVSS Breakdown & Threat Level

The CVSS score is listed as 0.0, which is likely a placeholder or incomplete assessment. Based on the vulnerability description, a reasonable CVSS vector would be:

• Attack Vector (AV): Local (L) – Requires local access to the device or ability to send crafted ZKP messages.
• Attack Complexity (AC): High (H) – Requires understanding of EC-JPAKE protocol and ZKP parsing.
• Privileges Required (PR): None (N) – No authentication needed to trigger the underflow.
• User Interaction (UI): None (N) – No user action required.
• Scope (S): Unchanged (U) – Affects only the vulnerable component.
• Confidentiality (C): None (N) – No data exposure.
• Integrity (I): None (N) – No data modification.
• Availability (A): High (H) – Causes hard fault and temporary DoS.

Estimated CVSS Vector: CVSS:3.1/AV:L/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Estimated Base Score: 5.1 (Medium)

Threat Level: Medium – Exploitation requires local access and protocol knowledge, but impact is denial of service.

Deep Dive & Mechanics

The vulnerability is an integer underflow in the ZKP parsing routine of Silicon Labs’ PSA Crypto and SE Manager EC-JPAKE APIs. EC-JPAKE (Elliptic Curve Password Authenticated Key Exchange) uses Zero-Knowledge Proofs to verify knowledge of a password without revealing it. The ZKP parsing function likely processes a length field or counter without proper validation, allowing an attacker to supply a value that causes an integer underflow (e.g., subtracting 1 from 0 results in a large positive number). This underflow can lead to a buffer over-read or infinite loop, ultimately causing a hard fault (e.g., memory access violation or watchdog timeout) and temporary denial of service.

Root Cause: Missing bounds check on a length or index variable during ZKP parsing.
Impact: Hard fault, device reset, or temporary unavailability of cryptographic services.
Attack Vector: An attacker with local access to the device (e.g., via a compromised application or physical interface) sends a crafted EC-JPAKE message with malformed ZKP data.

Vulnerable vs. Patched Code

No patch is available. The vulnerable code likely resembles:

// Vulnerable pseudo-code
int parse_zkp(uint8_t *data, uint16_t len) {
    uint16_t zkp_len = data[0]; // Attacker controls this
    // Missing check: if (zkp_len > len) return error;
    uint16_t remaining = len - 1;
    // Underflow if zkp_len is 0 and len is 1: remaining becomes 65535
    while (remaining > 0) {
        // Process ZKP data
        remaining--;
    }
    return 0;
}

A patched version would include a bounds check:

// Patched pseudo-code
int parse_zkp(uint8_t *data, uint16_t len) {
    if (len < 1) return -1;
    uint16_t zkp_len = data[0];
    if (zkp_len > len - 1) return -1; // Bounds check
    uint16_t remaining = len - 1;
    while (remaining > 0) {
        // Process ZKP data
        remaining--;
    }
    return 0;
}

Exploitation & Lab Setup

Red Team (Offensive)

Prerequisites:

• Access to a Silicon Labs device with vulnerable firmware (e.g., EFR32MG24 with SE Manager).
• Ability to send raw EC-JPAKE messages (e.g., via UART, BLE, or Zigbee).
• Knowledge of the EC-JPAKE protocol and ZKP structure.

Exploitation Steps:

1. Identify the target device and its communication interface.
2. Craft an EC-JPAKE message with a ZKP length field set to 0 (or a value that causes underflow).
3. Send the malformed message to the device’s PSA Crypto or SE Manager API.
4. Observe the device hard fault (e.g., watchdog reset, LED pattern, or serial output).

Example Payload (Hex):

// EC-JPAKE message with ZKP length = 0x00
00 01 02 03 ... (rest of message)

Note: No public exploit code is available. This is a theoretical approach.

Blue Team (Defensive)

Detection:

• Monitor for unexpected device resets or hard faults in logs.
• Use intrusion detection systems (IDS) to flag malformed EC-JPAKE messages.
• Implement input validation on all ZKP parsing functions.

Mitigation:

• Apply firmware updates from Silicon Labs when available.
• Use hardware security modules (HSMs) to offload cryptographic operations.
• Restrict physical and logical access to devices.

Indicators of Compromise (IOCs)

• Network: Malformed EC-JPAKE messages with ZKP length field set to 0 or causing underflow.
• System: Unexpected hard faults, watchdog resets, or device reboots.
• Logs: Error messages related to PSA Crypto or SE Manager, e.g., "Hard fault at address 0xXXXX".
• Firmware: Vulnerable versions of Silicon Labs PSA Crypto and SE Manager (specific versions unknown).

Detection Engineering

YARA Rule

rule CVE_2025_14547_ZKP_Underflow {
    meta:
        description = "Detects malformed EC-JPAKE ZKP messages with potential integer underflow"
        author = "Valters IT"
        date = "2025-04-10"
        cve = "CVE-2025-14547"
    strings:
        $zkp_header = { 00 01 02 03 } // Example EC-JPAKE header
        $zero_length = { 00 } // ZKP length field set to 0
    condition:
        $zkp_header at 0 and $zero_length at 4
}

Sigma Rule

title: CVE-2025-14547 - Integer Underflow in Silicon Labs EC-JPAKE ZKP Parsing
id: 12345678-1234-1234-1234-123456789abc
status: experimental
description: Detects malformed EC-JPAKE messages that may trigger integer underflow in Silicon Labs PSA Crypto/SE Manager.
author: Valters IT
date: 2025-04-10
logsource:
    product: silicon_labs
    service: se_manager
detection:
    selection:
        event_id: 1001 # Example hard fault event
        message: "Hard fault at address 0x*"
    condition: selection
falsepositives:
    - Legitimate firmware bugs
level: high

Suricata Rule

alert tcp any any -> any any (msg:"CVE-2025-14547 - EC-JPAKE ZKP Underflow Attempt"; content:"|00 01 02 03|"; offset:0; depth:4; content:"|00|"; offset:4; depth:1; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Isolate affected devices from untrusted networks until a patch is available.
2. Monitor for hard faults and device resets in logs.
3. Implement input validation on all ZKP parsing functions (if source code is accessible).

Long-Term Fix:

• Apply firmware updates from Silicon Labs when released.
• Consider using alternative cryptographic libraries (e.g., Mbed TLS) if possible.
• Upgrade to hardware with Secure Vault High (SVH) features that may mitigate such faults.

Workarounds:

• Disable EC-JPAKE functionality if not required.
• Use network segmentation to limit exposure.

Valters IT
DevSecOps & Cyber Threat Intelligence