Openshift Container Platform

Stack exhaustion in libdm's LVM metadata configuration parser allows any LVM command processing attacker-crafted block device metadata to crash, resulting in denial of service on affected Linux systems. The flaw is exploitable in shared storage, SAN, or virtualization environments where an adversary can supply a maliciously structured block device to a target system running LVM2. No public exploit code has been identified at time of analysis, and the vulnerability is absent from CISA KEV; however, the provided CVSS vector is materially inconsistent with the described DoS impact and warrants independent verification.

OpenShift Container Platform exposes a resource exhaustion path where low-privileged authenticated users with pod creation rights can trigger cluster-wide API server degradation by exploiting two quota enforcement gaps: completed pods with restartPolicy:Never are excluded from ResourceQuota pod limits, and Kubernetes events are not quota-scoped. By repeatedly creating such short-lived pods, an attacker causes Kubernetes events to accumulate unboundedly in etcd, degrading API server performance across the entire cluster - a scope change (CVSS S:C) that extends impact well beyond the attacker's own namespace. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

WORM protection bypass in Samba's vfs_worm VFS module allows authenticated share users to defeat data retention controls by renaming a newly created file over an existing WORM-protected file. Affected users are those operating Samba deployments that have explicitly enabled the vfs_worm module for write-once, read-many data protection - such as compliance, archival, or audit log shares. An attacker with low-privilege write access can silently overwrite files that should be immutable post-grace-period, with high integrity impact (CVSS I:H). No public exploit or CISA KEV listing is identified at time of analysis.

Access control bypass in Samba allows authenticated SMB users who hold write permissions on the underlying filesystem to create or delete NTFS-style reparse point metadata on shares configured with 'read only = yes', defeating the read-only intent of the export. Because the necessary access checks are missing at the SMB layer, an attacker can change how files behave when accessed over SMB - for example, converting a regular file into a symbolic link or another reparse-point type - yielding an integrity and availability impact (CVSS 7.1). There is no public exploit identified at time of analysis, and CISA's SSVC framework rates exploitation as 'none', non-automatable, with partial technical impact.

Trust-store poisoning in Samba's certificate auto-enrollment lets an adjacent-network attacker install an attacker-controlled CA certificate when auto-enrollment is enabled. Because Samba retrieves the CA certificate over plaintext HTTP and adds it to the local trust store without verifying authenticity, a man-in-the-middle can have a rogue CA trusted system-wide, enabling interception or spoofing of otherwise trusted TLS communications. The issue carries CVSS 8.0 with high confidentiality and integrity impact and a changed scope; EPSS is 0.00% and no public exploit identified at time of analysis.

Heap-based buffer overflow in libsolv's repo_add_solv() function enables a remote unauthenticated attacker to crash the parsing process by delivering a specially crafted .solv repository metadata file containing negative values in the maxsize or allsize header fields. The malformed values bypass allocation sizing logic, producing an undersized heap buffer that is subsequently written past its bounds, yielding a denial of service. No public exploit identified at time of analysis; however, an upstream fix has been submitted via openSUSE/libsolv GitHub PR #617, and Red Hat has acknowledged the issue via a dedicated security advisory.

Stack-based buffer overflow in libsolv's Debian metadata parser allows remote, unauthenticated attackers to cause a denial of service by serving maliciously crafted Debian repository metadata containing SHA384 or SHA512 checksum tags. The root cause, confirmed by the GitHub PR #616 diff, is a statically allocated 65-byte stack buffer in `ext/repo_deb.c` sized only for SHA256 digests, which is overflowed by the larger SHA384 (96 hex chars) and SHA512 (128 hex chars) values. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis; an upstream fix is available as an open pull request.

Denial of service in GnuTLS affects the Datagram Transport Layer Security (DTLS) packet reordering logic, where the comparator function fails to correctly handle packets with duplicate sequence numbers. Remote unauthenticated attackers can send specially crafted DTLS packet sequences to trigger unstable ordering or undefined behavior, causing service disruption. No public exploit identified at time of analysis, and the issue is rated CVSS 7.5 (High) for availability impact only.

