Suse

Heap buffer overflow in FFmpeg's TDSC screen-capture codec decoder exposes Red Hat Enterprise Linux AI 3 and OpenShift AI deployments to denial of service or potential arbitrary code execution. The tdsc_load_cursor() function performs erroneous stride-based pointer arithmetic in two locations when rendering cursor data from crafted TDSC video, writing past a heap-allocated buffer boundary. No public exploit or active exploitation has been confirmed at time of analysis, and the upstream fix is available as FFmpeg commit 242ff799c.

Heap buffer overflow in GNU C Library (glibc) 2.45 and earlier triggers when an effectively empty string is passed via the ,ccs= mode-argument extension to fopen(), enabling limited heap memory corruption in applications that expose this code path to externally controlled input. The vendor-assigned CVSS 3.1 score of 4.9 (Medium) with a local attack vector and high complexity accurately reflects the narrow preconditions required. No public exploit code has been identified at time of analysis, and the glibc advisory itself explicitly notes this vulnerable usage pattern is absent from mainstream GNU/Linux applications.

Out-of-bounds stack array access in the tdelete function affects the GNU C Library (glibc) as reported by Ubuntu. The tdelete function, part of POSIX binary tree search routines (tsearch family), contains a memory safety flaw where a stack-allocated array can be accessed beyond its bounds during tree node deletion. Exploitation depends on an application passing attacker-influenced input to tdelete, and no public exploit code or CISA KEV listing has been identified at time of analysis.

CVE-2026-19499 has been reported by Ubuntu but contains no available description, CVSS score, vector, or CWE data at time of analysis. The vulnerability's nature, affected component, and impact are entirely unknown from the provided intelligence. No meaningful characterization of this CVE is possible without additional data from the vendor advisory or NVD.

Broken access control in Grafana OSS and Enterprise allows an organization administrator to delete dashboard snapshots owned by other organizations on the same multi-tenant instance, and to recover a snapshot's secret delete key by supplying only its public share key. The flaw crosses organizational trust boundaries within a shared Grafana deployment, enabling a malicious or compromised org-admin to both exfiltrate snapshot delete credentials and destroy data belonging to tenants they should have no access to. No public exploit code or CISA KEV listing exists at time of analysis, but the low attack complexity and authenticated-network accessibility make this straightforward to exploit for any actor who holds org-admin credentials.

Denial-of-service attack vectors in OpenRGB's unauthenticated TCP network protocol server (listening on 0.0.0.0:6742) allow any network-reachable attacker to crash or resource-exhaust the OpenRGB daemon without authentication. CVE-2026-18794 covers multiple DoS paths rooted in absent input-size validation - the server performs uncapped memory allocations from attacker-controlled length fields and passes raw network data to string constructors without null-termination checks. A Python reproducer script was published alongside coordinated disclosure on 2026-08-25, lowering the exploitation bar significantly. No CISA KEV listing; upstream 1.0rc3-hotfix addresses the worst aspects of the disclosed flaw set.

Denial of service in GNU wget's FTP OPIE/S-KEY authentication handler allows a malicious or intercepted FTP server to cause wget to perform approximately 2.1 billion MD5 computations by supplying a crafted sequence number near INT_MAX in the OPIE challenge line. All versions of GNU wget with OPIE/S-KEY FTP authentication support are affected per CPE cpe:2.3:a:gnu:wget:*:*:*:*:*:*:*:*. The --timeout option provides no mitigation because it governs network I/O exclusively, not CPU-bound computation. No public exploit identified at time of analysis; a fix is confirmed via upstream GitLab commit.

Remote unauthenticated denial of service in OpenSSL's QUIC server stack (versions 3.5.x before 3.5.8, 3.6.x before 3.6.4, and 4.0.x before 4.0.2) allows an attacker to crash the QUIC server process by sending a single malformed INITIAL packet with a destination connection ID shorter than 8 bytes. The crafted packet triggers a double-free of the QUIC record layer RX (QRX) object, causing heap corruption and process termination. No public exploit has been identified; remote code execution is explicitly assessed as highly improbable by the vendor, and no public exploit or active exploitation has been confirmed.

NULL pointer dereference in OpenSSL's RFC7250 Raw Public Key (RPK) TLS extension handling crashes any server or client configured in key-only RPK mode when a remote peer sends the typically omitted `signature_algorithms_cert` extension. Affected versions span OpenSSL 3.4.x through 4.0.x; impact is strictly limited to a process-aborting Denial of Service - no data disclosure or code execution is possible. No public exploit exists and CISA SSVC rates active exploitation as none, but the attack is automatable against any reachable endpoint in this non-default configuration.

Denial of service in OpenEXR 3.4.0 through 3.4.12 allows any application calling exr_start_read() on untrusted input to be unconditionally aborted by a crafted HTJ2K-compressed EXR file containing a QCD marker with lower five bits set to zero. The flaw chains two weaknesses: OpenJPH's vendored assertion-based validation calls abort() instead of returning a recoverable error, and OpenEXR's error handling wraps only its internal HT header parser, leaving downstream codestream construction calls entirely unprotected. No public exploit or active exploitation (CISA KEV) has been identified, but the trivial triggering condition and prevalence of OpenEXR in automated rendering pipelines make this a meaningful denial-of-service risk for media production infrastructure.

CRI-O's container-creation code path crashes the daemon with an unrecovered Go runtime panic when processing an OCI image whose config.Env contains a malformed entry lacking an '=' character, under the specific condition that the CreateContainer request supplies a nil CRI Envs field. The crash terminates the crio daemon process, disrupting all container workloads on the affected node until the service is manually restarted - a node-wide denial of service. Affecting Red Hat OpenShift Container Platform 4, this requires high privileges (PR:H) to exploit; no public exploit code or CISA KEV listing has been identified at time of analysis.

Incomplete remediation of CVE-2025-9615 in NetworkManager exposes WPA-Enterprise (802.1X) connections to server certificate validation bypass on Red Hat Enterprise Linux 6 through 10, Red Hat Hardened Images, and Red Hat OpenShift Container Platform 4. An unprivileged local user can set the 802-1x.ca-path or phase2-ca-path properties of a private connection profile to an attacker-controlled directory because the private_user restriction was never applied to these directory-valued fields. When the victim system subsequently connects to a wireless network, the bypassed CA validation enables credential theft via a rogue access point presenting a certificate signed by the attacker-supplied CA. No public exploit code has been identified and this vulnerability is not listed in CISA KEV at time of analysis; however, SSVC rates the attack as automatable with total technical impact once local access exists.

