2026-09-16
Sandbox escape in the Avast/AVG/Norton sandbox minifilter driver (aswSnx.sys) on Windows allows an authenticated, low-privileged process already executing inside the sandbox to break file isolation and escalate to SYSTEM (CVSS 8.8, AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, CWE-281). The driver opens the virtualization target with only GENERIC_WRITE and FILE_WRITE_ATTRIBUTES, omitting WRITE_DAC, so every attempt to reapply the original DACL fails silently and virtualized copies of sensitive files are left with permissive permissions; the IRP_MJ_CREATE handler additionally fails to strip WRITE_DAC for sensitive directories, letting a sandboxed process rewrite the security descriptor of a virtualized object, read the virtualized SAM copy, extract local NTLM hashes and run code as SYSTEM. Publicly available exploit code exists (the PrettyPrague proof of concept), the vendor has released patches for the affected Avast, AVG and Norton products, and no CISA KEV entry indicates confirmed active exploitation.
Denial of service in PocketBase versions prior to 0.22.48 (0.22.x branch) and 0.23.0 through 0.39.6 (0.23.0+ branch) allows an authenticated attacker or server misconfiguration to crash the process by triggering a panic in an internal goroutine that escapes the panic-recovery middleware. The flaw requires a network-reachable instance and low-privilege access (e.g., superuser) for the most directly reachable paths such as backup restore or view creation; public exploit code exists. Impact is limited to availability, causing process termination and requiring a restart, with no data exposure or code execution.
Authenticated users of zlt2000 microservices-platform through 6.0.0 can overwrite the password of any non-administrator account by calling the PUT /users/password endpoint with an arbitrary user id and a new password, because the server never verifies the current password. The flaw is network-reachable, low-complexity, and requires only a low-privilege login session (CVSS 4.0 base 8.7; assessed CVSS 3.1 AV:N/AC:L/PR:L/UI:N/C:H/I:H/A:L), and publicly available exploit code exists. Exploitation is limited to non-administrator accounts and is not possible pre-authentication, but a successful attack yields full credential takeover of the targeted account.
Missing authorization in zlt2000 microservices-platform through 6.0.0 lets any authenticated account - including one with zero assigned roles - invoke administrative APIs for user management, role assignment, password resets by user ID, and Elasticsearch index deletion, because the shipped default of zlt.security.auth.urlPermission.enable is false and suppresses all permission checks once authentication succeeds. Exploitation is not pre-auth: it requires a valid low-privilege session against a deployment running the out-of-the-box configuration, and publicly available exploit code exists (VulnCheck-reported PoC scripts covering role-granting, user enumeration, password reset, and ES index deletion), though no confirmed active exploitation (CISA KEV) has been recorded. Assessed severity is high (CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H = 8.8; vendor-published CVSS 4.0 score 8.7) because a zero-role user obtains both read and write access to sensitive administrative functions.
Insufficient scope validation in GitLab Enterprise Edition lets an authenticated user holding only Developer permissions run security policy test pipelines inside projects in their own group and read protected CI/CD variables that are meant to be restricted to Maintainer or Owner roles. All EE releases from 19.0 up to 19.1.8, 19.2.6 and 19.3.2 are affected, and GitLab shipped fixes in those patch releases. Publicly available exploit code exists (a HackerOne report is referenced), but there is no confirmed active exploitation and no CISA KEV listing.
A high-privileged authenticated attacker can inject and execute arbitrary operating-system commands on the Ruijie RG-EW3000GX router running firmware EW_3.0(1)B11P380, through the user_list_note functionality that manipulates the Name argument resolved from /etc/rg_config/admin. The vulnerability is network-reachable and requires no user interaction, but the CVSS vector (PR:H) confirms it is only exploitable after obtaining administrator credentials for the device management interface, so anonymous internet attackers cannot reach it directly. Publicly available exploit code exists (a GitHub proof-of-concept for the RG-EW3000GX user_list_note flaw), which materially raises the likelihood of post-authentication abuse, particularly on routers whose management plane is exposed to the WAN or protected by weak/default admin passwords; no CISA KEV entry has been reported for this CVE.
OS command injection in the Ruijie RG-EW3000GX router (firmware EW_3.0(1)B11P380) lets an attacker who already holds a valid administrator session execute arbitrary shell commands on the device by injecting metacharacters into the data.url argument of a configChange request handled by the cc_set function in unifyframe-sgi.elf. Exploitation is remote and low-complexity once admin access is obtained, and publicly available exploit code exists (PoC disclosed via GitHub and VulDB), though there is no CISA KEV confirmation of active exploitation. Because the CVSS vector carries PR:H and the independent assessment confirms the configChange/cc_set path is not reachable pre-authentication, this is a real but privilege-gated vulnerability rather than an unauthenticated takeover.
Improper sanitization of user-controlled data in GitLab CE/EE's Markdown JSON table renderer allows crafted content to make a targeted user's browser issue unintended state-changing HTTP requests when the rendered page is viewed, affecting versions from 15.3 through 19.1.7, 19.2.5 and 19.3.1. Exploit details are publicly available through a linked HackerOne report, and the vendor CVSS of 8.2 reflects network reachability, a high attack-complexity rating, required user interaction and a scope change. Vendor-released fixes are 19.1.8, 19.2.6 and 19.3.2.
Unauthenticated denial of service in GitLab CE/EE caused by flawed resource accounting in the GraphQL complexity calculation logic, allowing a crafted query to consume disproportionate server resources. Exploitation affects GitLab 18.4.6 through 19.1.7, 19.2.0 through 19.2.5, and 19.3.0 through 19.3.1 - any Internet- or network-reachable instance with the GraphQL API enabled. Public exploit code exists (a HackerOne report is cited as the source), but there is no CISA KEV listing confirming active in-the-wild exploitation at time of analysis.
Unauthenticated denial of service in GitLab CE/EE (all versions from 18.4.6 before 19.1.8, 19.2 before 19.2.6, and 19.3 before 19.3.2) allows a remote attacker with no credentials to exhaust server resources through the GraphQL API by submitting queries whose true cost the complexity calculation under-counts. The flaw is an improper resource-allocation limit (CWE-770), scored CVSS 7.5 with the entire impact on availability (A:H) and none on confidentiality or integrity. Publicly available exploit code exists - a HackerOne report is linked from the advisory - but there is no CISA KEV listing, so active in-the-wild exploitation is not confirmed; EPSS data was not supplied with this record.
Arbitrary file deletion in zlt2000 microservices-platform through 6.0.0 allows authenticated attackers to delete any user's files and metadata due to missing ownership validation in the file-center module's DELETE /files/{id} endpoint. Attackers can enumerate file identifiers via GET /files and then delete arbitrary files, bypassing authorization controls (CWE-639); publicly available exploit code exists. Exploitation requires a valid, low-privilege account (PR:L) with access to the file-center REST API, and the impact is limited to integrity and availability (no data disclosure), with a CVSS 4.0 base score of 7.2.
Mass assignment in djust, a Django library providing Phoenix LiveView-style reactive server-side rendering, allows any client with an established WebSocket session to overwrite arbitrary public attributes on a LiveView instance through the framework's default `update_model` event handler. The handler ships in `djust.mixins.model_binding.ModelBindingMixin`, which sits in the LiveView base MRO and is therefore exposed by every view, and it `setattr`s a view attribute whose name is supplied entirely by the client - gated only by a 14-entry framework-internal denylist, an underscore-prefix rejection, and an opt-in `allowed_model_fields` allowlist that defaults to `None` (allow all). Affected deployments are djust versions prior to 1.0.7 that leave the allowlist unset and keep authorization, ownership, or business state such as `self.account_id`, `self.is_admin`, or `self.total_price` as public view attributes; the advisory's own reproducer set all three without any `dj-model` binding. Exploitation yields state tampering that can escalate to authorization-flag manipulation or IDOR when downstream handlers act on the tampered attributes without re-authorizing, giving a High integrity impact with no confidentiality or availability impact (assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N); no public exploit code was identified at time of analysis and there is no CISA KEV entry, though the vendor retained a private reproducer.
Authenticated attackers can read arbitrary Elasticsearch indices in zlt2000 microservices-platform through 6.0.0 by supplying any index name in the POST /search/{indexName} or GET /agg/requestStat/{indexName}/{routing} endpoints, bypassing authorization checks. This exposes sensitive data such as the sys_user index containing user records and password hashes; the vulnerability has a CVSS 4.0 base score of 7.1 and an assessed CVSS 3.1 vector of AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, meaning high confidentiality impact with no integrity or availability effect. Publicly available exploit code exists (no CISA KEV confirmation), and exploitation requires only a valid low-privilege session on a network-reachable search-center service.
Authenticated back-office users of yshop-crm through 2.1.3 can enumerate the complete user directory via GET /admin-api/system/user/page because the endpoint's @PreAuthorize('system:user:list') gate is commented out in UserController.java. The flaw is a broken-access-control issue (CWE-862) that requires valid admin-panel credentials plus a role configured with data scope ALL; without that scope the query returns little of value, but with it an attacker can harvest login names, nicknames, departments, emails, mobile numbers, and last-login metadata. Publicly available exploit code exists (a Python enumeration PoC), and no CISA KEV entry confirms active exploitation at time of analysis. The independent assessment rates this CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, meaning authenticated remote confidentiality loss only - no integrity or availability impact.
Missing authorization in yshop-crm 2.1.3 and earlier lets any authenticated back-office (admin-api) user delete arbitrary approval-workflow steps via DELETE /admin-api/crm/flow/delete-step, bypassing the permission check that should restrict this to workflow administrators. The result is an integrity-only compromise of the approval chains that gate contract, receivable, and invoice finalization; there is no confidentiality or availability impact, and the CVE record's CVSS 4.0 score of 7.1 maps to an independent CVSS 3.1 assessment of AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N, i.e. a genuine but moderate-priority missing-authorization flaw rather than a critical takeover. Publicly available exploit code exists (a Python PoC against the delete-step endpoint); no CISA KEV listing or other confirmation of active in-the-wild exploitation was present in the supplied data.
Missing authorization in yshop-crm through 2.1.3 allows any authenticated back-office user - including low-privilege operators - to read the installation-wide audit trail by calling GET /admin-api/crm/operatelog/page, exposing operator names, display nicknames, client IP addresses, User-Agent strings, request URLs, action details, and customer identifiers. Publicly available exploit code exists (a PoC script that queries the endpoint), and although exploitation requires a valid back-office session with network reach to the admin API, no elevated role or user interaction is needed, so the realistic threat is a malicious insider or anyone who has reused or stolen an operator credential. The vulnerability is broken access control (CWE-862) with high confidentiality impact only; it does not permit data modification, service disruption, or pre-authentication compromise.
Missing authorization in yshop-crm through 2.1.3 allows any authenticated back-office user to claim and reassign sales leads belonging to other employees by invoking the CrmCluesController receiveCustomer lead-claim endpoint with a manipulated ownerUserId value. The flaw is a broken access control (CWE-862) issue that requires only a valid low-privilege staff login and no administrative role, feature toggle, or user interaction, with the practical impact limited to integrity of lead ownership data (no confidentiality or availability impact). Publicly available exploit code exists in the form of a Python proof-of-concept targeting the endpoint, and the absence of access logging or quota validation on the operation removes any built-in brake on bulk lead theft, though no confirmed active exploitation (CISA KEV) has been observed at time of analysis.
Missing authorization in yshop-crm through 2.1.3 allows any authenticated back-office user to issue arbitrary invoices by calling the PUT /admin-api/crm/invoice/issue endpoint, which performs no permission check on the caller. An attacker holding low-privileged back-office credentials can set an invoice's status, overwrite contract invoiced amounts with attacker-chosen values, and trigger invoice emails to arbitrary recipient addresses - a pure integrity impact with no confidentiality or availability loss. Publicly available exploit code exists (a Python PoC in the LinYuanyi1 cve-request-poc repository), but there is no evidence of confirmed active exploitation (CISA KEV).
Missing authorization in yshop-crm through 2.1.3 lets any authenticated back-office user, regardless of role or privilege level, invoke the saveRedisSet and getRedisSet endpoints in CrmCustomerController and rewrite the installation-wide Redis keys that drive lead allocation and customer auto-recycling. Because the scheduled CustomerAutoJob consumes those same keys, a low-privilege staff account can disable recycling, block customer creation, or trigger mass customer deletion across the deployment; publicly available exploit code exists (the VulnCheck-referenced CVE request PoC on GitHub), while no active exploitation has been confirmed and the CVE is not listed in CISA KEV. This is a genuine but bounded-priority issue: exploitation requires a valid CRM account (assessed CVSS PR:L, so unauthenticated remote abuse is not possible), and the assessed impact is high integrity loss to shared policy state (I:H) with a limited availability effect (A:L) and no confidentiality loss (C:N - the readable values are configuration/policy keys, not customer records).
Command injection in Pepperl+Fuchs ICE2/ICE3 IO-Link Master devices (and OEM equivalents from Phoenix Contact and others) allows a low-privileged authenticated attacker to execute arbitrary OS commands as root via the PHP endpoint /index.php/ajax/get_iodd_menu_info. Any valid user or operator account - the lowest access tiers on the device - is sufficient to achieve full device compromise. No public exploit has been identified at time of analysis, but the vulnerability is straightforward (CWE-78) and reported across three separate CERTVDE advisories covering multiple vendor SKUs, indicating a shared firmware base.
Arbitrary file overwrite in the Contest Gallery WordPress plugin (Upload & Vote Photos, Media, Sell with PayPal & Stripe) affects all versions up to and including 32.0.1, where the 'baseUrlForFacebook' parameter is passed to a file-writing routine without adequate path validation. Exploitation requires at least a subscriber-level account on the target WordPress site, but then allows overwriting known files on the server, which can escalate to remote code execution when the overwritten path is a PHP file that the web server later executes. No public exploit code or CISA KEV listing was provided in the source data for this CVE, so active exploitation is unconfirmed at time of analysis.
Local privilege escalation in Qualitysoft Corporation's QND endpoint management client for Windows (Advance ≤Ver.11.0.9i, Premium and Standard ≤Ver.11.1i) allows any logged-in user to execute arbitrary commands with SYSTEM privileges by abusing an improperly access-controlled named pipe exposed by the client component. The named pipe lacks a restrictive DACL, permitting user-mode processes running under low-privileged accounts to communicate with the SYSTEM-level pipe server and direct it to execute attacker-controlled commands. No public exploit code and no CISA KEV listing have been identified at time of analysis; JPCERT/CC and Qualitysoft Corporation have both published advisories.
Denial of service in the official RabbitMQ Go client library amqp091-go (versions prior to 1.13.0): a malicious, compromised, or impersonated AMQP 0.9.1 broker can crash any application that connects to it. By encoding a byte-array field length as 0xFFFFFFFF (decoded into a signed int32 as -1) inside the connection.start server-properties table or a message header field table, the broker drives readField() to call make() with a negative size, producing a 'len out of range' runtime panic that escapes the reader goroutine and terminates the client process. Attackers must sit on the broker side of the connection - a trusted-broker deployment is largely unaffected - and the outcome is availability loss only, with no code execution or data disclosure. No public exploit code or confirmed active exploitation has been identified at time of analysis; vendor-released patch 1.13.0 is available.
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.
Crafted OSPFv3 packets can force an unexpected restart of the OSPFv3 routing agent on Arista EOS devices that have OSPFv3 configured, causing a transient loss of routing adjacencies and traffic disruption. The flaw is an availability-only denial of service (CWE-130 improper handling of length parameters) with no code execution, data disclosure, or persistence; no authentication is required (PR:N) and no user interaction is needed (UI:N), but exploitation depends on a preconditioned packet and, per our assessment, an attacker positioned on the same OSPFv3-participating link or adjacency domain rather than arbitrarily across the internet. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the vendor has published Security Advisory 0173.
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.
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.
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.
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.