Authentication bypass in GnuTLS affects servers that enable the RSA-PSK key exchange, where the PSK identity comparison treats a username containing an embedded NUL byte as equal to a legitimate truncated username. Remote attackers can send a crafted username to circumvent pre-shared-key authentication and gain unauthorized access. There is no public exploit identified at time of analysis, the EPSS probability is low (0.15%), and CISA SSVC scores exploitation as none - indicating high theoretical severity but no observed real-world abuse.

Polkit's polkit-agent-helper-1 setuid binary fails to bound input length on stdin, allowing local authenticated users to trigger out-of-memory conditions and deny system availability. An attacker with local login privileges can supply excessively long input to exhaust memory resources, causing a system-wide denial of service. No public exploit code or active exploitation has been confirmed at the time of analysis.

Libarchive fails to properly validate the pz_log2_bs field in ISO9660 Rock Ridge extensions during zisofs decompression, allowing remote attackers to supply a crafted ISO file that triggers undefined behavior and causes denial-of-service through incorrect memory allocation and application crashes. The vulnerability requires user interaction (ISO file opening) but no authentication, affects libarchive across multiple distributions, and carries a moderate EPSS score (0.11%, 30th percentile) suggesting low current exploitation probability despite the moderate CVSS severity.

A vulnerability was recently discovered in the rpc.mountd daemon in the nfs-utils package for Linux, that allows a NFSv3 client to escalate the privileges assigned to it in the /etc/exports file at mount time. [CVSS 6.5 MEDIUM]

A flaw was found in the libxml2 library. This uncontrolled resource consumption vulnerability occurs when processing XML catalogs that contain repeated <nextCatalog> elements pointing to the same downstream catalog. [CVSS 2.9 LOW]

libxml2's xmlCatalogXMLResolveURI function is vulnerable to uncontrolled recursion when processing self-referencing delegate URI entries in XML catalogs, allowing remote attackers to trigger stack exhaustion and crash applications. This configuration-dependent denial of service requires specially crafted XML input but no authentication, affecting any application using the vulnerable library to parse untrusted catalogs. No patch is currently available.

A flaw was identified in the RelaxNG parser of libxml2 related to how external schema inclusions are handled. The parser does not enforce a limit on inclusion depth when resolving nested <include> directives. [CVSS 3.7 LOW]

Heap-based buffer overflow in GLib's g_escape_uri_string() function allows local attackers to achieve high-integrity and high-availability impacts through integer overflow in escaped string length calculation. The vulnerability affects Red Hat Enterprise Linux 9.0 and 10.0 across multiple architectures (x86_64, ARM64, IBM Z, PowerPC). Vendor patches are available via multiple RHSA advisories. Publicly available exploit code exists, but EPSS score remains extremely low (0.01%, 1st percentile), suggesting minimal real-world exploitation activity despite the availability of technical details.

DNS resolve confusion in netavark, the Rust-based network stack for Podman containers, causes container name lookups to be forwarded to unexpected external DNS servers due to a regression that removed the dns.podman search domain. Affected deployments on Red Hat Enterprise Linux 8/9/10 and OpenShift Container Platform 4.0 running netavark < 1.15.1 are subject to misdirected container DNS resolution when host resolv.conf search domains contain a record matching a running container's hostname. The impact is limited to information disclosure (CVSS 3.7, Low), with no confirmed active exploitation and no public exploit identified at time of analysis.

A flaw was found in polkit. When processing an XML policy with 32 or more nested elements in depth, an out-of-bounds write can be triggered. This issue can lead to a crash or other unexpected behavior, and arbitrary code execution is not discarded. To exploit this flaw, a high-privilege account is needed as it's required to place the malicious policy file properly.