Stored cross-site scripting in Grafana OSS allows an authenticated Editor-level attacker to hijack the browser session of any user who clicks a crafted alert link, executing attacker-controlled JavaScript in the Grafana origin with the victim's permissions. The attack exploits unsanitized rendering of the external Alertmanager alert generatorURL field as an href in the Alert Details 'See source' LinkButton, combined with a bypass of Grafana's click-interceptor heuristic by embedding :// inside a JavaScript comment within a javascript: URI. No public exploit code or CISA KEV listing has been identified at time of analysis, but the bypass technique is fully disclosed in the CVE description, lowering the bar for weaponization.

Stored cross-site scripting in Hugo's fenced-code-block renderer (versions 0.93.0 through 0.165.0) allows a low-privileged content author to inject arbitrary JavaScript into statically generated HTML pages by embedding crafted attribute values in a code-fence info string. The vulnerability arises because Hugo's `markup/internal/attributes/attributes.go` converts attribute values from byte slices to strings during storage, silently bypassing the escaping branch in `RenderAttributes` that only operates on byte slice types - contradicting the function's own documentation. Every visitor who loads an affected page executes the injected script; no public exploit identified at time of analysis, and exploitation has not been confirmed in CISA KEV.

Server-side request forgery in Hugo static site generator (versions 0.91.0 through 0.165.0) allows an attacker who can supply a URL through site content - via front-matter fields or a connected CMS - to silently fetch loopback, RFC 1918, or cloud-metadata endpoints during the build process, embedding the internal response directly into the published static output. The security.http.urls allowlist, Hugo's only guard on resources.GetRemote outbound fetches, evaluates hostname strings without performing DNS resolution, meaning any registered domain whose A record points to a private or metadata IP bypasses the policy entirely, and no dial-time hook in the HTTP client provides a second check. No public exploit code has been identified at time of analysis, but the attack requires only DNS control and content-write access, making it operationally straightforward in CI/CD-integrated deployments.

Privilege escalation in Velociraptor allows any user with the NOTEBOOK_EDIT permission - typically an analyst-level role - to overwrite global artifacts without the elevated permissions normally required for such operations. The `verify()` VQL function, designed only for syntax validation, incorrectly writes submitted artifacts into the shared global repository rather than a temporary local scope, effectively bypassing authorization controls (CWE-862). No public exploit or CISA KEV listing has been identified at time of analysis, but the low privilege bar and network accessibility make this a meaningful internal threat in Velociraptor deployments.

Privilege escalation to PostgreSQL superuser and pod-level command execution in CloudNativePG before 1.28.4 and 1.29.2 lets a low-privileged tenant who holds DATABASE OWNER escape from database-level control to the postgres OS process. Because operator-issued superuser connections did not pin search_path, a tenant could plant overloaded built-in operators in the public schema and hijack instance-manager introspection queries so they run attacker-controlled code as the superuser, then reach OS command execution via COPY ... FROM PROGRAM and the pod's ServiceAccount token. This is CWE-426 (Untrusted Search Path), the same class as PostgreSQL's CVE-2018-1058; no public exploit identified at time of analysis, but the vendor patch and detailed advisory make the mechanism fully documented.

Heap buffer overflow in Capstone's SuperH (SH) architecture floating-point disassembler affects all releases through 6.0.0-Alpha9, allowing a four-byte out-of-bounds write into heap memory when processing crafted SH instructions. The root cause is that opFADD, opFMUL, opFSUB, and related SH FPU decoders in arch/SH/SHDisassembler.c increment op_count as an array index into the fixed-size operands[] array without bounds checking, overflowing the 176-byte sh_info heap allocation. A process that disassembles attacker-controlled SH binary data with the affected mode flags can be crashed; code execution is possible but depends on heap layout. No public exploit has been identified at time of analysis, though a proof-of-concept test case is included in the upstream fix PR. The vendor-released patch is version 6.0.0-Alpha10.

Out-of-bounds read in Capstone's SuperH (SH) architecture disassembler crashes the host process when fed crafted SH2A or SH4A bytecode. Versions 6.0.0-Alpha9 and earlier are affected when the library handle is configured with CS_ARCH_SH plus CS_MODE_SH2A or CS_MODE_SH4A and CS_MODE_SHFPU; the disassembler derives an idx value from a raw 16-bit instruction and dereferences a mode-specific decode[] function-pointer table without a bounds check. The demonstrated impact is limited to process termination - no code execution or information disclosure was shown - and a vendor-released patch is available in 6.0.0-Alpha10.

OS command injection in OTRS Community Edition's PGP encryption module allows authenticated administrators to execute arbitrary operating-system commands by supplying crafted values for the PGP binary path and command options, which are concatenated unsanitized into a shell command invoked during normal ticket operations. Exploitation requires pre-existing administrator-level access to the OTRS admin panel and is triggered automatically once a malicious configuration is saved and a PGP-involving ticket operation occurs. No public exploit has been independently confirmed beyond a researcher disclosure blog, and the vulnerability is not listed in CISA KEV at time of analysis.

Heap buffer overflow in msgpack-c through version 7.0.1 results from an integer overflow in msgpack_unpacker_expand_buffer, where unchecked size_t addition of the requested reservation size and current buffer usage wraps to near-zero on near-SIZE_MAX inputs, causing the allocator to receive a massively undersized target while the function falsely reports success to the caller. Integrations that pass attacker-controlled lengths to the msgpack_unpacker_reserve_buffer API - such as custom length-prefixed streaming transports - can trigger subsequent heap overwrites when the caller writes the full declared length into the undersized buffer. No public exploit code or CISA KEV listing exists at time of analysis; exploitation requires a specific non-default integration pattern not present in msgpack-c's own internal decode paths.

HTTP request smuggling and header injection in libevent's http.c allow remote unauthenticated attackers to desynchronize an upstream proxy from libevent's own parsing, bypassing access controls. Affected are all versions prior to 2.1.13-stable and 2.2.2-alpha, where evhttp_header_is_valid_value accepted obsolete CRLF line folding in header values and evhttp_decode_uri_internal decoded %00 into literal NUL bytes that truncate paths in downstream C string operations. No public exploit identified at time of analysis; the CRLF weakness is patched in 2.1.13/2.2.2-alpha, but the URI NUL-truncation condition is not clearly remediated by the reviewed patches.

