Enterprise Linux EUVD-2025-20927

We are tasked with synthesizing data for CVE-2025-32989 into a JSON output. We need to follow strict instructions.

First, extract required fields. The CVE description mentions: heap-buffer-overread in GnuTLS when handling Certificate Transparency SCT extension (OID 1.3.6.1.4.1.11129.2.4.2). Flaw allows a malicious user to create a certificate with malformed SCT to expose sensitive data. CVSS: 5.3, AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N. CWE-295 is given, but that's "Improper Certificate Validation" which doesn't directly match buffer overread; perhaps it's misclassification? Actually, the description says "Improper Certificate Validation" might be because it's about how SCT is checked? But the root cause is heap-buffer-overread which is CWE-126 (Heap-based Buffer Overflow) or CWE-125 (Out-of-bounds Read). The provided CWE is CWE-295, but I'll note that in confidence_notes if needed. We'll use it as given but note discrepancy. CWE-295 relates to improper certificate validation, so maybe the issue is that the SCT isn't validated properly, leading to reading sensitive data? But the description says heap-buffer-overread, so it's a memory safety flaw. The CWE seems inconsistent; I'll mention that. Actually the instruction says "Reference the CWE to explain the root cause class" — so we must reference CWE-295. I'll incorporate it but note it's about validation, leading to overread? We'll phrase accordingly.

We have EPSS: 0.10% (percentile 28%), low. Patch available from vendor. KEV not mentioned, so not in KEV. POC not mentioned publicly. But there is a patch, so exploitation status: no public exploit identified (since no KEV, no POC mentioned). The description says "malicious user can create a certificate", so it involves a specifically crafted certificate, and the victim (GnuTLS) processes it. CVSS vector indicates AV:N, PR:N, so remote, no authentication needed to send the malicious certificate? That seems plausible: a malicious server presents a certificate with malformed SCT extension to a client using GnuTLS, causing the client to leak memory contents? Or a client presents such certificate to a server? The description says "when GnuTLS verifies certificates from certain websites" so likely the client side: a server presents a malicious certificate to a client using GnuTLS. So attacker controls the TLS server. That's practical: a malicious website or MITM could serve the certificate. So unauthenticated remote.

Technical context: involved technology: GnuTLS library for TLS/SSL, specifically certificate parsing, X.509, Certificate Transparency extension (SCT). Exact versions? The CPE for gnu:gnutls:- means all versions? We'll infer from Red Hat errata versions. EUVD gives patch versions per distribution: RHEL 9: 0:3.8.3-6.el9_6.2, RHEL 8 presumably? We'll list affected products: GnuTLS library itself, and Red Hat distributions, Ubuntu, Debian, SUSE. Use references. For affected products we'll compose a concise paragraph.

Risk assessment: CVSS 5.3, EPSS low, no active exploitation. Attack vector network, low complexity, no privileges required, no user interaction? Wait, CVSS says UI:N, but in this scenario, the user must browse to a malicious website or connect to a malicious server. That does require user interaction? Actually, CVSS UI:N means no user interaction, i.e., the vulnerability can be exploited without any user action, perhaps if the server is connecting to a malicious service? But the typical scenario: user visits a website (requires user to initiate), but that's often considered UI:R (Required). However, NVD's vector says UI:N, so they consider that no user action is needed? Possibly because the vulnerability could be triggered by automated processes (e.g., an application that fetches TLS certs automatically). I'll stick with the given vector in the CVSS field. But in my "exploitation_conditions" I'll mention the realistic scenario: attacker hosts malicious server, client retrieves certificate automatically? Or requires user to connect? The CVSS definition: UI:N means the vulnerability can be exploited without any user interaction. If a user must visit a website, that's usually UI:R. Given that the vector says UI:N, I'll assume the exploitation condition does not require user interaction (perhaps the certificate is fetched by an automatic service). I'll keep UI:N in my assessed vector if I keep the given one. However, the instruction says "Your OWN independent CVSS 3.1 base-metric vector for THIS vulnerability, grounded in the description and exploitation conditions — NOT a copy of any score in the input." So I need to assess it. The description: "malicious user to create a certificate ... This issue leads to the exposure of confidential information when GnuTLS verifies certificates from certain websites when the certificate (SCT) is not checked correctly." The scenario: a client verifies a certificate from a website, i.e., the user's client checks the certificate of a website they are connecting to. That does imply user interaction: the user must navigate to the malicious site. So UI:R might be appropriate. But then the attacker controls the server. So I'd assess AV:N (remote server), AC:L (just need to present the certificate), PR:N (no auth to the vulnerable component), UI:R (user must initiate connection), S:U (scope unchanged - memory read in same process), C:L (read sensitive data from memory), I:N, A:N. That would give a CVSS base score around 4.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:N). But the given vector says UI:N. I'll use my assessment. I'll decide: Is it really no user interaction? Possibly if the client is a server that fetches and verifies certificates automatically, like a reverse proxy or a service. The description says "when GnuTLS verifies certificates from certain websites" which could be any application using GnuTLS to verify. That could be automated, like a web crawler. So UI:N might be plausible. Since it's ambiguous, I'll lean on the description: "from certain websites" implies client connecting, so likely user initiates. But I'll adopt UI:N as per the NVD analysis, but I must produce my own assessment. I need to be consistent with the "exploitation_conditions": a malicious server with a crafted certificate is accessible to the vulnerable client. If the client automatically connects (e.g., a service monitoring certificates), then UI:N. I'll state that exploitation requires the vulnerable application to connect to an attacker-controlled server. That does not necessarily require user interaction; it could be automated. So I'll keep UI:N. I'll set PR:N, UI:N. So vector: AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N. That's a 5.3 as per given. I'll just use that but note it's based on the scenario where no user interaction is needed. I'll justify: "Attacker serves a malicious TLS certificate, no user interaction needed when a client automatically verifies it." For CVSS 4.0, I'll map: AV:N, AC:L, AT:N (no attack requirements defined, but there is a specific condition: the server presents a malformed SCT, which the attacker does, so AT:N), PR:N, UI:N, VC:L (confidentiality impact low), VI:N, VA:N, SC:N, SI:N, SA:N. So CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N. Score would be 6.9 high? Actually CVSS 4.0 base score for VC:L only is 5.3 as well. I'll provide the vector.

