CVE-2025-7390

Executive Summary

CVE-2025-7390 is a critical vulnerability in the OPC Foundation’s OPC UA HTTPS (opc.https) server implementation. The flaw allows a malicious client to completely bypass the client certificate trust check when the server endpoint is configured to require secure communication only. This means an attacker without a valid, trusted client certificate can still establish a secure channel and potentially gain unauthorized access to OPC UA data and operations. The CVSS score of 9.1 (Critical) reflects the ease of exploitation (network-based, low complexity, no privileges required) and the high impact on confidentiality, integrity, and availability. No public proof-of-concept (PoC) or exploit code is currently available, but the vulnerability is considered highly dangerous due to the widespread use of OPC UA in industrial control systems (ICS) and critical infrastructure.

Supply Chain & Package Security

This vulnerability is not in a typical software package manager (NPM, PyPI, Go, Ruby) but in the OPC Foundation’s core protocol stack. The impact is on any vendor or integrator that uses the OPC Foundation’s HTTPS transport implementation. Organizations should audit their OPC UA server deployments to determine if they use the vulnerable opc.https transport and apply any vendor-specific patches or workarounds as they become available.

CVSS Breakdown & Threat Level

• CVSS Vector: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
• Base Score: 9.1 (Critical)
• Attack Vector: Network (AV:N) – Exploitable remotely.
• Attack Complexity: Low (AC:L) – No special conditions required.
• Privileges Required: None (PR:N) – No authentication needed.
• User Interaction: None (UI:N) – No user action required.
• Scope: Unchanged (S:U) – Impact confined to the vulnerable component.
• Confidentiality Impact: High (C:H) – Full read access to OPC UA data.
• Integrity Impact: High (I:H) – Ability to modify data or commands.
• Availability Impact: High (A:H) – Potential to disrupt operations.

Threat Level: Critical. The vulnerability is trivial to exploit and can lead to full compromise of OPC UA servers, which are often used in critical infrastructure (energy, manufacturing, water treatment). The lack of a patch increases the urgency for compensating controls.

Deep Dive & Mechanics

The OPC UA protocol supports multiple transport protocols, including HTTPS (opc.https). When configured for “secure communication only,” the server is supposed to require a valid client certificate that chains to a trusted root CA. The vulnerability lies in the certificate chain validation logic within the opc.https server implementation.

Root Cause: The server fails to properly validate the client certificate’s trust chain. Specifically, it may accept a self-signed certificate or a certificate signed by an untrusted CA as valid, effectively bypassing the trust check. This could be due to:

• Missing or incorrect call to X509_verify_cert() or equivalent.
• Improper handling of certificate chain building errors.
• A logic flaw where the server accepts any certificate presented during the TLS handshake without verifying its issuer.

Attack Flow:

1. Attacker generates a self-signed client certificate (or uses any certificate).
2. Attacker initiates an HTTPS connection to the vulnerable OPC UA server.
3. The server’s TLS handshake accepts the attacker’s certificate without verifying its trust chain.
4. The attacker is now authenticated as a legitimate client and can perform OPC UA operations (read, write, subscribe, etc.) according to the server’s access control rules (which may be permissive).

Impact: An attacker can:

• Read sensitive process data (e.g., sensor readings, production metrics).
• Write malicious values to control parameters (e.g., setpoints, alarms).
• Subscribe to data changes and monitor industrial processes.
• Potentially cause physical damage by manipulating control logic.

Vulnerable vs. Patched Code

Since no official patch is available, the following is a hypothetical comparison based on common certificate validation patterns.

Vulnerable Code (Conceptual C++):

// Vulnerable: Accepts any certificate without chain validation
bool validate_client_certificate(X509* cert) {
    // Missing: X509_verify_cert() or chain building
    return true; // Always returns true
}

Patched Code (Conceptual C++):

// Patched: Properly validates certificate chain
bool validate_client_certificate(X509* cert, STACK_OF(X509)* trusted_cas) {
    X509_STORE* store = X509_STORE_new();
    for (int i = 0; i < sk_X509_num(trusted_cas); i++) {
        X509_STORE_add_cert(store, sk_X509_value(trusted_cas, i));
    }
    X509_STORE_CTX* ctx = X509_STORE_CTX_new();
    X509_STORE_CTX_init(ctx, store, cert, NULL);
    int ret = X509_verify_cert(ctx);
    X509_STORE_CTX_free(ctx);
    X509_STORE_free(store);
    return ret == 1; // Only return true if verification succeeds
}