Integer overflow in Libevent's event tagging subsystem exposes any application using the evtag API to remote denial of service without authentication. The flaw arises in evtag_unmarshal_header, where a uint32 payload length decoded from attacker-controlled input is implicitly cast to a signed int; values exceeding INT_MAX produce negative or truncated results that flow into allocation sizing in evtag_unmarshal_string, causing a wrapped allocation request and crash. No active exploitation has been confirmed (not in CISA KEV), but the network-accessible, unauthenticated attack surface and a publicly available upstream fix make this a straightforward patching priority for any consumer of the libevent evtag interface.

HTTP request smuggling in the libevent evhttp server (http.c) affects all versions prior to 2.1.13 and the 2.2.x-alpha line prior to 2.2.2-alpha, letting an unauthenticated remote attacker desynchronize request boundaries when libevent sits behind a differently-framing proxy. Because evhttp mishandles duplicate and comma-listed Transfer-Encoding headers and accepts bare-LF chunk terminators, a smuggled second request can bypass proxy-enforced access controls or poison shared caches. No public exploit identified at time of analysis, and this is not listed in CISA KEV; a vendor patch is available.

Use-after-free memory corruption in libevent's evbuffer_add_buffer_reference (buffer.c) allows a caller that can drive a specific empty-buffer state to trigger process crashes or heap corruption in any application linking the library. Affected are libevent stable releases before 2.1.13 and development releases 2.2.0-alpha through 2.2.2-alpha; the root cause is that evbuffer_free_all_chains frees the initial empty chain without nullifying the three outbuf chain-tracking pointers, after which APPEND_CHAIN_MULTICAST dereferences the now-dangling pointer. No public exploit code and no active exploitation (CISA KEV) has been identified at time of analysis; vendor-released patches are available for both stable and alpha branches.

Memory exhaustion in libevent's WebSocket server (ws.c) allows unauthenticated remote clients to crash affected processes by sending an unbounded stream of fragmented WebSocket frames. Affected versions span 2.2.0-alpha-dev through pre-fix 2.2.2-alpha; the evws WebSocket API enforces WS_MAX_RECV_FRAME_SZ per individual frame but applies no cap to the total accumulated message size in evws->incomplete_frames, enabling heap growth without limit. No public exploit has been identified at time of analysis, and the vulnerability is absent from the CISA KEV catalog; however, exploitation is trivially simple for any WebSocket client.

Out-of-bounds read in libevent's tagged RPC decoder crashes any application that decodes attacker-controlled tag data using the evbuffer API, affecting all 2.1.x releases prior to 2.1.13 and all 2.2.x alpha releases prior to 2.2.2-alpha. The flaw in decode_tag_internal causes the byte-iteration loop to walk the full logical buffer length while only a smaller pullup window is physically contiguous, allowing a crafted 6-byte fragmented tag to drive reads past valid memory and abort the process. No active exploitation is confirmed and no public proof-of-concept exists; fixed releases are available on GitHub and should be applied promptly given libevent's broad embedding across network-facing software.

Heap out-of-bounds write in libevent's bufferevent_sock.c allows any local peer connecting to an AF_UNIX evhttp listener to corrupt heap memory, achieving full confidentiality, integrity, and availability impact. Release builds compiled with -DNDEBUG silently remove the EVUTIL_ASSERT length guard, causing memcpy to write a kernel-supplied 110-byte sockaddr_un into the 28-byte conn_address union field and overwriting the adjacent dns_request heap pointer. No public exploit has been identified at time of analysis, but the absence of privilege requirements and low attack complexity make this accessible to any local process with filesystem access to the socket path.

Out-of-bounds read in libexpat through 2.8.3 allows remote unauthenticated attackers to crash any application that parses attacker-controlled XML with external entity resolution enabled. The flaw - introduced as a regression by the CVE-2026-66046 fix - causes dtdCopy() to allocate hash entries with the smaller sizeof(NAMED) instead of sizeof(NAME_AND_DEFAULT_ATTRIBUTE), so storeAtts() subsequently reads the attIndex member past the end of the allocated block when handling external entity parsers created via XML_ExternalEntityParserCreate. No public exploit code or CISA KEV listing is identified at time of analysis; an upstream patch commit is available but a tagged release version has not been confirmed.

Sandbox escape in asteval allows any attacker who can supply expressions to `Interpreter.eval()` to raise `SystemExit`, `KeyboardInterrupt`, `GeneratorExit`, or `BaseException`, bypassing both `run()` and `eval()` exception handlers - which catch only `Exception` - and terminating or disrupting the calling process. All asteval versions through 1.0.6 are affected; version 1.0.9 resolves the issue. No active exploitation has been confirmed (not in CISA KEV), but a working proof-of-concept covering all four variants is included in the public advisory GHSA-89v8-rhwq-hf77, and this is a third distinct sandbox-escape class in asteval following CVE-2025-24359 and GHSA-vp47-9734-prjw.

Remote code execution in Adminer 5.4.2 allows authenticated high-privilege users to execute arbitrary code in the context of the web server by exploiting an incorrect function return value check in the multi_query method (CWE-253). The CVSS base score of 7.2 (High) reflects full confidentiality, integrity, and availability impact once authentication is satisfied. No public exploit code or CISA KEV listing has been identified at time of analysis, placing this in the category of a serious but not yet confirmed actively-exploited vulnerability.

Remote code execution in GIMP 3.2.2 is achievable when a user opens a crafted APNG file, triggering an integer overflow before buffer allocation in the APNG parser (CWE-190). Disclosed by Zero Day Initiative as ZDI-CAN-29401/ZDI-26-462 and tracked as EUVD-2026-63458, the flaw yields full C/I/A compromise within the GIMP process. No active exploitation is confirmed (not listed in CISA KEV), but a fix commit is available on GNOME GitLab; no officially tagged patched release has been independently confirmed at time of analysis.

