/

CVE-2026-11310

Severity:

HIGH RISK

(7.5)

X.509 Trust-Chain Bypass (CWE-295) in wolfSSL Cert Verify

CVE-2026-11310

Analyzed

Vulnerability type

Category:

Improper Certificate Validation

CWE:

CWE-295

Impact:

Authentication and trust bypass in X.509 certificate validation

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A trust-chain bypass in wolfSSL's OpenSSL compatibility certificate verifier allows untrusted intermediates to be treated as trust anchors when validating X.509 chains.

In builds using OPENSSL_EXTRA where applications call X509_verify_cert() with caller-supplied intermediates, an attacker can have a non‑anchored certificate chain accepted as trusted, enabling use of attacker-controlled certificates.

Affected context

This vulnerability occurs in wolfSSL deployments built with --enable-opensslextra (OPENSSL_EXTRA) that use the OpenSSL compatibility API wolfSSL_X509_verify_cert() or X509_verify_cert() for certificate validation.

It becomes relevant when applications supply untrusted intermediate certificates to the verifier and perform manual or deferred peer verification, such as for S/MIME/CMS, code or firmware signing, or JWT/JWS x5c processing.

Native wolfSSL TLS/DTLS handshakes using the default WOLFSSL_VERIFY_PEER path are not affected, and builds that do not load caller-supplied intermediates into the verifier are generally outside the vulnerable context.

Exploit preconditions

  • Attack surface: Any component or protocol that relies on wolfSSL's OpenSSL compatibility certificate verification (e.g., S/MIME, CMS, code signing, firmware validation, JWT/JWS) and accepts external certificate chains.
  • Required access: Ability to supply or influence the certificate chain passed to X509_verify_cert(), including untrusted intermediate certificates.
  • Trigger point: Invocation of wolfSSL_X509_verify_cert() / X509_verify_cert() in a build configured with --enable-opensslextra and using --enable-sessioncerts, while caller-provided intermediates are loaded into the certificate manager.
  • Why exploitation is possible: The verifier temporarily loads untrusted intermediate certificates into the certificate store and fails to remove them before performing the trust-store check.

As a result, a caller-supplied intermediate can serve as the effective trust anchor, allowing a chain that never reaches a configured CA to be accepted as if it were trusted.

Why this happens

The root cause is an improper trust anchor management pattern in the certificate verification logic, corresponding to CWE-295: Improper Certificate Validation.

The verifier design loads caller-supplied intermediate certificates into the certificate manager to assist path building but does not reliably separate them from the configured trusted CA store when performing the trust check.

Because these intermediates remain present during the trust anchor evaluation, the verification step can incorrectly treat an untrusted intermediate as a trusted root, breaking the assumption that only pre-configured, vetted CAs can anchor a certificate chain.

Abstractly, this reflects a common bug class where temporary or helper credentials are not isolated from trust stores, resulting in elevation of untrusted material into trusted status during validation.

Potential impact

  • An attacker can have a certificate chain that lacks a real trusted CA accepted as valid.
  • Attackers may impersonate trusted entities in systems relying on X.509 certificate checks (e.g., signed firmware, code, or documents).
  • Malicious updates or binaries could be treated as legitimately signed and deployed.
  • Sensitive data could be processed or decrypted under false trust assumptions.
  • Integrity protections on content or communications using X.509-anchored signatures can be undermined.

General mitigation guidance

Mitigation generally focuses on enforcing strict separation between caller-supplied certificates and the trusted store and tightening trust boundary handling in verification logic.

Secure patterns include:

  • Ensuring temporary or untrusted intermediates are never persisted or considered in trusted store lookups, and actively removing them before trust-anchor evaluation.
  • Designing certificate managers so that trusted anchors and helper certificates are stored in distinct, non-overlapping collections with explicit checks for trust flags.
  • Treating all caller-supplied intermediates as untrusted input and limiting them only to path construction, not trust decision-making.
  • Adopting a "trust-minimizing" approach: only explicitly configured CAs or pinned end-entities may anchor validation, and unrecognized intermediates cannot elevate themselves.
  • Applying defense-in-depth by combining X.509 chain checks with explicit key pinning or application-level whitelist rules where appropriate.

How teams detect issues like this

Detection typically involves scrutinizing certificate validation flows and trust-store interactions rather than specific attack payloads.

Useful strategies include:

  • Static analysis rules that flag code paths where untrusted, caller-supplied certificates are added to global or shared certificate stores used for trust decisions.
  • Code review practices focusing on the lifecycle of intermediate certificates: reviewers should verify that helpers are scoped narrowly and removed before trust checks.
  • Architectural reviews to confirm that trust anchors are defined in immutable or strictly-controlled stores and that no runtime inputs can modify those stores during verification.
  • Policy enforcement in CI/CD that prohibits mixing trusted CA configuration with runtime-supplied certificates, and that requires explicit marking of trust anchors versus intermediates.
  • Use of automated security tooling or unit tests that simulate chains with untrusted intermediates and assert that such chains fail validation.

Sources

SourceLink
github.comgithub.com/wolfSSL/wolfssl/pull/10674
wolfssl.comwolfssl.com/docs/security-vulnerabilities/

Frequently asked

questions

No. The issue affects any use of wolfSSL's OpenSSL compatibility certificate verifier where X509_verify_cert() processes caller-supplied intermediates, including S/MIME, CMS, code/firmware signing, and JWT/JWS x5c. Native wolfSSL TLS/DTLS using default verification options is generally not impacted.

An attacker must be able to supply or control the certificate chain given to the verifier, particularly one or more untrusted intermediate certificates. This is common in scenarios where clients or external systems provide full chains for validation.

The safest fix pattern is to refactor certificate validation so that trusted anchors are strictly separated from any caller-supplied intermediates, ensuring untrusted certificates are never elevated into the trusted CA store and are removed or isolated before trust decisions are made.

Prevent them by designing PKI code with clear trust boundaries, using distinct structures for trusted CAs versus helper intermediates, enforcing strict policies on what can modify trust stores, and regularly reviewing validation logic with automated tests and static analysis to confirm that only explicitly configured trust anchors can accept chains.

Find out what's already
exploitable in your codebase.