CVE-2025-7424 is a type confusion vulnerability in the libxslt library where the psvi (Post-Schema-Validation Infoset) memory field is reused for both stylesheet and input document processing, enabling memory corruption during XML transformations. This affects any application using vulnerable libxslt versions to process untrusted XML stylesheets or documents, allowing unauthenticated remote attackers to trigger denial of service or memory corruption without requiring user interaction. The vulnerability has a high CVSS score (7.5) with high availability impact, though real-world exploitation probability and active KEV status require confirmation from official sources.

Denial-of-service via heap buffer overflow in GnuTLS certtool utility could crash the system. When certtool parses certain settings from a crafted template file, an off-by-one error leads to an out-of-bounds NULL write, corrupting memory. Affected products include GnuTLS on Red Hat Enterprise Linux, OpenShift Container Platform, Ubuntu, and Debian; vendor patches are available. No active exploitation or public proof-of-concept is known, and EPSS score is very low (0.05%).

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

Memory corruption and denial of service in GnuTLS arises from a double-free (CWE-415) in the code that exports X.509 Subject Alternative Name entries containing an otherName field. When the type-id OID inside such an entry is invalid or malformed, GnuTLS calls asn1_delete_structure() on an ASN.1 node it does not own, so the same structure is freed again by the calling function, corrupting allocator state. The flaw is reachable through public GnuTLS APIs - meaning any application that parses or re-exports an attacker-supplied certificate is exposed - and there is no public exploit identified at time of analysis (EPSS 0.04%, 12th percentile; not in CISA KEV).

A security vulnerability in A flaw (CVSS 6.5). Remediation should follow standard vulnerability management procedures.

Cryptographic key derivation failure in libssh versions prior to 0.11.2 (when built against OpenSSL older than 3.0) can cause SSH sessions to proceed with uninitialized key material, allowing remote attackers to undermine session confidentiality and integrity. The flaw stems from inverted return-value semantics between OpenSSL and libssh in ssh_kdf(), so a silent KDF failure is treated as success. No public exploit identified at time of analysis and EPSS risk is low (0.07%), but the issue is widely shipped across Red Hat, Ubuntu, Debian and SUSE distributions and has vendor patches available.

CVE-2025-5318 is an out-of-bounds read vulnerability in libssh versions before 0.11.2 caused by an incorrect comparison check in the sftp_handle function that allows authenticated remote attackers to access memory beyond the valid handle list and retrieve invalid pointers for further processing. This vulnerability enables exposure of sensitive information or denial of service, with a CVSS score of 8.1 indicating high severity. The vulnerability requires authentication and network access but has high confidentiality and availability impact.

A flaw was found in the interactive shell of the xmllint command-line tool, used for parsing XML files.

Stack-based buffer overflow in libxml2's xmlBuildQName function allows remote unauthenticated attackers to crash affected systems via crafted XML input. The vulnerability affects libxml2 directly and downstream Red Hat products including OpenShift Container Platform 4.12-4.19, RHEL 7-10, and JBoss Core Services. With CVSS 7.5 (AV:N/AC:L/PR:N/UI:N), EPSS 0.75% (73rd percentile), and publicly available exploit code, this represents a moderate real-world risk focused on availability disruption rather than code execution or data compromise.

Out-of-bounds read in the libarchive library leads to memory corruption or denial of service when a malicious archive stream is piped into bsdtar. The vulnerability affects libarchive versions prior to 3.8.0 and all downstream consumers including Red Hat Enterprise Linux, Ubuntu, Debian, and OpenShift Container Platform. A local attacker must trick a user into piping crafted data into bsdtar, resulting in potential information disclosure or a crash; no active exploitation has been observed and EPSS probability is very low (0.04%).

An off-by-one miscalculation in libarchive's handling of file name prefixes and suffixes leads to a 1-byte write overflow. This affects libarchive versions prior to 3.8.0 and can cause memory corruption, crashes, or potentially be leveraged for further exploitation. No public exploit or active exploitation has been identified, and the EPSS score is low (0.04%).