Remote code execution in GIMP 3.2.2 is achievable via a specially crafted TIF image file that triggers an integer overflow in the application's TIFF parser, causing an undersized heap allocation and subsequent memory corruption. An attacker who convinces a user to open a malicious file or visit an attacker-controlled page that delivers such a file can execute arbitrary code with the privileges of the victim's user account. No public exploit identified at time of analysis, though the ZDI origin (ZDI-26-461, formerly ZDI-CAN-29405) represents a technically verified, researcher-confirmed vulnerability with well-characterized root cause.

Heap-based buffer overflow in GIMP's TIF file parser enables remote code execution when a user opens a crafted TIFF image, affecting GIMP 3.2.2. The flaw stems from missing length validation before copying attacker-controlled data into a heap buffer (CWE-122), granting full code execution in the context of the GIMP process. No public exploit code or active exploitation (CISA KEV) has been identified at time of analysis, but a fix commit is available on the GNOME GitLab repository.

Remote code execution is possible in GIMP 3.2.2 through a maliciously crafted SGI image file, exploiting an integer overflow in the application's SGI file parser. An unauthenticated remote attacker can deliver the file via email or web and, upon the victim opening it, execute arbitrary code within the GIMP process context with the privileges of the logged-in user. No active exploitation has been confirmed (not in CISA KEV), though ZDI's coordinated public disclosure via ZDI-26-459 lowers the barrier to weaponization; an upstream patch commit exists but a formally tagged fixed release has not been independently confirmed.

Remote code execution in GIMP 3.2.2 is achievable by an attacker who can convince a target user to open a specially crafted TIF file, triggering an integer overflow during buffer allocation in the TIFF parser that leads to heap corruption and arbitrary code execution in the context of the current user process. Disclosed by the Zero Day Initiative under ZDI-26-458 (ZDI-CAN-29406), the flaw is rooted in missing validation of user-supplied size data before heap allocation. No public exploit has been identified at time of analysis and the vulnerability does not appear in the CISA KEV catalog; however, an upstream fix commit is available in the GIMP GitLab repository.

Remote code execution via maliciously crafted TIF files affects GIMP 3.2.2, allowing an attacker to execute arbitrary code in the context of the running GIMP process with full user-level privileges. The root cause is a CWE-190 integer overflow in the TIFF file parser where attacker-supplied image metadata bypasses size validation before a heap allocation, enabling memory corruption and code execution. Reported by Zero Day Initiative as ZDI-CAN-29403 and tracked under ENISA EUVD-2026-63453; no public exploit code or CISA KEV listing has been identified at time of analysis.

Stack-based buffer overflow in GIMP 3.2.2's TIF file parser enables remote attackers to execute arbitrary code in the context of the current user process. Exploitation requires the target to open a specially crafted TIF image file, making this a socially-engineered attack delivered via malicious webpage or email attachment. Reported by the Zero Day Initiative (ZDI-26-456/ZDI-CAN-29399), a fix commit has been pushed to the upstream GNOME GitLab repository, though no independently confirmed patched release version is available at time of analysis.

Heap-based buffer overflow in GIMP's TIF file parser (CWE-122) enables remote code execution on affected installations when a user opens a crafted TIFF image. Confirmed affected version is GIMP 3.2.2 per EUVD-2026-63451, with the flaw originating from missing length validation before copying attacker-controlled data to a heap buffer. Discovered and reported by Zero Day Initiative (ZDI-26-455 / ZDI-CAN-29398); no public exploit or CISA KEV listing has been identified at time of analysis, though an upstream patch commit exists on GNOME GitLab.

Remote code execution in GIMP 3.2.2 is triggered when a victim opens a specially crafted PSD file, exploiting an integer overflow in the PSD parser that occurs before buffer allocation. Tracked by Zero Day Initiative as ZDI-CAN-29395 and rated CVSS 7.8, the flaw allows an unauthenticated remote attacker to execute arbitrary code within the GIMP process context after inducing the target to open a malicious file. No public exploit identified at time of analysis, and no active exploitation has been confirmed via CISA KEV.

Remote code execution in GIMP 3.2.2 is possible when a user opens a specially crafted HDR image file, with the underlying flaw residing in the GEGL image processing library that GIMP depends on. The integer overflow in HDR buffer size computation (CWE-190) produces an undersized heap allocation that an attacker can leverage to execute arbitrary code in the context of the victim's GIMP process. No public exploit code has been identified at time of analysis, and CISA KEV listing has not been confirmed; the ZDI advisory (ZDI-26-453) assigns this a High severity rating of CVSS 7.8.

Remote code execution in GStreamer's rtpsbcdepay plugin is achieved when a user processes a crafted RTP stream containing malformed SBC audio payload, triggering a use-after-free that corrupts heap memory and redirects execution to attacker-controlled code within the affected process. The flaw exists in all GStreamer installations where the rtpsbcdepay element is exercised, covering a broad surface area including Linux media players, VoIP clients, and Bluetooth audio gateways. No public exploit has been identified at time of analysis, but coordinated disclosure by ZDI (ZDI-CAN-29787) confirms technical reproduction, and a vendor security advisory (SA-2026-0051) has been published.

Heap-based buffer overflow in GStreamer's PNG file parsing allows remote code execution in the context of the affected process. Affects GStreamer installations where a user can be induced to open or process a maliciously crafted PNG file - via a web page or file download. The flaw stems from missing length validation before copying attacker-controlled data into a heap buffer (CWE-122). No public exploit or CISA KEV listing is identified at time of analysis; however, ZDI disclosed the issue under ZDI-26-466 following coordinated disclosure, and GStreamer has issued security advisory sa-2026-0052.

Stack-based buffer overflow in GStreamer's OGG file parsing component allows remote attackers to execute arbitrary code in the context of the current process. Affected installations of GStreamer fail to validate the length of user-supplied data before copying it to a stack-based buffer during OGG container parsing, enabling full code execution (C:H/I:H/A:H). No public exploit identified at time of analysis and the vulnerability is not listed in CISA KEV, though it was discovered and disclosed by the Zero Day Initiative (ZDI-CAN-29584), which typically indicates a reliable, well-researched finding.

Heap-based buffer overflow in GStreamer's MRF file parser enables remote code execution when a user opens a crafted media file or visits a page that triggers parsing. The root cause is absent length validation before copying attacker-supplied data into a heap buffer (CWE-122), granting full confidentiality, integrity, and availability impact within the target process. Reported by ZDI as ZDI-CAN-29608 and addressed in GStreamer security advisory SA-2026-0050; no public exploit code or CISA KEV listing is confirmed at time of analysis.

