Memory-exhaustion denial of service in the official RabbitMQ Go AMQP 0.9.1 client library (amqp091-go) prior to 1.13.0 lets a malicious or compromised broker kill client processes: when a content header frame arrives, the client preallocates the message body buffer using the broker-declared 64-bit body size without capping that hint to the negotiated Connection.Config.FrameSize, so an extreme declared size drives a correspondingly huge Go heap allocation before any body bytes are received, exhausting memory and terminating the process. The exploitation model is broker-attacks-its-clients rather than exploitation by an arbitrary network attacker (CVSS 4.0 8.9 with AT:P, and the assessed CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H), meaning the victim application must connect to a broker that is hostile, subverted, or on a path an attacker can tamper with; no client credentials or unusual configuration are needed, and a FrameSize of 0 ("unlimited") removes the cap entirely even after patching. There is no CISA KEV entry and no public exploit identified at time of analysis, but the upstream fix commit, test case, and 1.13.0 release are all public.
Denial of service in the RabbitMQ amqp091-go Go client for AMQP 0.9.1 (versions prior to 1.13.0) allows a malicious or compromised broker to advertise a FrameMax below the protocol's 4096-byte frameMinSize during connection negotiation, causing the client to fragment subsequent publications into an excessive number of frames and write operations, consuming CPU and stalling the client process or its host. The assessed vector carries PR:N, so no authentication is required on the client side, but exploitation is bounded by a trust-boundary prerequisite: the victim Go application must connect to a broker that the attacker controls or has compromised, and TLS with proper broker authentication prevents an unrelated network attacker from impersonating the broker. Impact is availability-only with no loss of confidentiality or integrity, and no public exploit code has been identified at time of analysis.
A memory-corruption flaw in the Linux kernel's vfio-pci driver (vfio/pci/vfio_pci_config.c) allows a local user holding access to a VFIO passthrough device node (typically /dev/vfio/*) to trigger a use-after-free and subsequent double-free of the per-device MSI permission table (vdev->msi_perm). Exploitation requires attacker-induced failure of the allocation path (init_pci_cap_msi_perm()/alloc_perm_bits() returning -ENOMEM during a failed device open, e.g. under memory pressure or fault injection), after which re-opening the same persistent vfio_pci_core_device reuses the freed perm_bits object - dereferencing its readfn/writefn function pointers inside vfio_pci_config_rw_single() - while closing it hits kfree() on an already-freed object in vfio_config_free(). There is no public exploit code identified and no indication of active exploitation at time of analysis; EPSS is low (0.21%, ~11th percentile), and the memory-pressure precondition plus the requirement for VFIO passthrough privileges materially limits real-world reliability, even though the assessed CVSS:3.1:AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H score is high.
A use-after-free in the Linux kernel's Bluetooth SCO (synchronous connection-oriented) socket handling lets an attacker within Bluetooth radio range race the SCO connection-ready path against a concurrent socket close, dereferencing a freed socket with the potential for kernel memory corruption or a crash. Only systems with Bluetooth enabled and an active SCO listening socket are exposed, and exploitation is unauthenticated but adjacent (AV:A) and highly timing-dependent (AC:H in independent assessment), with the realistic outcome being a kernel denial of service rather than reliable code execution. No public exploit code has been identified at time of analysis and the vulnerability is not in CISA KEV; EPSS is 0.19% (9th percentile), indicating low observed exploitation likelihood, and vendor patches are available in stable releases 5.15.212, 6.1.178, 6.6.145, 6.12.97, 6.18.40 and 7.1.
Unauthenticated visitors can inject arbitrary WordPress shortcodes, including attacker-chosen attributes, into Formidable Forms versions before 6.35 because a request-derived value is substituted into a form's custom HTML and then passed through the shortcode parser server-side. Any page rendering an affected form will execute the injected shortcode, which can expose data or alter site behaviour depending on which shortcodes are installed on the target. Publicly available exploit code exists per WPScan, but CISA KEV does not list this issue and the CVSS score is moderate (4.8, AV:N/AC:H/PR:N/UI:N/C:L/I:L/A:N), reflecting configuration-dependent preconditions and limited impact.
Path traversal in Octopus Server allows an authenticated low-privilege user to overwrite arbitrary files on the server filesystem, which in certain configurations escalates to remote code execution. Affected are three distinct release trains of Octopus Server (CPE: cpe:2.3:a:octopus_deploy:octopus_server). No public exploit or CISA KEV listing exists at time of analysis, and a vendor patch is available across all three affected version ranges.
Unauthenticated remote access to the configuration download function on XikeStor Layer3 switches (SKS8300-8T, SKS8300-12E2T2X, SKS8310-8X) running firmware below V1.04.B09 exposes full device configuration files to any network-reachable attacker. Recovered configurations contain network topology details and credentials, enabling attackers to authenticate to the switch itself or leverage it as a pivot point into the protected network segment it manages. Disclosed by JPCERT/CC (JVN#45281119); no public exploit code or active exploitation (CISA KEV) identified at time of analysis.
Unauthenticated arbitrary Python module import in djust before 1.0.7 lets any client that can reach the WebSocket or SSE mount endpoint force the server to import a module chosen by a client-supplied dotted path, executing that module's import-time side effects before any LiveView subclass check or per-view authentication occurs. The LIVEVIEW_ALLOWED_MODULES allowlist that should constrain this lookup is fail-open (the check is skipped when the setting is unset, which is the framework default) and uses loose startswith matching, so the flaw is reachable in a default configuration; the assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H. Impact is bounded by what is already installed and importable on the host: guaranteed outcomes are denial of service (import bombs, expensive dependency trees) and a module/class enumeration oracle exposed through distinct error strings, escalating to RCE-by-proxy where a suitably side-effectful module exists. No public exploit has been identified at time of analysis - the maintainer retains the reproducer privately - and there is no CISA KEV listing.
Cross-tenant authorization bypass in TinaCMS self-hosted deployments allows any holder of a legitimate TinaCloud account and its valid bearer token to read, create, update, delete, and manage media on a victim site without any victim account or interaction. The flaw affects @tinacms/auth before 1.1.4 and the next-tinacms-azure adapter before 15.0.1, where the server-side isAuthorized helper trusts a request-supplied clientID and therefore validates the attacker's token against the attacker's own TinaCloud app rather than the site's configured app (CWE-639, CVSS 8.8, PR:L). Exploitation is authenticated from the attacker's perspective - the attacker must already control a TinaCloud-verifiable token, so any TinaCloud account suffices - while no public exploit code was identified at time of analysis and the vendor has released patched versions.
A hardening release for Cisco Secure Adaptive Security Appliance (ASA) Software, Cisco Secure Firewall Threat Defense (FTD) Software, and Cisco Secure Firewall Management Center (FMC) Software addresses a class of internally discovered defects grouped under CVE-2026-20333, described as incorrect comparison conditions (CWE-697) that can lead to high confidentiality, integrity, and availability impact (CVSS 8.8). Affected deployments span ASA 9.16 through 9.24, FTD 7.0 through 10.0.0, and FMC 7.0 through 10.0.1, and exploitation requires network reachability to the affected management/data plane plus valid low-privilege credentials (CVSS vector PR:L), so this is not an unauthenticated remote attack. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV); Cisco resolved it proactively through the cisco-sa-hardening-asaftdfmc-uvpPROhN advisory rather than in response to a reported incident.
SQL injection in Cisco Secure FMC's web-based management interface allows an authenticated, remote attacker holding a Security Approver, Access Admin, or Network Admin role to execute arbitrary SQL against the backend database, potentially exfiltrating any data and capturing session credentials of an authenticated Administrator. The CVSS 3.1 vector (8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) reflects low attack complexity gated only by the required privileged account, and no public exploit code or active exploitation has been identified at time of analysis.
Cisco Nexus Dashboard versions 2.1 through 4.2.1 contain information exposure and insecure handling vulnerabilities that allow authenticated low-privileged remote attackers to access sensitive information and potentially cause limited integrity impact. The flaws are addressed in a software hardening release and require network access to the management interface; no public exploit code exists at time of analysis. Cisco has released a patch per advisory cisco-sa-hardening-ndw1-psFvnrg.
Unauthenticated attackers on an adjacent network segment can exploit multiple resource lifetime flaws (CWE-664) in Cisco Secure Firewall ASA, FTD, and FMC software to potentially achieve full confidentiality, integrity, and availability impact (CVSS 8.8). The vulnerabilities were internally discovered and addressed in a Cisco hardening release; the exact affected feature is not publicly detailed, and no public exploit code has been identified at time of analysis.
Authenticated remote code execution in Cisco Secure Firewall Management Center (FMC) lets a low-privileged web-management user turn a crafted HTTP request into root-level command execution on the underlying appliance. The flaw is an unsecured deserialization sink in the web-management interface (CWE-502): an attacker who can reach the FMC web UI and authenticate with credentials for at least the Security Analyst (read-only) role can save a malicious payload and get it executed as root, giving a complete compromise of confidentiality, integrity, and availability (CVSS 3.1 base 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). No public exploit code and no confirmed active exploitation were identified at time of analysis, but the low privilege bar - the least-privileged FMC role rather than an admin account - makes this a high-priority management-plane risk for internet- or broadly reachable deployments. Cisco Secure Firewall Management Center versions across the 7.0.x, 7.2.x, 7.3.x, 7.4.x, 7.6.x, 7.7.x and 10.0.x trains are reported as affected.
Path traversal (CWE-22) in Cisco Nexus Dashboard lets a remote attacker holding valid low-privileged credentials (CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N) send crafted requests that escape intended directory boundaries, yielding high confidentiality, integrity, and availability impact for an overall base score of 8.8. Cisco addressed this and several other internally discovered flaws as a group in a single software hardening release rather than documenting each issue individually, so the specific vulnerable feature or endpoint is not publicly enumerated. No public exploit code or confirmed active exploitation was identified at time of analysis; the decisive prerequisite is an existing authenticated session, meaning fully unauthenticated internet attackers cannot exploit it directly, but any Nexus Dashboard node whose API/UI is reachable by accounts of any privilege level should be treated as in scope until patched.
Cisco Nexus Dashboard is affected by multiple SQL injection vulnerabilities (CWE-89) that can be triggered by an authenticated attacker with low privileges over the network. Successful exploitation could allow reading, modifying, or deleting sensitive data and disrupting the management interface, with high impact to confidentiality, integrity, and availability as reflected in the CVSS 3.1 score of 8.8. No public exploit identified at time of analysis, and the authentication requirement combined with typical management network segmentation limits real-world risk.
HP Advance server software contains a path traversal vulnerability (CWE-22) in its HP AC Print & Scan and HP Output Central components, allowing unauthenticated remote attackers to write arbitrary files, which can lead to remote code execution or privilege escalation. The vendor CVSS 4.0 vector (8.8) rates it network-reachable and unauthenticated with high integrity and availability impact, but HP notes impact occurs 'under certain conditions,' implying unstated deployment prerequisites that may narrow actual exploitability; no public exploit code or confirmed active exploitation has been identified at time of analysis.
SQL injection in Tanium Threat Response (CVSS 3.1 base score 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) allows a low-privileged, authenticated user to inject crafted input over the network and manipulate the backend SQL queries, producing high confidentiality, integrity and availability impact on the affected component. Exploitation requires a valid Threat Response console account or API credentials at low privilege (PR:L) plus network reachability to the management interface, but needs no user interaction and involves low attack complexity. No public exploit code and no confirmed active exploitation have been identified at time of analysis; Tanium addressed the issue and documents it in advisory TAN-2026-047.
SQL injection in the Tanium Asset module allows a remote attacker who already holds a valid Tanium console session with Asset-module authorization to execute arbitrary SQL through an undisclosed injectable input, with high impact to confidentiality, integrity, and availability (CVSS 3.1 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The vulnerability is an authenticated-adjacent issue: the PR:L vector means the attacker must first obtain console credentials and Asset authorization, and the target must have the optional Asset module deployed, which narrows the exposed population below Tanium's overall install base. No public exploit code has been identified at time of analysis and the flaw is not on CISA KEV, so this is a genuine mid-to-high priority patching item rather than a drop-everything emergency; Tanium has addressed it via advisory TAN-2026-049.
Unauthenticated remote attackers can read trace and funnel analytics from SigNoz deployments running versions 0.88.0 through 0.141.0 because the trace-funnel analytics HTTP handlers were registered without any authorization wrapper. A single unauthenticated POST to endpoints under the trace-funnels router (both the /{funnel_id}/analytics/* and /analytics/* payload variants) returns identifiers, durations, span counts, service topology, and error activity, and because the payload-style handlers accept attacker-supplied funnel definitions, no pre-existing funnel or account is required. Exploitation is bounded by network reachability to the query-service listener and is read-only (no modification or code execution), and no public exploit code has been identified at time of analysis.
Path traversal and arbitrary file write in the oras-go OCI artifact library prior to 2.6.2 allow a malicious artifact layer marked with the io.deis.oras.content.unpack=true annotation to escape the content/file.Store extraction root and create or overwrite any file writable by the pulling process, potentially leading to code execution. Exploitation is unauthenticated from an attacker's network position (CVSS:3.1/AV:N/AC:L/PR:N) but requires user interaction (UI:R) because the victim must pull the attacker-controlled artifact reference; the bug bypasses the AllowPathTraversalOnWrite=false default, so no permissive configuration is needed. Scored 8.8 High, with no public exploit identified at time of analysis and no CISA KEV listing; a vendor patch is available in oras-go 2.6.2.
Authorization bypass in ScadaLTS 2.8.1-release-candidate build 0 lets any authenticated user invoke restricted DWR methods by sending a POST to a URL their role is allowed to reach while naming a privileged class and method in the request body, bypassing Spring Security's URL-pattern-only access control; the assessed severity is CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), with high confidentiality, integrity, and availability impact once the flaw is chained with the other Tenable-reported findings it enables. Exploitation is not anonymous: the attacker must already hold a valid low-privilege ScadaLTS session, and the deployment must run with DWR's crossDomainSessionSecurity setting set to false in web.xml (the default in the affected build), which disables DWR's built-in origin and session validation. No confirmed active exploitation (CISA KEV) and no public exploit code were identified in the available intelligence at time of analysis, so the practical urgency is driven by the credential precondition rather than by observed attacks.
Authenticated remote code execution in ScadaLTS 2.8.1-release-candidate build 0 allows any holder of a low-privilege account to run arbitrary JavaScript on the server by abusing the scripting sandbox. The DWR-exposed DataSourceEditDwr.validateScript method performs no authorization check and is reachable through a DWR routing bypass, so supplied code is compiled and executed by the Rhino engine with the application's privileges (CVSS 3.1: 8.8, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). There is no public exploit identified at time of analysis and no confirmed actively exploited (CISA KEV) status; the independent assessment treats this as a genuine, credible priority rather than an inflated high-CVSS artifact, with the requirement for valid credentials being the principal limiting factor.
Unauthenticated server-side request forgery in DataGear through 6.0.0 lets any remote attacker who can reach the web interface force the server to issue arbitrary HTTP requests - GET, POST, PUT, PATCH, or DELETE - to internal hosts and cloud metadata services via the /dataSet/preview/Http endpoint, returning the full response body to the caller. The endpoint is reachable without credentials (it is exempted by the SecurityConfigSupport allowlist), so the only prerequisite is network reachability to the DataGear instance, with impact maximized in cloud deployments where the link-local metadata service at 169.254.169.254 is reachable and can yield IAM credential theft. No public exploit code has been identified at time of analysis, the issue is not in CISA KEV, and no vendor-released patch has been identified.
Authenticated users who can register or modify a TechDocs documentation source can achieve code execution inside the Backstage TechDocs backend or its build container by supplying a crafted mkdocs.yml, because @backstage/plugin-techdocs-node fails to strip unsafe Python YAML tags, markdown_extensions names and their configuration, theme options, and extra_templates values before the file reaches the Python documentation generator. The flaw affects the techdocs-node plugin before 1.14.6 and the 1.15.0 through 1.15.3 range, and the vendor has released fixes in 1.14.6 and 1.15.4. Authentication is mandatory per the CVSS vector (PR:L), no public exploit code or confirmed active exploitation was identified at time of analysis, and the blast radius is limited to the files, credentials, and network reach of the TechDocs backend or build container rather than the wider Backstage host.
Path traversal in the Jenkins Robot Framework Plugin (6.2.2 and earlier) allows an authenticated user holding Item/Configure permission to point the plugin's report archive directory at a location outside the build directory, giving attacker-chosen file creation or overwrite anywhere on the Jenkins controller filesystem - an impact that can be escalated to remote code execution. The flaw is remotely reachable (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 8.8) and requires no user interaction, but it is gated by the Item/Configure privilege, plugin installation and use, and a build actually executing to trigger the write. No public exploit code has been identified at time of analysis, and the risk concentrates on multi-user or multi-tenant controllers where lower-trust users are permitted to configure jobs.
Sandbox escape leading to arbitrary code execution inside the Jenkins controller JVM affects Script Security Plugin 1415.v9a_f9b_3a_c253d and earlier because the plugin fails to reject the @GroovyASTTransformationClass annotation in script source. An authenticated Jenkins user with permission to define and run sandboxed scripts, including Pipelines (the CVSS vector carries PR:L), can submit a script that registers a Groovy AST transformation executed at compile time, before the sandbox applies, resulting in high confidentiality, integrity, and availability impact on the controller; our independent assessment scores this 8.8 with a scope change (S:C) rather than the provider's S:U. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV, but for any account holding script-submission rights the exploit path is direct rather than theoretical, so the practical risk concentrates on instances that grant Job/Configure or equivalent Pipeline-authoring rights broadly. This is a genuine high-priority vulnerability, not CVSS inflation: the sandbox itself, not a misconfiguration, is the control being bypassed.
Arbitrary code execution in Jenkins Script Security Plugin 1415.v9a_f9b_3a_c253d and earlier allows an authenticated attacker with permission to define and run sandboxed Groovy scripts or Pipelines to bypass the sandbox and run code in the Jenkins controller JVM. The flaw is a protection mechanism failure (CWE-693) in how the plugin casts collections, and it carries CVSS 8.8 with PR:L; only users who can author sandboxed scripts or Pipelines can trigger it. No public exploit code was identified at time of analysis, and CISA SSVC rates exploitation as none, but this is high-priority for multi-tenant Jenkins because script-authoring rights are often broadly granted.
Sandbox escape in the Jenkins Script Security Plugin (1415.v9a_f9b_3a_c253d and earlier) allows authenticated users with permission to define and run sandboxed Groovy or Pipeline scripts to execute arbitrary code in the Jenkins controller JVM, because the sandbox fails to intercept method calls, property and attribute accesses, and array accesses made on a null receiver. No non-default configuration is required - the weakness is inherent to the default sandbox - and the flaw is rated CVSS 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, CWE-693), with CISA SSVC assessing total technical impact but no active exploitation and no public exploit identified at time of analysis. Real-world urgency is moderated by the access prerequisite: the attacker must already hold script-authoring rights, so exposure is concentrated in multi-tenant or delegated Jenkins instances where Pipeline authoring is granted to less-trusted users.
Sandbox escape in the Jenkins Script Security Plugin 1415.v9a_f9b_3a_c253d and earlier lets an authenticated user who holds permission to define and run sandboxed scripts - including Pipelines - execute arbitrary code in the Jenkins controller JVM, earning a CVSS 3.1 base score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The root cause is a protection-mechanism failure (CWE-693): the sandbox proxy created when a script coerces a value to a Java interface skips the method check when the coerced value inherits a same-named method, so the interface proxy can be used to reach unchecked code. No public exploit code has been identified at time of analysis and CISA SSVC rates the issue non-automatable (Exploitation: none, Automatable: no, Technical Impact: total), so mass exploitation is not expected; the binding prerequisite is the authenticated script-authoring permission reflected by PR:L, which makes this a real but privilege-gated RCE-class risk.
Advantech EKI-1242EIMS and EKI-1242IEIMS industrial gateways running firmware V1.06.01 expose their edgserver management protocol on TCP port 5058 without any authentication, allowing a remote unauthenticated attacker who can reach that port to invoke critical device-management functions such as network reconfiguration, reboot, reset, and firmware upgrade. The flaw is a CWE-306 missing authentication for critical function issue with CVSS 8.8 (v4.0) and an independently assessed CVSS 3.1 of 8.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:H); the vector contains PR:N, confirming no credentials or user interaction are required. Impact is integrity and availability only - there is no confidentiality exposure - and there is no public exploit identified at time of analysis and no CISA KEV listing, so the practical risk is gated by whether the OT management segment is reachable from an untrusted network.
Use-after-free (CWE-416) in the Linux kernel's HID Sony driver can be triggered when a physically attached Sony/PlayStation-compatible HID controller (USB or Bluetooth) fails input_register_device() after sony_input_configured() has already linked it into sony_device_list; the devres-managed sony_sc structure is later freed while its list node stays linked, so a second matching controller traversing the list reads freed memory. This requires a rare registration-failure error path (typically memory/resource exhaustion) plus a second device attach event and physical device access, so it is a local crash/DoS-class bug rather than a remote code-execution issue; the public CVSS 8.8 (AV:A) score materially overstates impact relative to the assessed vector CVSS:3.1/AV:P/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H. No public exploit code exists and the flaw is not in CISA KEV; no public exploit identified at time of analysis. Vendor-released patches exist in kernel 6.18.51, 7.2.5, and 7.3-rc1.
A stack buffer overflow in the Linux kernel's staging rtl8723bs Wi-Fi driver allows an unauthenticated attacker within radio range to corrupt kernel memory by sending a crafted WPS information element in a beacon or probe-response frame that the target parses while scanning. Because the driver trusts an attacker-controlled 2-byte WPS attribute length as a memcpy() size without comparing it against the remaining bytes of the IE, the copy overruns single-byte stack variables such as the selected-registrar flag at call sites in ioctl_cfg80211.c and rtw_mlme_ext.c, yielding a kernel crash and, depending on build hardening, possible code execution; the independent assessment rates this AV:A/AC:L/PR:N/UI:N with high integrity and availability impact (confidentiality rated none). No public exploit code or confirmed active exploitation has been identified at time of analysis, and exposure is confined to systems with this niche driver loaded and an adversary physically close enough to inject 802.11 management frames.
Out-of-bounds reads and writes in the Linux kernel's hid-rmi driver let a physically attached HID device that advertises the Synaptics RMI report IDs (RMI_DEVICE) leak kernel heap memory and corrupt adjacent slab objects during probe, with the stolen bytes surfaced to any local user through a mode-0444 sysfs attribute. Unpatched kernels from 3.16 onward are affected up to the listed fixed releases, which include 5.10.270, 5.15.221, 6.1.188, 6.6.157, 6.12.110, 6.18.51, 7.2.5 and 7.3-rc2; no public exploit code has been identified at time of analysis. The vendor CVSS of 8.8 (AV:A/PR:N/UI:N) overstates real-world risk - our assessment is AV:P/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:H - because an attacker must supply the device locally (or already be root to force a bind via new_id) and the code paths only run during probe, though the confidentiality impact is real since the leaked register data is exposed to unprivileged userspace and echoed back to the device itself.
A functional regression introduced in the Linux kernel's dma-direct allocator by commit 5b138c534fda causes dma_direct_alloc_from_pool() to hand back a CPU address where its caller dma_direct_alloc_pages() expects a struct page pointer, so that path dereferences an address as page metadata and can corrupt state or crash the kernel. Only kernels built with the atomic DMA coherent pool (CONFIG_DMA_COHERENT_POOL) and configurations that route coherent allocations through the atomic pool - typically GFP_ATOMIC or restricted/non-coherent DMA device paths - are exposed, and the bug is reachable only by local kernel/driver DMA activity with low privileges, not over a network. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (no CISA KEV entry); severity should be read as the low-CIA/availability-heavy impact assessed locally (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H) rather than the higher network-adjacent score carried in some feeds.
A use-after-free (CWE-416) in the Linux kernel's s390/vfio-ap AP crypto passthrough driver allows a local attacker with host-side privilege to corrupt kernel state by attaching a second vfio-ap mediated device to a KVM instance that already owns one. On the resulting -EPERM error path, vfio_ap_mdev_set_kvm() fails to restore kvm->arch.crypto.pqap_hook, leaving it pointing at an mdev that is never tracked by matrix_mdev->kvm; when that mdev is later freed, a guest-executed PQAP instruction dereferences the stale hook through pqap_hook_rwsem and triggers the use-after-free. Exploitation requires an IBM Z/s390 host running KVM with vfio-ap enabled but is not remotely reachable, needs authenticated local privilege to configure mediated devices, and depends on error-path plus free-then-execute sequencing; no public exploit code or confirmed active exploitation was identified at time of analysis, and vendor patches are available in the stable trees.
The s390 vfio-ap mediated device (mdev) driver in the Linux kernel fails to actually revoke crypto control-domain access when a privileged host administrator unplugs a control domain from a matrix mdev: vfio_ap_mdev_cfg_remove clears the wrong bit set with bitmap_andnot instead of intersecting with bitmap_and on the mdev's adm bitmap. The practical result is that a KVM guest on IBM Z hardware configured for AP (Adjunct Processor) passthrough retains access to control domains the host intended to remove, a residual-access/state-desynchronization condition rather than remote code execution, reached only when a host admin performs an explicit control-domain removal (CVSS 3.1 AV:L/AC:L/PR:H/UI:N/S:C/C:L/I:L/A:N). No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV; the vendor-supplied 8.8 score (AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H) materially overstates real-world risk given that exploitation is confined to the rare s390 crypto-passthrough deployment mode and requires a trusted privileged reconfiguration action.
Stale hardware access to unplugged crypto resources in Linux KVM guests on IBM Z (s390) stems from a logic error in the vfio-ap mediated-device driver: when the last AP adapter, domain, or control domain is removed from the host's AP configuration, the shadow APCB is cleared but the bitmap_andnot() return value is false for an empty result, so the do_hotplug flag never gets set and the guest's APCB is never refreshed. Only s390 hosts with CEX crypto adapters configured for guest passthrough are affected, exploitation is local and requires privileged host management access to modify the AP configuration, and no public exploit code has been identified at time of analysis. The practical consequence is a crypto-resource isolation failure in which the guest passively retains access to AP devices the administrator believes were unplugged, not memory corruption or code execution.
A use-after-free in the Linux kernel's batman-adv (B.A.T.M.A.N. advanced) mesh networking module lets an attacker on the adjacent mesh trigger a kernel crash by exploiting stale receive-device metadata on reassembled fragments. When batman-adv merges buffered fragments it reuses the skb from the highest-numbered fragment; if the hard interface that carried that fragment is torn down before the fragment chain completes, the merged skb re-enters the receive path holding a freed skb->dev pointer, and the DAT and bridge loop avoidance handlers dereference it when computing the ARP header length. The assessed impact is availability only (kernel crash/DoS) with at most limited integrity effects, requiring a narrow race between fragment buffering and administrative interface removal; no public exploit code has been identified, no KEV listing exists, and exploitation is limited to the adjacent mesh segment (CVSS:3.1/AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H assessed; NVD published a higher 8.8 vector that this analysis does not corroborate).
Stale TLB entries can be reused by an L2 guest in the Linux kernel's KVM nested virtualization (nVMX) implementation on x86 Intel VMX hosts, because vpid02 is not flushed on its first use after a VPID is recycled following an L1 guest's VMXOFF/VMXON cycle. Exploitation requires an attacker who already controls an L1 guest on a host running KVM with nested virtualization enabled (kvm_intel nested=1) where L1 uses VPID for its L2 guests, and success depends on KVM reusing a vpid02 value that still has TLB entries resident on the physical CPU, making the outcome timing- and reuse-dependent rather than deterministic. No public exploit has been identified at time of analysis, and our independent assessment rates the realistic impact well below the vendor's CVSS 8.8 - limited confidentiality and integrity loss with high availability impact under local, high-complexity preconditions (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:C/C:L/I:L/A:H).
Linux kernel's KVM nested-VMX (nVMX) emulation can leave stale L2 guest TLB entries on a physical CPU, because KVM executes the L1 guest's INVVPID on whichever pCPU is currently active rather than on the pCPU where L2 last ran. When L1 migrates to another CPU, issues INVVPID, and then migrates back to the original CPU to resume L2, the stale VPID mappings on that original pCPU are never invalidated and vmx_vcpu_load_vmcs() does not request a KVM_REQ_TLB_FLUSH because vmcs02 never ran on a different pCPU. Affected are x86 hosts with non-default nested virtualization enabled and a malicious or buggy L1 guest controlling an L2 guest; exploitation requires local access to an L1 vCPU (PR:L) and a narrow cross-CPU scheduling/migration race, no public exploit code has been identified at time of analysis, and CISA KEV does not list this issue. The judged impact is primarily TLB corruption and nested-guest instability rather than a reliable code-execution or data-exfiltration primitive, consistent with an assessed vector of AV:L/AC:H/PR:L/S:C/C:L/I:L/A:H.
Slab use-after-free in the Linux kernel's KVM x86 MMU lockless rmap aging path affects hosts running Linux 6.15 through 6.18.50 and 7.x before 7.2.5 that are built with CONFIG_KVM_MMU_LOCKLESS_AGING=y. A local user able to run or drive a KVM guest (PR:L, no user interaction) can race the lock-elision window so that a writer populates a KVM_RMAP_MANY rmap and later frees its pte_list_desc chain while the lockless aging walk is still traversing it, yielding memory corruption of kernel slab memory; the race is timing-dependent (AC:H) and is driven by host memory reclaim rather than attacker-controlled scheduling, so exploitation is opportunistic rather than deterministic. No proof-of-concept or public exploit code has been identified at time of analysis and there is no evidence of active exploitation. Vendor scoring is 8.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H), while independent assessment rates it 6.3 with AC:H and no confidentiality impact, reflecting the narrow, reclaim-triggered race window; it is a local privilege/DoS-class memory-safety bug, not a remote code execution issue despite the 'RCE' tag on the record.
A use-after-free race in the arm64 KVM vGICv3 code path of the Linux kernel (vgic_v3_save_pending_tables) allows a locally authenticated guest with vCPU-level access to trigger a dangling-pointer dereference against host kernel memory. The flaw requires an arm64 KVM host configured with GICv3 LPI/ITS support, where a concurrent irqfd cached-injection plus a guest ITS DISCARD can free an LPI that the pending-table save loop still holds via a stale xarray iterator pointer; the practical outcome is a host-side crash/denial of service with limited integrity impact rather than a clean, reliable privilege escalation, and exploitation depends on a tight timing window (assessed AV:L/AC:H/PR:L, S:C, C:N/I:L/A:H). Vendor patches are available in Linux 6.18.51, 7.2.5, and 7.3-rc1; no public exploit code and no confirmed active exploitation have been identified at time of analysis.
On LoongArch hosts running KVM, a memory-slot update that changes only flags (KVM_MR_FLAGS_ONLY, most notably toggling KVM_MEM_LOG_DIRTY_PAGES for live migration) zeroes the slot's architecture-specific flags, so a slot previously marked KVM_MEM_HUGEPAGE_INCAPABLE because of a GPA/HVA offset mismatch can subsequently be mapped with PMD-sized entries; because the mapping path aligns the guest frame number and host page frame number independently, the guest can read or write the wrong host pages, giving a local attacker with access to the KVM VM file descriptor both confidentiality and integrity impact on the host (CVSS 8.8 vendor score, AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H). The independent assessment rates the attack complexity higher (AC:H) because exploitation requires a misaligned memslot plus a flags-only update, typically during live migration, and does not manifest for a static guest with aligned memslots; only the LoongArch architecture is affected. No public exploit code was identified at time of analysis and the issue is not listed in CISA KEV, though the tags classify the outcome as information disclosure and the successful corruption path is a memory-safety violation with high integrity impact.
Out-of-bounds kernel memory corruption in the Linux kernel's LoongArch KVM EIOINTC interrupt-routing code allows a local attacker who holds a VM file descriptor to read and write memory beyond the loongarch_eiointc allocation. The MSI data field supplied by userspace through KVM_SET_GSI_ROUTING (irqfd/KVM_IRQ_LINE) or KVM_SIGNAL_MSI is passed unchecked into eiointc_set_irq() and used as an IRQ index against 256-bit bitmaps and the sw_coremap[]/coreisr/sw_coreisr arrays, so any value of 256 or greater triggers deterministic, fully attacker-controlled out-of-bounds accesses with scope change from the guest process into kernel memory (CVSS 3.1 8.8, AV:L/PR:L/S:C). Exploitation is confined to LoongArch hosts running KVM and requires local access to the KVM interfaces; the DMSINTC path is unaffected because it decodes and masks the vector from the address. No public exploit code has been identified and the flaw is not confirmed actively exploited (not in CISA KEV), and vendor patches are available in the stable kernel commits referenced by the advisory.
An out-of-bounds write in the Linux kernel's HDMI-CEC driver for the Extron DA HD 4K Plus adapter (media: cec: extron-da-hd-4k-plus) lets a malicious or malfunctioning CEC device overflow the fixed-size msg.msg[] buffer, crashing the kernel and potentially corrupting kernel memory. Only hosts that have the extron-da-hd-4k-plus driver built and bound to an actual Extron DA HD 4K Plus CEC adapter are affected, and the malformed CEC message must arrive over the physically or adjacently attached CEC/serial link - there is no remote, over-the-network attack path against a default configuration. No public exploit code or in-the-wild exploitation has been identified at time of analysis, and the vendor's CVSS 8.8 (AV:A/AC:L/PR:N/UI:N/C:H/I:H/A:H) materially overstates real-world risk; our independent assessment is AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H, since the hardware is rare, the input channel is adjacent-only, and reliable escalation beyond a kernel crash is not demonstrated.
Repeated command aborts in the Linux kernel's qla2xxx (QLogic Fibre Channel) driver can reinitialize an already-queued work item, corrupting workqueue list state and leading to host crashes, hangs, or a looping worker - a denial-of-service condition on systems using NVMe over Fibre Channel. Affected code exists from the introduction commit e473b3074104ee09227cfbba5f872e3ea15dd280 (reported as Linux 4.17) onward, and fixes are available in stable releases 6.6.157, 6.12.110, 6.18.51, 7.2.5 and 7.3-rc1. No public exploit code has been identified at time of analysis, and the bug is a driver-internal timing race rather than an attacker-invokable primitive: triggering requires a host with a qla2xxx HBA actively handling NVMe-FC FCP or LS I/O where two aborts for the same command race (for example, concurrent transport teardown and a timeout-driven abort), so our assessment rates it substantially lower than the vendor's headline CVSS of 8.8 (AV:A/PR:N) - a local, high-complexity race with no confidentiality impact.
Wild-pointer dereference in the Linux kernel's qla2xxx QLogic Fibre Channel HBA driver lets an unexpected STATUS_TYPE completion IOCB reach a SCSI-only fast path, where the srb union is reinterpreted so sp->u.scmd.cmd reads as a non-NULL garbage pointer and is dereferenced. Only hosts running the qla2xxx driver with a physical QLogic FC HBA are exposed, and only when the adapter firmware or FC fabric delivers a mis-typed status IOCB that coincides with a live non-SCSI outstanding handle; the assessed vector is CVSS:3.1/AV:A/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:H, so the realistic outcome is a kernel crash rather than reliable code execution. No public exploit code or confirmed active exploitation has been identified at time of analysis, and vendor patches are available for all maintained stable branches.
Concurrent host_map btree corruption can occur in the Linux kernel's qla2xxx QLogic Fibre Channel driver because the format-1 branch of qla24xx_report_id_acquisition() releases vport_slock before invoking qla_update_host_map()/qla_update_vp_map(), which mutates ha->host_map without the serialization the function contract requires. Only systems running the qla2xxx driver with a QLogic FC HBA and NPIV virtual ports configured (a privileged local configuration) exercise this code path, and triggering it depends on winning a narrow, non-deterministic timing race against another host_map update. The result is kernel-internal data-structure corruption rather than direct data theft; no public exploit code has been identified and the issue is not confirmed as actively exploited (no CISA KEV).
Stale GPU TLB entries in the Linux kernel's AMD KFD (amdkfd) driver let in-flight DMA descriptors from already-unmapped MES-scheduled queues continue reading or writing memory that has been freed or migrated, producing page faults and hung compute queues. The flaw affects AMD GPU/APU systems running KFD/ROCm compute through the MES firmware scheduler path rather than the HWS path (which invalidates the TLB automatically), and was reproduced on gfx1151 (Strix Point) with XNACK mode 1 enabled during SVM page-migration workloads such as KFDSVMRangeTest.MultiThreadMigrationTest. It is a local, timing-sensitive race requiring a GPU-authorized local user, per our assessment triggers only during MES queue eviction (evict_process_queues_cpsch) or debug/CRIU queue suspension (suspend_queues) concurrent with SVM page migration; no public exploit identified at time of analysis, and it is not listed in CISA KEV. Vendor-released patches (Linux 6.18.51, 7.2.5, and 7.3-rc2) add the missing kfd_flush_tlb() calls.