Exploitation & Lab Setup

Red Team (Exploitation)

Prerequisites:

• A vulnerable OPC UA server (e.g., OPC Foundation’s sample server or a vendor product using the vulnerable stack).
• Network access to the server’s HTTPS endpoint (default port 443 or custom).
• OpenSSL or similar tool to generate a self-signed certificate.

Steps:

1. Generate a self-signed client certificate:

   openssl req -x509 -newkey rsa:2048 -keyout attacker.key -out attacker.crt -days 365 -nodes -subj "/CN=attacker"
   

2. Use a tool like curl or a custom OPC UA client to connect with the attacker certificate:

   curl --cert attacker.crt --key attacker.key https://target-server:443/opcua
   

3. If the server is vulnerable, the connection will succeed, and the attacker can send OPC UA requests.

Note: No public exploit code is available. The above is a generic approach.

Blue Team (Detection & Hardening)

Detection:

• Monitor for TLS connections using self-signed or untrusted client certificates.
• Log all client certificate validation failures (if the server logs them).
• Use network monitoring to detect anomalous OPC UA traffic from unknown clients.

Hardening (Compensating Controls):

• If possible, disable the opc.https transport and use opc.tcp with mutual TLS (mTLS) instead.
• Implement network segmentation to restrict access to OPC UA servers to trusted IP ranges only.
• Use a Web Application Firewall (WAF) or API gateway to inspect OPC UA over HTTPS traffic.
• Apply vendor-specific patches as soon as they become available.
• Monitor vendor advisories from the OPC Foundation and your OPC UA stack provider.

Indicators of Compromise (IOCs)

• Network:
  • TLS handshakes with client certificates that do not chain to a trusted root CA.
  • OPC UA sessions established from unexpected IP addresses or without proper client certificate validation.
• Logs:
  • Server logs showing successful connections from clients with self-signed certificates (if logging is enabled).
  • Absence of certificate validation failure logs when expected.
• System:
  • Unauthorized changes to OPC UA data points or control parameters.
  • Unexpected subscriptions or read requests from unknown clients.

Detection Engineering

YARA Rule

rule CVE_2025_7390_OPC_HTTPS_BYPASS {
    meta:
        description = "Detects potential exploitation of CVE-2025-7390 by identifying self-signed client certificates in OPC UA HTTPS traffic"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "CVE-2025-7390"
    strings:
        $s1 = "-----BEGIN CERTIFICATE-----" ascii
        $s2 = "OPCUA" ascii
        $s3 = "https" ascii
    condition:
        $s1 and $s2 and $s3
}

Sigma Rule

title: OPC UA Client Certificate Bypass Attempt
id: 8f4c3b2a-1d5e-4f7a-9c8b-0a1b2c3d4e5f
status: experimental
description: Detects TLS connections to OPC UA HTTPS endpoints using self-signed or untrusted client certificates
author: Valters IT
date: 2025-04-10
references:
    - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-7390
logsource:
    category: network
    product: zeek
    service: ssl
detection:
    selection:
        server_name|contains: "opcua"
        client_cert_chain_issuer: "self-signed"
    condition: selection
falsepositives:
    - Legitimate testing with self-signed certificates
level: high

Suricata Rule

alert tls $EXTERNAL_NET any -> $HOME_NET 443 (msg:"CVE-2025-7390 OPC UA Client Certificate Bypass"; flow:to_server,established; tls.cert_issuer:!".*trustedCA.*"; tls.sni; content:"opcua"; nocase; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Disable opc.https transport if not required. Use opc.tcp with mTLS instead.
2. Implement network segmentation – restrict access to OPC UA servers to trusted IPs only.
3. Enable logging of all client certificate validation attempts and monitor for failures.
4. Apply vendor patches as soon as they are released. Contact your OPC UA stack provider for updates.

Long-Term Fixes:

• The OPC Foundation must release a patched version of the opc.https stack that properly validates client certificate chains.
• Organizations should adopt a zero-trust architecture for OPC UA communications, requiring mutual TLS with strict certificate validation.

Workaround:

• If opc.https is required, consider using a reverse proxy (e.g., Nginx, HAProxy) that performs client certificate validation before forwarding traffic to the OPC UA server. This adds an additional layer of defense.

Valters IT – DevSecOps & Cyber Threat Intelligence