Remote code execution via malicious MRF media files affects GStreamer across all versions tracked under CPE cpe:2.3:a:gstreamer:gstreamer:*:*:*:*:*:*:*:*. The MRF file parser fails to validate user-supplied input bounds, allowing a heap out-of-bounds write (CWE-787) that corrupts memory and redirects execution to attacker-controlled code within the victim process. Exploitation requires user interaction - opening a crafted file or visiting a page that triggers GStreamer parsing - and no public exploit or CISA KEV listing has been identified at time of analysis, though ZDI coordinated disclosure (ZDI-CAN-29510) and an upstream vendor advisory (sa-2026-0050) are both present.

Uncontrolled resource consumption in jsoup through version 1.23.2 allows remote unauthenticated attackers to crash JVM-based applications by submitting deeply nested XML with unique namespace declarations per element. The XmlTreeBuilder component copied the full inherited namespace HashMap at every XML start element, producing O(n²) time and memory growth that exhausts heap and triggers an OutOfMemoryError. No public exploit has been identified and the vulnerability is not listed in CISA KEV, but the CVSS 4.0 score of 8.7 reflects zero authentication or complexity barriers - any application that feeds user-supplied XML through jsoup is directly at risk.

STARTTLS response injection in aiosmtplib prior to version 5.1.2 allows an active network attacker to desynchronize SMTP command-response pairs by staging plaintext bytes that survive the TLS transport upgrade into the encrypted session. The root cause is that SMTPProtocol.start_tls in protocol.py fails to flush its internal _buffer before calling loop.start_tls, so any attacker-injected SMTP response lines appended after the legitimate 220 reply are subsequently parsed as if they arrived inside the TLS tunnel. No public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the CVSS AC:H rating confirms exploitation requires an active man-in-the-middle network position.

Denial of service in FreeIPA's ipa-enrollment SLAPI plugin allows any authenticated LDAP client to crash the 389 Directory Server by sending a malformed extended operation. The flaw (CWE-476, null pointer dereference) is triggered by omitting the request value for the JOIN_OID in the ipa-enrollment extended operation, causing the server to dereference a null pointer and crash. No public exploit or active exploitation has been identified at time of analysis; however, the low attack complexity and network-accessible vector make this a credible threat against any RHEL Identity Management deployment.

FreeIPA's Kerberos Ticket Granting Service fails to verify Privilege Attribute Certificate (PAC) signatures when processing cross-realm tickets from a trusted Active Directory domain, allowing any authenticated AD user to impersonate arbitrary FreeIPA principals. This grants unauthorized elevated access to FreeIPA services including the web portal, SMB server, and LDAP directory. No active exploitation is confirmed (not in CISA KEV; SSVC Exploitation: none), though SSVC rates technical impact as total and CVSS scores 8.1 - the gap reflects the non-default trust configuration prerequisite that limits real-world exposure.

Privilege escalation in FreeIPA allows an attacker with high LDAP write privileges to create a rogue service principal that impersonates a privileged existing one, bypassing the uniqueness constraint enforced by the 389-ds directory server. The flaw arises because 389-ds fails to recognize equivalent representations of the same Kerberos principal name (CWE-706), enabling the creation of a shadow principal that Kerberos treats as legitimate. If exploited, an attacker can acquire valid Kerberos service tickets for sensitive services, with full domain compromise as the realistic worst-case outcome. No public exploit exists and CISA KEV does not list this CVE, though SSVC rates the technical impact as total.

Local privilege escalation and denial of service in libvirt's NodeGetFreePages RPC handler allows an unprivileged local user to corrupt the root libvirtd daemon's heap memory through a crafted integer overflow. The CWE-190 flaw causes an undersized buffer allocation that is subsequently overwritten with real NUMA node data, enabling heap buffer overflow in a root-owned process. No public exploit code or CISA KEV listing exists at time of analysis, but the CVSS 7.8 score (AV:L/AC:L/PR:L) and full C/I/A impact make this a genuine priority on multi-tenant RHEL virtualization hosts.

Stack buffer overflow in GNU binutils 2.46.1 and earlier allows arbitrary code execution when a victim opens a crafted PE (Portable Executable) file using any binutils tool such as objdump or readelf. The out-of-bounds stack write (CWE-787) can corrupt return addresses, enabling attacker-controlled code execution in the victim's user context. No public exploit or CISA KEV listing has been identified at time of analysis, but the CVSS 7.8 High rating reflects full confidentiality, integrity, and availability impact if successfully exploited.

Use-after-free in libexpat before 2.8.4 allows an attacker who can supply crafted XML with a custom unknown-encoding declaration to corrupt parser memory when the encoding convert or release callback re-enters the parser without handler-depth tracking. Affected applications are those that register an UnknownEncodingHandler via XML_SetUnknownEncodingHandler - a non-default but legitimate usage pattern. No public exploit code or CISA KEV listing has been identified at time of analysis, and the CVSS score of 4.9 with AV:L/AC:H reflects the constrained exploitation prerequisites, though the library's wide deployment footprint elevates aggregate risk.

Hash flooding denial-of-service in libexpat 2.8.2 and 2.8.3 stems from an inverted boolean check on the return value of getentropy(), causing the library to silently proceed with a predictable hash seed whenever the entropy syscall fails. Any network-accessible application that passes attacker-controlled XML through the vulnerable libexpat versions is exposed, since an adversary can craft XML content whose keys collide in libexpat's hash tables, forcing O(n²) lookup behavior and CPU exhaustion. No active exploitation has been confirmed by CISA KEV and no public POC has been identified at time of analysis, but the unauthenticated network attack vector and libexpat's broad transitive footprint across runtimes and distributions make this a meaningful availability risk.

Unicode normalization mishandling in HashiCorp go-slug versions 0.4.0 through 0.18.2 enables a local attacker to circumvent .terraformignore exclusion rules, causing sensitive files to be silently bundled into Terraform slug uploads destined for remote backends. Exploitation requires local filesystem write access to the Terraform working directory and a legitimate operator triggering a slug upload operation - the CVSS vector confirms AV:L/UI:R, narrowing the realistic attack surface to shared workstations, multi-tenant CI/CD environments, or compromised developer machines. Confidentiality impact is rated high (C:H) because excluded files such as credentials, API keys, or Terraform variable files containing secrets may be exposed to remote Terraform Cloud or Enterprise backends; no public exploit has been identified and the vulnerability is absent from the CISA Known Exploited Vulnerabilities catalog.