Integer overflow in libarchive's WARC file handler can cause denial-of-service or potential memory corruption when processing a crafted WARC archive with a content-length exceeding INT64_MAX - 4. Versions prior to 3.8.0 are affected, including those bundled in Red Hat Enterprise Linux, OpenShift, and other distributions. Exploitation likelihood is low (EPSS 0.04%), no active exploitation is known, and the vulnerability requires local user interaction.

A vulnerability has been identified in the libarchive library. This flaw can lead to a heap buffer over-read due to the size of a filter block potentially exceeding the Lempel-Ziv-Storer-Schieber (LZSS) window. This means the library may attempt to read beyond the allocated memory buffer, which can result in unpredictable program behavior, crashes (denial of service), or the disclosure of sensitive information from adjacent memory regions.

CVE-2025-5914 is an integer overflow vulnerability in libarchive's archive_read_format_rar_seek_data() function that leads to a double-free memory corruption condition. This affects all users of libarchive who process untrusted RAR archive files, potentially allowing arbitrary code execution or denial-of-service with user interaction (opening a malicious RAR file). While no KEV listing or confirmed public exploits are currently documented, the high CVSS score (7.8) and memory safety nature of the vulnerability indicate significant real-world risk if weaponized.

A vulnerability was found in systemd-coredump. Rated medium severity (CVSS 4.7). Public exploit code available and no vendor patch available.

A flaw was found in grub2. Rated high severity (CVSS 7.8), this vulnerability is low attack complexity. No vendor patch available.

A flaw was found in the HFS filesystem. Rated high severity (CVSS 7.8), this vulnerability is low attack complexity. No vendor patch available.

A stack overflow flaw was found when reading a BFS file system. Rated medium severity (CVSS 4.1). No vendor patch available.

A vulnerability was found in OpenSSH when the VerifyHostKeyDNS option is enabled. Rated medium severity (CVSS 6.8), this vulnerability is remotely exploitable, no authentication required. Epss exploitation probability 60.0%.

Arbitrary file write outside the intended destination in rsync's client-side `--safe-links` handling allows a malicious or compromised rsync server to bypass the symlink safety check via a path-traversal flaw (CWE-22). The client fails to recursively verify whether a symbolic-link target supplied by the server itself contains a nested symlink, so a controlled server can place files anywhere the rsync process can write. A detailed advisory was published by Google's security-research team (GHSA-p5pg-x43v-mvqj) as part of the January 2025 rsync vulnerability cluster, but the issue is not in CISA KEV and no public exploit identified at time of analysis; EPSS is moderate at 2.89% (86th percentile).

A flaw was found in rsync. Rated medium severity (CVSS 6.1), this vulnerability is remotely exploitable, no authentication required. Public exploit code available and no vendor patch available.

A flaw was found in rsync which could be triggered when rsync compares file checksums. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available and EPSS exploitation probability 19.1%.

