OpenSSL CVE-2026-84783

Requires the affected process to be running OpenSSL 4.0.0-4.0.2 and to access the X.509 extension cache of a certificate concurrently from multiple threads - the bug is a use-after-free that only manifests 'under concurrent use' of the same certificate object. The attacker must be able to supply or influence a certificate that is parsed (e.g. via TLS handshake, certificate-chain validation, or CMP/CRL processing) while such concurrent access occurs. Limiting factors: exploitation depends on a timing-sensitive thread race (not a deterministic single-shot input), so single-threaded or non-shared certificate handling is not affected; the maximum realistic impact is a crash/denial of service (no confidentiality or integrity impact per C:N/I:N).

This is a genuine but availability-bounded issue. The official CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H, 7.5) rates only availability impact - a use-after-free in the X.509 extension cache under concurrent access, i.e. a memory-safety crash/DoS, NOT information disclosure or code execution despite the 'Information Disclosure' tag (which contradicts C:N and is misleading). No EPSS score, no CISA KEV listing, and no public POC are present in the input, so exploitation status is 'no public exploit identified at time of analysis.' The signals are consistent with a low-immediacy but broadly-relevant bug: OpenSSL is ubiquitous, so the affected footprint is enormous, but the trigger is a concurrency race ('under concurrent use') that requires the target application to parse attacker-supplied certificates while sharing/reusing the same X.509 object across threads. The vendor's AC:L is questionable for a race condition - reliably winning a use-after-free window across threads is closer to AC:H, which lowers realistic exploitability. Reachability also depends on the application: only software that concurrently accesses cached extensions on a shared certificate is exposed. Net: a real, patch-now hygiene item because of OpenSSL's prevalence, but not an emergency in the absence of exploitation evidence, and its worst credible outcome is a crash/DoS rather than compromise.

An attacker supplies a crafted X.509 certificate (e.g. as a TLS client/server certificate or in a chain) to a server that concurrently parses and accesses the certificate's cached extensions across multiple threads. By racing concurrent access to the freed extension-cache structure, the attacker triggers a use-after-free that crashes the process, causing denial of service. No public exploit code is identified at time of analysis, and successful triggering depends on winning a timing-sensitive race.