Memory exhaustion in Coturn 4.15.0 allows an authenticated TURN user to crash or degrade server availability by abusing the RFC 8016 mobility extension (--mobility). The attacker repeatedly resumes a single TURN allocation from fresh UDP 5-tuples without completing handoffs, which overwrites the allocation's sole mobile_pending_resume backlink and orphans prior pending sessions whose cleanup watchdogs have been disarmed - causing unbounded process memory growth. No public exploit has been identified at time of analysis, though the patch commit includes a Python regression script (mobility_resume_flood.py) that precisely models the attack pattern, serving as an effective blueprint; exploitation requires both --mobility to be enabled and valid authenticated TURN credentials.

TCP/TLS stream parser desynchronization in Coturn TURN/STUN server prior to 4.15.0 allows any unauthenticated remote client to crash their own connection by sending a STUN message with a crafted body-length field value between 65520 and 65532. The integer overflow in stun_get_message_len_str() causes the framing layer to misinterpret the stream, consuming only 4-16 bytes and treating remaining data as a new message, ultimately dropping the attacking client's connection. No other clients or the server process are impacted; vendor-released patch version 4.15.0 is available and no active exploitation is confirmed.

Format string injection in Coturn prior to 4.13.0 lets an authenticated TURN user crash the relay server or leak stack memory into Redis by embedding printf-style specifiers in STUN USERNAME or REALM attributes. At nine call sites in ns_ioalib_engine_impl.c, attacker-controlled values pass is_secure_string() validation and are embedded into Redis keys; send_message_to_redis() then passes the composite key as the format argument to redisAsyncCommand(), causing redisvFormatCommand() to read past the va_list. No public exploit identified at time of analysis and no CISA KEV listing; however, the attack surface is reachable by any valid TURN credential holder, including guest or externally-provisioned users in many WebRTC deployments.

Uprobe-based gadget attachment in Inspektor Gadget (versions >= 0.27.0, < 0.53.1) can be weaponized by any unprivileged container to cause approximately 53 seconds of CPU burn in the IG daemon by supplying a crafted `/etc/ld.so.cache` file - no container capabilities required. Because IG uses fanotify hooks to pause container startup until uprobe attachment completes, and Docker serializes container starts behind that pause, a single crafted container effectively blocks all other containers on the host from launching for the duration of processing. The attack is amplifiable by starting multiple crafted containers simultaneously, and no public exploit has been identified at time of analysis.

Double-free heap corruption in FreeRDP's server-side audio redirection channel (rdpsnd) allows any authenticated RDP client to reliably crash the server and potentially corrupt heap memory in allocator-dependent ways. All FreeRDP server deployments prior to version 3.28.0 exposing the rdpsnd channel are affected. The attacker sends a single malformed Client Audio Formats PDU to leave a dangling pointer in the server context, which is then freed a second time during session teardown - guaranteeing a server crash and opening the door to further exploitation depending on the underlying allocator.

Server-side divide-by-zero in FreeRDP's rdpsnd audio channel allows any authenticated RDP client to crash the server-side audio process. By advertising a DVI ADPCM format with nBlockAlign=8 and nChannels=2, the client forces the `bs` block-size calculation to zero; the subsequent modulo operation raises SIGFPE and terminates the rdpsnd channel process. No public exploit or KEV listing exists; exploitation is constrained to authenticated sessions, but the low complexity makes it a credible denial-of-service risk in environments with audio redirection enabled.

Grafana OSS's Unified Alerting component allows a low-privileged authenticated organization member to query any datasource - including those they are explicitly denied access to - by setting the client-controlled queryType field to the reserved value __expr__ while supplying the UID of a real datasource in an alert rule. Authorization skips the datasources:query permission check when it sees __expr__, but the evaluator subsequently resolves and executes the query against the real datasource identified by datasourceUid, resulting in full data exfiltration through Grafana's configured credentials. Affected versions span Grafana OSS 8.4.0 through 13.1.1; no public exploit code or CISA KEV listing has been identified at the time of analysis, but the low attack complexity and confirmed reproduction under default OSS permissions make this a credible insider-threat and privilege-escalation vector.

CPython's tarfile module on POSIX platforms creates empty directories outside the intended extraction destination when processing archive members whose names temporarily escape and re-enter it, such as '../evil/../dest/sub/file'. The extraction filters ('tar' and 'data') validate the resolved path - which correctly resolves to inside the destination - but create intermediate directories from the raw member name as given, allowing filesystem pollution beyond the extraction boundary. File contents are never placed outside the destination, and no public exploit has been identified at time of analysis; the PSF advisory confirms the limited scope.

Config-name injection in GitPython <= 3.1.57 enables arbitrary git-config directive forgery and remote code execution via `core.sshCommand` or `core.hooksPath`. The option-name validator in `git/config.py` only blocks CR/LF/NUL, allowing `=`, `#`, and whitespace to pass unchecked; `write_section` then writes the option name verbatim, causing git to parse attacker-supplied content as a valid directive. Exploitation requires a calling application to forward attacker-influenced input to `config_writer.set_value()` as the option-name argument, and a proof-of-concept is publicly confirmed in the vendor GHSA advisory. No CISA KEV listing is present at time of analysis.

Arbitrary OS command execution in GitPython before 3.1.58 is possible by bypassing the check_unsafe_options guard using a single-character kwarg combined with split_single_char_options=False, causing git's short-option parser to interpret a smuggled joined token as --upload-pack=<cmd>. This is a second-order incomplete-fix bypass of the previously patched GHSA-r9mr-m37c-5fr3, affecting all guarded methods including clone_from, fetch, pull, push, ls_remote, iter_commits, blame, and archive. A working proof-of-concept is publicly available in the upstream GitHub Security Advisory GHSA-wvpp-8hx9-p66j; no CISA KEV listing is present at time of analysis, but the public PoC significantly lowers the exploitation bar.