A vulnerability was found in GraphQL due to improper access controls on the GraphQL introspection query. Rated medium severity (CVSS 5.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. This Exposure of Sensitive Information vulnerability could allow attackers to access sensitive data that should not be disclosed.

A denial of service (DoS) vulnerability was found in OpenShift. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

A misconfiguration flaw was found in Keycloak. Rated medium severity (CVSS 6.1), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A vulnerability was found in Keycloak. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A flaw was found in Podman. Rated high severity (CVSS 7.7), this vulnerability is remotely exploitable. No vendor patch available.

A flaw was found in the Openshift console. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

Remote code execution in OpenSSH's sshd server (regression of CVE-2006-5051) allows unauthenticated remote attackers to exploit a signal handler race condition by failing to authenticate within the LoginGraceTime window, potentially yielding root-level code execution on glibc-based Linux systems. The flaw - widely known as 'regreSSHion' - affects numerous distributions and vendor appliances including Ubuntu 23.10/24.04, AlmaLinux 9, SonicWall SMA firmware, Arista EOS, NetApp ONTAP, and others. Publicly available exploit code exists and EPSS scores it at 48.06% (98th percentile), reflecting very high exploitation likelihood, though it is not currently listed in CISA KEV.

A flaw was found in cri-o. Rated high severity (CVSS 8.1), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

A flaw was found in OpenShift's Telemeter. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity.

A flaw was found in Keycloak, where it does not properly validate URLs included in a redirect. Rated high severity (CVSS 8.1), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A flaw was discovered in the mholt/archiver package. Rated high severity (CVSS 7.8), this vulnerability is no authentication required, low attack complexity. No vendor patch available.

A flaw was found in the kubevirt-csi component of OpenShift Virtualization's Hosted Control Plane (HCP). Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

A vulnerability was found in Undertow. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A flaw was found in CRI-O that involves an experimental annotation leading to a container being unconfined. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. This Allocation of Resources Without Limits vulnerability could allow attackers to exhaust system resources through uncontrolled allocation.

Keycloak's device authorization grant does not correctly validate the device code and client ID. Rated high severity (CVSS 8.1), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

The SSH transport protocol with certain OpenSSH extensions, found in OpenSSH before 9.6 and other products, allows remote attackers to bypass integrity checks such that some packets are omitted (from. Rated medium severity (CVSS 5.9), this vulnerability is remotely exploitable, no authentication required. Public exploit code available and EPSS exploitation probability 53.6%.

A flaw was found in Keycloak that prevents certain schemes in redirects, but permits them if a wildcard is appended to the token. Rated medium severity (CVSS 5.4), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available and no vendor patch available.

An unconstrained memory consumption vulnerability was discovered in Keycloak. Rated high severity (CVSS 7.7), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available and no vendor patch available.

A privilege escalation flaw was found in the node restriction admission plugin of the kubernetes api server of OpenShift. Rated high severity (CVSS 7.2), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

Denial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resources by rapidly opening and immediately canceling (RST_STREAM) large numbers of streams over a single connection, a technique dubbed the 'Rapid Reset' attack. The flaw is confirmed actively exploited (CISA KEV) following large-scale weaponization observed August through October 2023, with publicly available exploit code and an EPSS score of 94.45% placing it in the 100th percentile for likelihood of exploitation. Virtually every major HTTP/2 stack - including nghttp2, Netty, Envoy, and Eclipse Jetty - is affected.

A flaw was found in Open vSwitch that allows ICMPv6 Neighbor Advertisement packets between virtual machines to bypass OpenFlow rules. Rated medium severity (CVSS 5.5), this vulnerability is low attack complexity.

A flaw was found in Open Virtual Network where the service monitor MAC does not properly rate limit. Rated medium severity (CVSS 5.3), this vulnerability is remotely exploitable, no authentication required, low attack complexity. This Uncontrolled Resource Consumption vulnerability could allow attackers to cause denial of service by exhausting system resources.

A flaw was found in Keycloak. Rated high severity (CVSS 7.1), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

A flaw was found in Red Hat's AMQ Broker, which stores certain passwords in a secret security-properties-prop-module, defined in ActivemqArtemisSecurity CR; however, they are shown in plaintext in. Rated medium severity (CVSS 5.5), this vulnerability is low attack complexity. No vendor patch available.

A flaw was found in Red Hat AMQ Broker Operator, where it displayed a password defined in ActiveMQArtemisAddress CR, shown in plain text in the Operator Log. Rated medium severity (CVSS 5.5), this vulnerability is low attack complexity. No vendor patch available.

A flaw was found in undertow. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

An authentication bypass vulnerability was discovered in kube-apiserver. Rated high severity (CVSS 8.0), this vulnerability is remotely exploitable. No vendor patch available.

A flaw was found in Quarkus where HTTP security policies are not sanitizing certain character permutations correctly when accepting requests, resulting in incorrect evaluation of permissions. Rated high severity (CVSS 8.1), this vulnerability is remotely exploitable, no authentication required. Public exploit code available and no vendor patch available.

A flaw was found in undertow. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A flaw was found in Keycloaks OpenID Connect user authentication, which may incorrectly authenticate requests. Rated medium severity (CVSS 5.0), this vulnerability is remotely exploitable. No vendor patch available.

A compliance problem was found in the Red Hat OpenShift Container Platform. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. No vendor patch available.

A flaw was found in the `/v2/_catalog` endpoint in distribution/distribution, which accepts a parameter to control the maximum number of records returned (query string: `n`). Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

A flaw was found in openvswitch (OVS). Rated high severity (CVSS 8.2), this vulnerability is remotely exploitable, no authentication required, low attack complexity.

An uncontrolled resource consumption vulnerability was discovered in HAProxy which could crash the service. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

runc through 1.1.4 has Incorrect Access Control leading to Escalation of Privileges, related to libcontainer/rootfs_linux.go. Rated high severity (CVSS 7.0). Public exploit code available and no vendor patch available.

An incorrect handling of the supplementary groups in the Buildah container engine might lead to the sensitive information disclosure or possible data modification if an attacker has direct access to. Rated high severity (CVSS 7.1), this vulnerability is low attack complexity. Public exploit code available and no vendor patch available.

An incorrect handling of the supplementary groups in the Podman container engine might lead to the sensitive information disclosure or possible data modification if an attacker has direct access to. Rated high severity (CVSS 7.1), this vulnerability is low attack complexity. Public exploit code available and no vendor patch available.

In OpenShift Container Platform, a user with permissions to create or modify Routes can craft a payload that inserts a malformed entry into one of the cluster router's HAProxy configuration files. Rated medium severity (CVSS 6.3), this vulnerability is remotely exploitable, low attack complexity. This Uncontrolled Resource Consumption vulnerability could allow attackers to cause denial of service by exhausting system resources.

An Improper Certificate Validation attack was found in Openshift. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. No vendor patch available.

A permissive list of allowed inputs flaw was found in DPDK. Rated high severity (CVSS 8.6), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available and no vendor patch available.

A flaw was found in python-oslo-utils. Rated medium severity (CVSS 4.9), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available.

A flaw was found in dpdk. Rated medium severity (CVSS 6.5), this vulnerability is low attack complexity. This Uncontrolled Resource Consumption vulnerability could allow attackers to cause denial of service by exhausting system resources.

A vulnerability was found in CRI-O that causes memory or disk space exhaustion on the node for anyone with access to the Kube API. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available.

A vulnerability was found in Ignition where ignition configs are accessible from unprivileged containers in VMs running on VMware products. Rated medium severity (CVSS 6.5), this vulnerability is remotely exploitable, low attack complexity. This Incorrect Authorization vulnerability could allow attackers to bypass authorization checks to access restricted resources.

A privilege escalation flaw was found in Podman. Rated high severity (CVSS 8.8), this vulnerability is remotely exploitable, no authentication required, low attack complexity. Public exploit code available and no vendor patch available.

A flaw was found in cri-o, where containers were incorrectly started with non-empty default permissions. Rated medium severity (CVSS 5.3), this vulnerability is low attack complexity. No vendor patch available.

A flaw was found in crun where containers were incorrectly started with non-empty default permissions. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable. This Incorrect Default Permissions vulnerability could allow attackers to access resources due to overly permissive default settings.

A flaw was found in Podman, where containers were started incorrectly with non-empty default permissions. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable. This Incorrect Default Permissions vulnerability could allow attackers to access resources due to overly permissive default settings.

A flaw was found in the way HAProxy processed HTTP responses containing the "Set-Cookie2" header. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentication required, low attack complexity.

JMSAppender in Log4j 1.2 is vulnerable to deserialization of untrusted data when the attacker has write access to the Log4j configuration. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable. Epss exploitation probability 72.2% and no vendor patch available.