Now exploit scenario: attacker creates a malicious server with a crafted certificate containing a malformed SCT extension, and when a vulnerable GnuTLS client connects, the heap buffer overread leaks memory contents to the attacker. But the attacker doesn't necessarily retrieve the leaked data directly; the description says "leads to the exposure of confidential information" meaning the client's memory is leaked, possibly to the attacker via some side channel? Or the sensitive data from the certificate? Wait: "malicious user create a certificate ... that contains sensitive data. This issue leads to the exposure of confidential information when GnuTLS verifies certificates ... when the certificate (SCT) is not checked correctly." The wording is confusing: the certificate contains sensitive data, and the overread leads to exposure of that sensitive data? Or the overread causes the GnuTLS process to leak its own memory contents containing sensitive data? I think the latter: The malformed SCT causes a heap-buffer-overread, reading memory beyond the buffer, which might contain sensitive data from the process memory (e.g., keys, other data). So an attacker can craft a certificate that triggers the overread and the client's process leaks information. The attacker might not directly see it unless they can observe the process's output (like logs, error messages). But the description says "exposure of confidential information", likely meaning that the sensitive data is read by the library and could be returned to the attacker (e.g., included in the certificate validation failure message, or accessible via other means). Usually, heap-buffer-overread could cause information disclosure in error messages or network responses. So the attacker might observe the leaked data. I'll craft the exploit scenario accordingly. Conditions: GnuTLS must be used for certificate verification, and the client must connect to a server presenting a malicious certificate. No special configuration beyond using GnuTLS for TLS.

Attack chain: Connection initiation from client to attacker's server → Server presents malicious X.509 certificate with malformed SCT extension → GnuTLS parses the extension, triggering heap buffer overread → Confidential data from memory is exposed to attacker (e.g., in error handling or response). So steps: 1. Attacker hosts malicious TLS service → 2. Victim (GnuTLS client) initiates TLS handshake → 3. Attacker sends crafted certificate with malformed SCT → 4. GnuTLS parses SCT, reads beyond buffer, exposing memory → 5. Attacker obtains leaked sensitive data. As kill chain: Delivery (malicious certificate), Exploit (overread), Information disclosure.

Confidence notes: NVD assigned CWE-295 but root cause appears to be heap-buffer-overread (CWE-125/126); CWE discrepancy might reflect the missing validation of SCT leading to buffer overread. Patch available from vendor (Red Hat, Ubuntu, Debian, SUSE). Fix versions confirmed via RHSA and USN. No KEV or public exploit known.

Prevalence: GnuTLS is a popular TLS library, but not as ubiquitous as OpenSSL. It's used in many Linux distributions, Red Hat products, and software like wget, curl, etc. So I'd say 'medium' — widely deployed in enterprise Linux but not dominant. But the CPE includes openshift, enterprise linux, etc., so fairly common. I'll go with 'medium'. Basis: "TLS library used in many Linux distributions and enterprise software."

Now, ensure all fields are plain text strings, no arrays. All strings must be within JSON. I'll produce the final JSON.

Start filling fields:

product_name: "GnuTLS" (since that's the specific product with the vulnerability).

summary: "Heap-buffer-overread in GnuTLS during processing of Certificate Transparency SCT extension exposes sensitive data from client memory when verifying TLS server certificates. Attackers who can present a malicious certificate to a vulnerable GnuTLS client (e.g., via a malicious website or MITM) can read confidential information. No active exploitation or public proof-of-concept has been reported at this time, and vendor patches are available."

technical_context: "GnuTLS is a widely-used library implementing TLS/SSL, X.509 certificate parsing, and related protocols. The vulnerability lies in handling of the Signed Certificate Timestamp (SCT) extension (OID 1.3.6.1.4.1.11129.2.4.2), which is part of Certificate Transparency. The root cause is a heap-buffer-overread when parsing a malformed SCT, leading to reading beyond allocated memory. CWE-295 (Improper Certificate Validation) indicates that the lack of proper validation of the SCT input contributes to the overflow. Affected are all GnuTLS versions, as well as Red Hat Enterprise Linux (6 through 10), Red Hat OpenShift Container Platform 4.0, and other Linux distributions such as Ubuntu and Debian."

risk_assessment: "The CVSS 3.1 base score is 5.3 (Medium), with