Arbitrary file overwrite in GitPython before 3.1.58 allows attackers who can influence treeish arguments passed to IndexFile.from_tree, IndexFile.reset, or IndexFile.merge_tree to clobber any file writable by the host process with a valid git-index blob. The three affected methods in git/index/base.py forward caller-controlled strings directly to git read-tree with no option sanitization and no -- argument terminator, enabling injection of --index-output=<path>; git's last-occurrence-wins behavior lets the injected flag override the library's internal temp path. A proof-of-concept is publicly documented in GHSA-4gmw-gg2m-w46p; no CISA KEV listing was present at time of analysis.

Remote code execution in GitPython before 3.1.58 is reachable through Repo.init(), which forwards all keyword arguments verbatim to git init without any unsafe-option validation. An attacker who can influence the template kwarg can point it at an attacker-controlled directory containing malicious git hooks; git copies those hooks into the newly initialized repository, and the next git operation (e.g., a commit) triggers arbitrary code execution at the privilege level of the host process. A proof-of-concept demonstrating the full hook-copy-and-fire chain has been publicly released and independently reproduced per the GHSA advisory, and upstream fix code is available in PR #2204 and commit d9ddb55bdc66, targeting the 3.1.58 release.

Eclipse OpenJ9 JVM versions through 0.60 crash with a segmentation fault when processing a crafted .class file containing deeply nested annotations, enabling a denial-of-service attack against any Java application running on OpenJ9 where an attacker can supply class files for loading. The vulnerability is rooted in uncontrolled recursion (CWE-674) within the bytecode utility annotation parser, which exhausts the OS thread stack without triggering a recoverable error path. No active exploitation has been confirmed by CISA KEV and no standalone exploit code has been publicly identified, though the public GitHub fix PR clearly exposes the triggering mechanism and root cause.

Heap overread in swtpm's SWTPM_NVRAM_CheckHeader() function allows local low-privileged users to crash the swtpm daemon and leak heap memory contents to system logs on Red Hat Enterprise Linux 8, 9, and 10. The root cause is a classic sizeof-pointer vs. sizeof-struct confusion: the guard compares buffer length against sizeof(bh) (pointer width, 8 bytes on 64-bit) rather than sizeof(*bh) (actual struct size), permitting undersized buffers to bypass validation and triggering a 2-byte heap overread on 64-bit systems or 6 bytes on 32-bit. No public exploit or CISA KEV listing has been identified at time of analysis.

Denial-of-service in libheif 1.23.0 and earlier crashes host processes when a crafted HEIF sequence file - accepted by heif_context_read_from_memory() - leaves the context with no registered sequence tracks and heif_context_get_track() is subsequently called. Debug builds abort on assert(has_sequence()) in HeifContext::get_track(); release builds reach undefined behavior by dereferencing m_tracks.begin()->second on an empty std::map, which typically causes a segfault. The flaw is reachable through documented public APIs after parsing attacker-controlled bytes, making it directly relevant to any service that processes untrusted HEIF or AVIF input. No public exploit code is identified at time of analysis, and no CISA KEV listing exists.

Heap out-of-bounds write and read in libheif 1.23.0 and earlier allows an attacker who can supply a crafted HEIF/AVIF image sequence to corrupt heap memory during any application decode-then-re-encode workflow. The flaw stems from the uncompressed encoder allocating output buffers from primary image dimensions (e.g., 2x2) while copying each component plane using that plane's actual stored size (e.g., a mismatched 256x256 alpha plane), writing 65536 pixels worth of data into a 4-pixel allocation. No public exploit has been identified at time of analysis and no CISA KEV listing exists, but the fix commit includes a purpose-built regression test that directly reproduces the heap overflow, confirming the root cause.

Type confusion in V8, Chrome's JavaScript engine, enables remote code execution within the browser sandbox against users running Chrome prior to 151.0.7922.169. An unauthenticated remote attacker can trigger the vulnerability by luring a victim to a crafted HTML page, making this a drive-by exploitation scenario requiring only a single user interaction. Google has released a patch in stable channel version 151.0.7922.169; no public exploit or CISA KEV listing has been identified at time of analysis, though SSVC rates the technical impact as total.

Sandbox escape via heap-based buffer overflow in ANGLE's graphics engine on Chrome for Android allows a threat actor who has already achieved renderer process compromise to execute arbitrary code entirely outside the Chrome sandbox. All Chrome for Android versions prior to 151.0.7922.169 are affected; the vulnerability requires a two-stage exploit chain combining a separate renderer compromise with this ANGLE flaw. Google has released a patched build (151.0.7922.169); no public exploit code or CISA KEV listing has been identified at time of analysis, though the two-stage nature indicates likely use in sophisticated targeted attack chains.

Use-after-free in Google Chrome's WebGL subsystem allows remote code execution inside the browser sandbox for all Chrome versions prior to 151.0.7922.169. An attacker can achieve arbitrary code execution within the Chrome renderer by delivering a crafted HTML page to a victim, requiring only a single page visit. No public exploit code or CISA KEV listing has been identified at time of analysis; however, CVSS 8.8 with low attack complexity reflects meaningful real-world risk for any unpatched Chrome deployment.

Sandbox escape via race condition in Google Chrome's USB subsystem (all versions prior to 151.0.7922.169) enables arbitrary code execution on the host system when chained with a renderer process compromise. This is a second-stage exploit: an attacker must already have code execution within Chrome's sandboxed renderer before the USB TOCTOU race can be leveraged to cross the sandbox boundary, triggered through a crafted HTML page. No public exploit code or CISA KEV listing has been identified at time of analysis, though the scope-changed CVSS rating of 8.3 (S:C, C:H/I:H/A:H) underscores that a successful chain achieves full host-level compromise.

Remote code execution within the Chrome renderer sandbox is achievable against all Chrome versions prior to 151.0.7922.169 by delivering a crafted HTML page to a victim user. The root cause is an incorrect arithmetic or numeric calculation in V8, Chrome's JavaScript engine, which can be triggered purely through JavaScript execution in a standard browsing session. No public exploit code or CISA KEV listing has been identified at time of analysis, but the CVSS score of 8.8 and the universality of Chrome's user base make this a high-priority patching candidate.

Skia graphics library in Google Chrome prior to 151.0.7922.169 leaks information in a way that allows remote attackers to potentially bypass the web Same-Origin Policy via a specially crafted HTML page. Affected users on all desktop platforms running any Chrome version before 151.0.7922.169 are exposed to cross-origin data disclosure triggered by visiting a malicious page. No public exploit code or CISA KEV listing has been identified at time of analysis; a vendor-released patch is available.

Use-after-free in the Browser component of Google Chrome on macOS prior to 151.0.7922.169 enables remote attackers to execute arbitrary code outside the sandbox. Exploitation requires social engineering to induce a user to visit a crafted HTML page, placing this in the user-interaction-required category. No public exploit code or CISA KEV listing has been identified at time of analysis, but the sandbox escape impact elevates real-world severity significantly.

Incorrect reference resolution in the Core component of Google Chrome on Android exposes sensitive information to remote attackers who can socially engineer users into visiting a malicious HTML page. Affected versions are all Chrome for Android builds prior to 151.0.7922.169. Exploitation requires user interaction but no authentication, and the vulnerability is platform-specific to Android. No public exploit code and no CISA KEV listing have been identified at time of analysis; a vendor-released patch is available.

Type confusion in V8, Chrome's JavaScript engine, enables arbitrary code execution inside the Chrome renderer sandbox on any platform (Windows, macOS, Linux) when a user visits an attacker-controlled HTML page. All Chrome releases prior to 151.0.7922.169 are affected; Google has released the patched stable-channel build. No public exploit code or active exploitation has been identified at time of analysis, though the SSVC framework rates technical impact as total within the sandbox boundary.

Sandbox escape via link following in Google Chrome's CredentialProvider component on Windows allows a local attacker to execute arbitrary code outside the browser's security sandbox, affecting all Chrome versions prior to 151.0.7922.169. The vulnerability stems from improper symbolic link or junction resolution (CWE-59) in the CredentialProvider, a Windows-specific subsystem handling credential operations, enabling a local attacker to redirect file access operations to attacker-controlled paths. No public exploit code has been identified and CISA's SSVC assessment confirms no known exploitation; however, the full CIA triad impact and sandbox escape potential make this a meaningful local privilege boundary violation.

Remote code execution in Google Chrome for Android before 151.0.7922.169 stems from a heap buffer overflow in Dawn, Chromium's WebGPU implementation, and is notable because Google explicitly states it allows code execution OUTSIDE the renderer sandbox. A remote attacker who lures a victim to a crafted HTML page can achieve full compromise of the browser process context on the device. Rated Critical by Chromium with CVSS 9.6; a vendor patch is available, and no public exploit has been identified at time of analysis.

Heap-based buffer overflow in Google Chrome's WebGL implementation (all versions prior to 151.0.7922.169) enables a remote attacker to execute arbitrary code outside the browser sandbox by luring a user to a crafted HTML page. The sandbox escape elevates the impact from renderer-level code execution to potential full OS-level compromise. No public exploit code or active exploitation has been identified at the time of analysis, but the SSVC technical impact rating is 'total,' reflecting the severity of successful exploitation.

Site isolation bypass in Google Chrome prior to 151.0.7922.169 enables a renderer-compromised attacker to cross origin boundaries via a flawed CORS implementation, reading or modifying data from otherwise isolated sites. This is a chained exploitation scenario: it requires a preceding renderer compromise as a prerequisite, making it a sandbox-escape-class vulnerability rather than a standalone browser attack. No public exploit code or active exploitation has been identified at the time of analysis, and a vendor patch is available in the 151.0.7922.169 stable channel release.

Partial denial-of-service in Oracle Java SE's JSSE component allows unauthenticated remote attackers to degrade availability of applications using TLS APIs across a broad range of supported Java versions. Affected releases span Java SE 8 through 26, GraalVM for JDK 17 and 21, and GraalVM Enterprise Edition 21.3.19, making this a wide-blast-radius availability issue for the Java ecosystem. Exploitation is limited to availability impact only - no confidentiality or integrity compromise is possible - and no public exploit or active exploitation (CISA KEV) has been identified at time of analysis.

Remote denial-of-service in Oracle Java SE's 2D component allows unauthenticated network attackers to hang or crash the JVM across versions 25.0.4 and 26.0.2 via multiple protocols. The attack surface spans both server-side Java deployments exposing 2D-related APIs through web services and client-side environments running sandboxed Java Web Start applications or applets processing untrusted code. Oracle characterizes this as easily exploitable with no public exploit identified at time of analysis; no KEV listing is present.

Unauthorized data exposure in Oracle Java SE's Networking component allows unauthenticated remote attackers via HTTP to access critical or all data accessible to the affected Java process, with a confirmed scope change that can impact systems and products beyond the JDK's own security boundary. Affected versions span a wide range across Oracle Java SE (8u501 through 26.0.2), Oracle GraalVM for JDK (17.0.20 and 21.0.12), and Oracle GraalVM Enterprise Edition (21.3.19), covering both server-side Java API consumers and client-side Java Web Start or sandboxed applet deployments. No public exploit code has been identified at time of analysis, and the vulnerability does not appear in the CISA Known Exploited Vulnerabilities catalog; however, the breadth of affected LTS versions and the ubiquity of Java in enterprise environments make patch prioritization appropriate.

Tar extraction path traversal in moby/go-archive allows an attacker who controls archive contents to create or overwrite files outside the intended destination directory, undermining container-to-host filesystem boundaries. The affected functions - Unpack, UnpackLayer, Untar, UntarUncompressed, and ApplyLayer - perform lexical path validation but rely on OS-level resolution at operation time, meaning symlinks introduced inside the archive redirect writes to arbitrary paths writable by the extracting process. This flaw propagates through the full Docker ecosystem including Docker Engine, Docker Desktop, Docker CLI, Docker Compose, and Docker Sandboxes; vendor-released patches are available and no public exploit code has been identified at time of analysis.

Unauthenticated read access to VReplication log data in Vitess vttablet (versions 24.0.2 and earlier) exposes raw SQL statements and bound application parameter values to any caller who can reach the debug HTTP port. The `/debug/vrlog` endpoint, registered via `addHttpEndpoint()` in `go/vt/vttablet/tabletmanager/vreplication/vrlog.go`, invokes `vrlogStatsHandler()` without the `acl.CheckAccessHTTP(r, acl.DEBUGGING)` guard applied to every comparable debug endpoint, violating the operator-configured security policy. Critically, the feature is disabled by default since v22 and requires explicit opt-in via `--vreplication-enable-http-log`, which materially limits real-world exposure; no public exploit has been identified and the CVE is not listed in CISA KEV.