Quadratic CPU consumption in basic-ftp before 6.2.1 lets a malicious or compromised FTP server freeze a Node.js application that calls Client.list(): the RE_LINE pattern in src/parseListUnix.ts backtracks across the optional, unbounded owner and group fields of a crafted Unix-style directory line, and because parseList() picks a parser from the last nonblank line and then applies it to every line, a normal trailing entry can force the vulnerable Unix parser onto the earlier hostile line and block the event loop. The attack requires the victim to connect out to an untrusted or attacker-controlled FTP endpoint and perform a listing (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H - availability only, no confidentiality or integrity impact); unauthenticated attackers are sufficient, but the trust direction is the limiting factor, so systems that only talk to trusted FTP servers are not realistically exposed. There is no public exploit identified at time of analysis and the issue is not confirmed as actively exploited (no CISA KEV), and the vendor-released patch is version 6.2.1.
Improper URL construction in the @astrojs/node adapter for the Astro web framework (versions prior to 11.1.3) allows an unauthenticated remote client to terminate or disrupt a Node-hosted Astro site by sending a Host header whose port cannot be parsed, such as example.com:65536, example.com:99999, example.com:-1, example.com:abc, or a duplicated port like example.com:8080:8080. In the default standalone configuration the malformed host triggers an HTTP 500 while the server keeps running, but when the non-default staticHeaders option is enabled the exception is thrown from a synchronous handler, escapes the adapter's error handling, and crashes the Node process, producing a full availability loss. Impact is availability-only with no data exposure and no code execution path; any fronting proxy or CDN that rejects malformed Host headers prevents the request from reaching the origin and neutralizes the attack. No public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor-released fix is @astrojs/node 11.1.3.
Broken access control in the MakeCommerce for WooCommerce WordPress plugin (versions up to and including 4.1.0) lets a low-privilege authenticated Subscriber reach a plugin action that is missing its capability check, allowing unauthorized modification of store data. The published CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L) scores 8.2, but our independent assessment adjusts the privilege requirement to PR:L, since the 'Subscriber Broken Access Control' classification implies an authenticated Subscriber session is needed; open registration on many WooCommerce stores makes obtaining such an account trivial. The result is high integrity impact and limited availability impact with no confidentiality exposure, no user interaction required, and no public exploit identified at time of analysis.
Unauthenticated SQL injection in the WordPress plugin WP Data Access affects all versions up to and including 5.5.84, allowing remote attackers to inject arbitrary SQL into the site's database queries without logging in or any user interaction (CVSS 8.2, AV:N/AC:L/PR:N/UI:N). The assessed impact is primarily to database confidentiality (C:H) with only limited integrity impact (I:L) and no availability effect, which confines the practical worst case to large-scale data disclosure rather than site takeover or denial of service. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV), though the low attack complexity and lack of authentication prerequisites make weaponization straightforward; EPSS data was not provided in the source intelligence. This is a genuine priority for any WordPress site running the plugin, since exploitation requires only that the affected version be installed and reachable, with no special configuration needed.
Deserialization of untrusted data in Kiteworks Core before 9.5.0 can escalate to remote code execution on the appliance, but only as a secondary, chained weakness rather than a standalone attack. The issue is not exploitable in isolation: an attacker must first obtain a way to influence the data that Core deserializes, which in practice means chaining a separate flaw (for example one of the file-write or injection issues in the same CISA CSAF batch, va-26-274-01) or leveraging an existing foothold. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, and although the base score is 8.1, the local/config-adjacent reachability (AV:L), high attack complexity (AC:H) and the mandatory data-influence precondition materially lower real-world risk; the CVSS vector indicates no privileges are required (PR:N), but exploitation is not remotely self-contained.
Path traversal in AgentScope 1.0.0 through 1.0.18 lets an attacker who can influence the path argument passed to the agent's write_text_file tool cause file writes outside the intended directory, resulting in arbitrary file overwrite on the host running the agent. The assessed CVSS 3.1 base score is 8.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L), reflecting a network-reachable, low-complexity issue that requires the attacker to hold low privileges relative to the agent (PR:L) while the primary impact is integrity, with limited availability impact and no confirmed confidentiality impact. Exploitation is realistic in deployments where the agent is wired to call write_text_file with attacker-influenceable paths, most plausibly via untrusted content processed by the agent (indirect prompt injection) or a malicious task submitted to it; no public exploit code was identified at time of analysis, and the CVE is not listed in CISA KEV.
Path traversal in ModelScope AgentScope 1.0.0 through 1.0.8 allows an attacker who can reach the built-in insert_text_file tool and influence its path or filename argument to read and write files outside the intended workspace directory, giving both high confidentiality and high integrity impact (CVSS 8.1, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N). The attacker is not anonymous: exploitation requires at least low-privilege access to the agent or tool surface (PR:L), typically via a direct agent tool call, an exposed agent API endpoint, or prompt injection through untrusted content the agent processes, and the reachable damage is bounded by the filesystem permissions of the AgentScope process user. No confirmed active exploitation exists (not listed in CISA KEV) and no public exploit was identified at the time of analysis, so this should be treated as a real but conditional risk that depends on whether insert_text_file is enabled, exposed, and influenceable by an untrusted party.
Stored cross-site scripting in Kiteworks Core allows an administrator holding only a single narrowly scoped delegated permission to plant crafted content that later executes as JavaScript in the authenticated session of a higher-privileged System Administrator, enabling the lower-privileged attacker to escalate to full tenant administrative control and create a new administrative account. The flaw is tracked as CVE-2026-102126 with a vendor CVSS 3.1 score of 8.1 (AV:N/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:N) and is rated high severity under CWE-79. Exploitation requires an authenticated admin with the delegated permission (PR:H) and depends on the victim System Administrator viewing the affected page (UI:R); no public exploit code has been identified at time of analysis, and the issue is not in CISA KEV.
In Tugtainer versions before 1.31.3, the OIDC login flow accepts unverified JWT claims from the identity provider's id_token, allowing an unauthenticated remote attacker who can influence the token exchange to impersonate any identity and gain full control of the Tugtainer session. The flaw is a pre-authentication authentication bypass (CWE-347) with high confidentiality, integrity, and availability impact once triggered; exploitation requires OIDC to be configured and enabled. No public exploit has been identified at the time of analysis, and the issue is not listed in CISA KEV. A vendor patch is available in version 1.31.3.
Stack-based buffer overflow in apcupsd through 3.14.14 allows unauthenticated remote attackers to corrupt memory and potentially execute code through the optional CGI web interface. The flaw lives in getupsvar() in src/cgi/upsfetch.c, which is invoked by upsstats.cgi, multimon.cgi, and upsfstats.cgi; exploitation requires one of those CGI scripts to be deployed and reachable, plus the ability to control or man-in-the-middle the UPS variable data fed to it from an apcupsd Network Information Server. This is an AC:H, PR:N issue with full confidentiality, integrity, and availability impact; no public exploit code has been identified at time of analysis, and it is a related issue to CVE-2026-15544.
An out-of-bounds read in the kernel-mode layer of NVIDIA GPU Display Driver on Windows and Linux allows a local, authenticated unprivileged user to potentially achieve code execution, privilege escalation, denial of service, information disclosure, or data tampering. Affected products include GeForce, RTX/Quadro/NVS, and Tesla GPUs, as well as Guest Driver and vGPU Manager deployments. With a CVSS score of 7.8, the vulnerability requires local access and low privileges (CVSS vector AV:L/AC:L/PR:L/UI:N), making it primarily a risk in multi-user or shared-GPU environments; no public exploit has been identified at time of analysis, and patched driver branches are available in NVIDIA security bulletin 5861.
An out-of-bounds write in NVIDIA NVAPI for Windows allows a locally authenticated attacker holding standard user privileges to corrupt memory by invoking NVAPI entry points, potentially leading to code execution, elevation of privileges, information disclosure, denial of service, or data tampering. The flaw affects hosts running the NVIDIA GPU driver package on Windows - including GeForce, RTX/Quadro/NVS, and Tesla driver-equipped systems - with a CVSS 3.1 base score of 7.8 (HIGH) under vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. No public exploit code and no confirmed active exploitation (CISA KEV) have been identified at time of analysis, but the local-only, low-privilege prerequisite makes shared and multi-tenant GPU/VDI hosts the most exposed environment.
Type confusion in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux allows a local low-privileged user (CVSS vector AV:L/AC:L/PR:L/UI:N) who can reach the driver's device-node/ioctl interface to trigger memory corruption with high impact across confidentiality, integrity, and availability, potentially yielding code execution in kernel context, privilege escalation to root, denial of service, information disclosure, and data tampering. The CVSS 3.1 base score of 7.8 reflects a local attack vector paired with uniformly high impacts rather than any remote reachability, and despite the 'RCE' tag in the source metadata the vulnerability is not remotely exploitable. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and no EPSS or CISA KEV signal was provided.
Local privilege escalation in NVIDIA GPU Display Driver for Windows (CUDA driver component) allows an authenticated attacker with low privileges to execute arbitrary code by planting a malicious library in an uncontrolled search path. Affected products include GeForce, RTX/Quadro/NVS, Tesla, and vGPU guest driver branches. No public exploit identified at time of analysis; exploitation requires local access and write permissions to a directory resolved by the driver's search path, making it most relevant on shared multi-user or VDI/cloud-GPU hosts.
Local privilege escalation in NVIDIA Display Driver for Windows allows an authenticated low-privileged user to trigger a stack-based out-of-bounds write in the kernel mode layer, potentially leading to code execution, privilege escalation, and denial of service. Affected systems include Windows hosts with GeForce, RTX/Quadro/NVS, or Tesla drivers, as well as the Guest Driver in virtualized deployments. No public exploit code or active exploitation has been identified at time of analysis, and the flaw requires local access, making it most relevant to shared multi-tenant environments.
Local privilege escalation in Kiteworks Core lets an attacker who already holds code execution as an unprivileged backend service account invoke a privileged routine that mishandles attacker-influenced input, running arbitrary OS commands as root. The flaw requires a prior local foothold on the appliance - the CVSS vector (AV:L, PR:L, UI:N) confirms it cannot be reached directly over the network and demands an existing initial compromise or misconfiguration to obtain the service account. No public exploit code or active exploitation is identified at time of analysis, and the realistic risk is bounded by how easily that initial service-account access can be obtained on a given deployment; the vendor's advisory is GHSA-658c-86vw-g9hf.
Local privilege escalation and potential code execution in NVIDIA GPU Display Driver for Windows and Linux arise from a use-after-free (CWE-416) reachable by a low-privileged local user who can issue a crafted sequence of driver commands. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) rates confidentiality, integrity, and availability impact as high, with the greatest risk in shared or virtualized GPU deployments where guest-driver or virtual GPU manager isolation may be broken. No public exploit code or confirmed active exploitation is identified in the available data, and EPSS is not provided; exploitation requires local access and construction of the specific command sequence.
Local privilege escalation in NVIDIA Display Driver for Windows and Linux allows an unprivileged local attacker to trigger a use-after-free condition by issuing a crafted sequence of driver commands, potentially achieving code execution, privilege escalation, denial of service, or information disclosure. The vulnerability affects systems with GeForce, RTX/Quadro/NVS, or Tesla GPUs running vulnerable driver versions. No public exploit identified at time of analysis.
Local privilege escalation and memory corruption in NVIDIA GPU Display Driver on Windows and Linux, affecting GeForce, RTX/Quadro/NVS, and Tesla lines. An unprivileged local user can trigger a use-after-free (CWE-416) by issuing a specific sequence of driver commands, leading to potential code execution, privilege escalation, denial of service, or information disclosure. Requires local access and low privileges (AV:L/PR:L) with no user interaction (UI:N); no public exploit identified at time of analysis. Risk is highest in multi-user or shared-GPU environments such as VDI, terminal servers, and cloud/virtualized GPU hosts.
Local privilege escalation in the NVIDIA GPU Display Driver for Linux allows an authenticated, unprivileged user to trigger a use-after-free condition by issuing a specific sequence of driver commands, potentially leading to code execution, privilege escalation, denial of service, and information disclosure. The vulnerability affects GeForce, RTX/Quadro/NVS, and Tesla GPU drivers, including guest-VM vGPU deployments, and requires local access with low privileges. No public exploit code or confirmed active exploitation has been identified at time of analysis.
Local privilege escalation in Kiteworks Core allows an attacker who already holds a shell under a low-privileged service account to elevate to root on the appliance, gaining complete control of the system and the sensitive content it brokers. The weakness is a link-following issue (CWE-59) in a root-privileged operation, reachable with local access as the service account (CVSS:3.1/AV:L/AC:L/PR:L/UI:N), no user interaction, and no non-default configuration, making it a realistic second-stage escalation after a separate initial-access compromise. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the CVE is not associated with a KEV listing; the primary limiting factor is the prerequisite service-account foothold, while the primary risk is full root compromise of the appliance.
Local privilege escalation in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux allows an unprivileged local user to bypass read-only memory protection and gain write access to memory the driver marked read-only, which can result in kernel code execution, denial of service, privilege escalation, information disclosure, and data tampering. Exploitation requires the attacker to already hold low-privileged local access on an affected Linux host (CVSS 3.1 vector AV:L/AC:L/PR:L/UI:N, score 7.8) with no user interaction and no network vector; the risk is greatest on shared, multi-tenant vGPU, VDI, and cloud-GPU hosts where crossing the user-to-kernel boundary breaks tenant isolation. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but NVIDIA has published a fix through security bulletin 5861. This is a genuine local privilege-escalation risk rather than an emergency, and it should be prioritized on multi-tenant GPU infrastructure.
Local privilege escalation in Kiteworks Core lets an attacker who already has code execution as an unprivileged backend service account on the appliance obtain root. A privileged, root-owned routine consumes a filesystem path that the lower-privileged service account can influence, so the attacker can steer that root operation into executing arbitrary commands with full privileges (CWE-59 link-following / unsafe path handling). The attack is local-only (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8) and is a second-stage primitive requiring an existing foothold; no public exploit was identified at time of analysis and the CVE is not reported as confirmed actively exploited (CISA KEV), though the 7.8 severity and availability of a vendor advisory make prompt patching advisable.
Local code execution in JetBrains IntelliJ IDEA before 2026.2.3 is possible when a developer opens an attacker-supplied untrusted project, because malicious Structural Search script constraints then run within the IDE. The flaw is assessed as CVSS 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), meaning exploitation is local and requires the victim to open the project, but no target authentication is needed and default configurations are affected once that action occurs. No public exploit or confirmed active exploitation was identified at time of analysis; the risk is real but gated by social engineering and the local attack vector.
Privilege escalation in NVIDIA's GPU Display Driver for Windows lets a local, low-privileged authenticated user bypass an authorization check in the driver's kernel-mode escape handling, gaining kernel-level capabilities that can lead to code execution, data tampering, information disclosure, or denial of service on the affected host. The issue is classified as CWE-863 (incorrect authorization) with a CVSS 3.1 base score of 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); it is strictly local with no remote or network attack surface. No public exploit code has been identified and the vulnerability is not listed on CISA KEV, so it should be treated as a genuine but access-gated privilege-escalation risk concentrated in multi-user, VDI, and cloud-GPU hosts where an untrusted tenant or guest driver instance can reach the driver's escape interface.
Local privilege escalation in NVIDIA GPU Display Driver for Linux allows an authenticated local unprivileged user to write to memory that the kernel-mode display driver should keep read-only because permissions are not preserved (CWE-281), potentially causing code execution, privilege escalation, denial of service, information disclosure, or data tampering. The affected CPE branches are GeForce, RTX/Quadro/NVS, Tesla, and Guest Driver on Linux, with CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) indicating high impact after local access. No public exploit identified at time of analysis, and the practical risk is a genuine but not emergency-grade local privilege-escalation issue, most meaningful in shared or multi-tenant GPU environments.
Container escape in CRI-O - the OCI runtime that underpins Red Hat OpenShift Container Platform 4 - is achievable when a workload-level actor can create or influence pod metadata that overwrites CRI-O's own reserved sandbox bookkeeping; the poisoned state is then reloaded as trusted after a CRI-O daemon restart, and a subsequent container recreate inside that sandbox can expose a host-side runtime-management resource to the container. Rated CVSS 3.1 7.8 (AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), the flaw is not remotely reachable without cluster workload access, and the mandatory restart-then-recreate sequencing is the principal limiter on realistic exploitation. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing); no EPSS score was supplied in the available intelligence.
Local privilege escalation on Reachy Mini Wireless robots running OS images built from pollen-robotics/reachy-mini-os prior to v0.2.4, where a sudoers entry granted the low-privileged pollen daemon user (uid 1000) passwordless root access to /usr/bin/systemctl with no subcommand or argument restriction. Any code already executing as pollen - for example through a compromised reachy daemon - can escalate to full root (uid 0) without user interaction or a TTY, because systemctl can be pointed at an attacker-supplied unit file whose ExecStart runs as root. Rated CVSS 3.1 7.8 HIGH (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), confirmed by the vendor advisory GHSA-7rhg-9v48-x3h2 and closed by release v0.2.4; no public exploit code or CISA KEV entry was identified at time of analysis, and exploitation requires an existing foothold as the pollen user on an unpatched image.
Local privilege escalation to root in Pexip Infinity (versions before 38.2, plus 39.0, 39.1, and 40.0) allows an attacker who already holds a foothold on a node to break out of a low-privileged local context and obtain full root control. Per the CVSS vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8), the flaw is local-only, requires low privileges, and is not remotely exploitable on its own: the attacker must first run arbitrary code on the node, either by chaining a separate remote code execution vulnerability or by already possessing administrative access to the node's operating system. There is no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV); the practical risk is that this bug turns any successful initial compromise of a Pexip Infinity host into a complete root compromise, so it should be treated as a meaningful post-exploitation escalation rather than a standalone remote threat.
Incorrect resource transfer between spheres in the NVIDIA vGPU Virtual GPU Manager for Linux allows a locally positioned, low-privileged attacker to break an internal resource-handling boundary and gain high-integrity impact - code execution, privilege escalation, data tampering, information disclosure, or denial of service on the host running the vGPU Manager. This affects virtualization/vGPU deployments on Linux (the manager component on the hypervisor host), not standard desktop GPU drivers, and the CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) confirms the attacker must already hold local low-privileged access to a context served by that manager, such as a guest VM or a local account on the host; there is no network or unauthenticated path. It is a genuine local privilege-escalation class issue rather than a remotely triggerable one, and no public exploit was identified at time of analysis.
An out-of-bounds write in the kernel-mode layer of NVIDIA vGPU Virtual GPU Manager for Linux lets a local attacker with low privileges corrupt kernel memory, which the vendor rates as potentially leading to code execution, denial of service, privilege escalation, information disclosure, and data tampering (CVSS 3.1 base 7.8, HIGH). The attack is strictly local - vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H - so it is not remotely exploitable and requires only an authenticated low-privileged context or a tenant/guest that can reach the host kernel module; the risk is highest in multi-tenant VDI and cloud-GPU deployments where local access is comparatively easy to obtain. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so there is no evidence of confirmed active exploitation.
Local privilege escalation, code execution, denial of service, and information disclosure affect Linux hosts running NVIDIA vGPU Virtual GPU Manager because of an out-of-bounds read in the kernel-mode layer that services vGPU requests. A low-privileged local account or existing code-execution context (CVSS PR:L) is required, and no user interaction is needed, but the flaw is not remotely reachable and only impacts hosts with the vGPU Manager component installed. No public exploit or proof-of-concept has been identified at time of analysis, and EPSS data was not provided; the independent assessment rates this as a moderate, locally-scoped risk.
Local privilege escalation in NVIDIA vGPU Virtual GPU Manager for Linux stems from an out-of-bounds read in firmware (CWE-125) that a low-privileged local attacker can trigger with no user interaction and low complexity. The CVSS 3.1 score is 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), reflecting high confidentiality, integrity, and availability impact on vGPU/VDI/cloud-GPU hosts that use the affected Linux Virtual GPU Manager. No public exploit was identified at time of analysis, and exploitation requires an existing local foothold; it is not remotely exploitable despite the RCE tag.
Local attackers with low privileges on a Linux host running NVIDIA vGPU Virtual GPU Manager can trigger an out-of-bounds read in the kernel-mode layer, potentially leading to code execution, privilege escalation, denial of service, information disclosure, and data tampering. The flaw is not remotely reachable and affects only virtualization, VDI, or cloud-GPU hosts that run the vGPU Manager. No public exploit code or active exploitation has been identified at time of analysis.
Out-of-bounds read in NVIDIA vGPU Virtual GPU Manager for Linux allows a local authenticated attacker with low privileges to potentially achieve code execution, denial of service, or information disclosure. The vulnerability resides in the kernel-mode driver and affects both the vGPU Manager and guest driver components. No public exploit code has been identified, and the flaw is not known to be actively exploited. Integrity impact is assessed as low, but confidentiality and availability impacts are high, making this a significant risk in multi-tenant vGPU deployments.
An out-of-bounds read in the kernel-mode layer of the NVIDIA vGPU Virtual GPU Manager for Linux lets a local attacker who can already reach the vGPU kernel interface trigger memory reads past the bounds of an allocated buffer, potentially yielding information disclosure, data tampering, privilege escalation, denial of service, or kernel code execution. The flaw is rated CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning it is only reachable by an authenticated local principal - a low-privileged user or a guest context on the hypervisor - and not by an unauthenticated remote network attacker. Exposure is limited to hosts that actually deploy NVIDIA vGPU on Linux (VDI and cloud-GPU virtualization platforms), where the highest-impact scenario is a multi-tenant deployment in which the over-read crosses tenant isolation boundaries; no public exploit code or CISA KEV entry was identified at time of analysis, so this is a genuine but not emergency-grade issue warranting scheduled patching.
An out-of-bounds write in the NVIDIA Virtual GPU Manager (vGPU plugin) for Linux allows a user who already holds a low-privileged account inside a guest VM to corrupt host-side memory by sending a crafted RPC message whose performance-state list size parameters are invalid, potentially yielding code execution, privilege escalation, data tampering, denial of service, or information disclosure across the virtualization boundary. The defect is locally triggered (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) and requires no user interaction, but it is only reachable on hosts actually running the vGPU Manager for multi-tenant vGPU/VDI/cloud-GPU workloads - single-tenant systems without vGPU virtualization are not exposed through this guest-to-host path. No public exploit has been identified at time of analysis and the issue is not confirmed as actively exploited (CISA KEV); exploitability is constrained by the need for prior guest authentication and the presence of the vGPU component, making this a contained but genuine virtualization-trust-boundary flaw rather than a broad remote threat.
Out-of-bounds read (CWE-125) in the kernel-mode layer of NVIDIA's vGPU Virtual GPU Manager for Windows and Linux allows a low-privileged process inside a guest VM to force the host-side vGPU driver to read past the end of an allocated buffer (CVSS 3.1 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), primarily exposing host memory contents and creating crash and denial-of-service risk, with code execution and privilege escalation described by the vendor only as possible rather than demonstrated. The issue is reachable only on hosts actively running vGPU configurations such as VDI or cloud GPU hosting where an attacker already holds a foothold inside a guest; bare-metal and non-vGPU installations are not affected, and no user interaction or network reach is required. No public exploit code or confirmed active exploitation has been identified at time of analysis, and no fixed driver version appears in the available intelligence, so defenders should treat patch confirmation through NVIDIA's advisory as the priority action.
An out-of-bounds write in NVIDIA vGPU Manager's GPU System Processor (GSP) plugin lets an authenticated user inside a guest VM hit host-side plugin code with a specially crafted RPC message, potentially yielding code execution, privilege escalation, data tampering, denial of service, or information disclosure in the virtualization host stack. The practical barrier is an existing foothold in an authorized vGPU guest rather than network reachability, and no public exploit code has been identified at time of analysis. Scoring 7.8 under CVSS 3.1 (AV:L/AC:L/PR:L/UI:N, with high confidentiality, integrity, and availability impact) it represents a Moderate, locally-scoped risk that matters most in multi-tenant vGPU deployments where guest-to-host isolation is a core control.
Improper access through a buffer shared between a guest VM and the host in NVIDIA Virtual GPU Manager's GPU System Processor (GSP) tracing component (CWE-367, time-of-check-to-time-of-use) can lead to code execution, privilege escalation, data tampering, denial of service and information disclosure on the affected host. Exploitation is local rather than network-facing: the attacker must already hold user-level code execution inside a vGPU-attached guest VM and must additionally win a timing-dependent race against the host-side tracing path (CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H per independent assessment). No public exploit code and no confirmed active exploitation were identified at time of analysis, so practical risk is concentrated on multi-tenant vGPU, VDI and cloud-GPU hosts that run untrusted guests rather than single-tenant hosts with trusted workloads.
An out-of-bounds write in the kernel-mode layer of the NVIDIA vGPU Virtual GPU Manager for Windows and Linux allows a local attacker holding low privileges to corrupt kernel memory and potentially achieve code execution, privilege escalation, denial of service, information disclosure, and data tampering (CVSS 3.1 base 7.8). The flaw is local-only (AV:L) and requires an existing low-privileged foothold (PR:L) with no user interaction (UI:N); there is no public exploit identified at time of analysis and the package is not listed in CISA KEV. Although the numeric score is High, practical risk is assessed as MODERATE because exploitation demands local code execution on a host that specifically runs the vGPU manager - a component found in vGPU/VDI and cloud-GPU deployments rather than ordinary consumer driver installs.
Missing authorization in the NVIDIA vGPU GPU kernel driver lets a low-privileged user inside a guest VM reach privileged host GPU resources on Windows and Linux hosts, giving up to code execution, privilege escalation, data tampering, denial of service, and information disclosure on the hypervisor-side GPU stack. Exploitation requires local code execution within a guest (CVSS AV:L, PR:L, UI:N) in a vGPU deployment, so it is a realistic escalation primitive for tenants of shared-GPU, VDI, and cloud desktops rather than an internet-facing issue. No public exploit identified at time of analysis; risk is operator-context-dependent, but the high CIA impact and easy automation make prioritization relevant wherever untrusted tenants share vGPU capacity. Authentication requirements are confirmed as low-privileged/authenticated (CVSS vector PR:L).
Local privilege escalation in NVIDIA GPU Display Driver for Windows and Linux can be achieved by an unprivileged local user through the open-source kernel module's DMA-BUF import path, where importing a read-only buffer from another device's DMA-BUF exporter improperly preserves memory access permissions. Successful exploitation can result in code execution, privilege escalation, denial of service, information disclosure, and data tampering, with CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). No public exploit identified at time of analysis, and no CISA KEV entry is present in the provided data.
Local privilege escalation and kernel-level code execution in the NVIDIA GPU Display Driver for Windows and Linux, where the kernel-mode layer follows an error-handling path that operates on an improperly initialized resource (CWE-908). The flaw is reachable by an authenticated, low-privileged local user (CVSS 3.1: AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8 HIGH) on any host where the affected driver is installed and loaded, granting full confidentiality, integrity, and availability impact within the kernel-mode driver's scope. No public exploit code has been identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV); risk is concentrated on shared multi-tenant GPU hosts such as VDI, cloud GPU instances, and vGPU guests where untrusted local users coexist with the driver, and success may be probabilistic because the attacker must reliably trigger the failing error path.
Local privilege escalation in the NVIDIA GPU Display Driver for Linux (open-source kernel module variant) allows any unprivileged local user with an account on the host to abuse a DMA mapping code path where memory access permissions are not properly preserved, potentially yielding code execution, privilege escalation, denial of service, information disclosure, or data tampering. The vulnerability is rated CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning exploitation requires only local access, no user interaction, and no elevated privileges to trigger, but it is confined to systems running the open-source kernel module - the proprietary module is not affected. There is no public exploit identified at time of analysis and no CISA KEV listing; risk is concentrated in multi-user, VDI, cloud-GPU, and HPC hosts where untrusted local users share GPU-equipped machines.
Local privilege escalation in the NVIDIA GPU Display Driver's open-source kernel module lets an unprivileged local user trigger a use-after-free in the Resource Server map cleanup path via a missing self-reference guard, yielding code execution, privilege escalation, denial of service, information disclosure and data tampering (CVSS 3.1 7.8, AV:L/AC:L/PR:L/UI:N, CWE-416). Affected are Windows and Linux hosts running the open-source kernel module variant of the driver, spanning GeForce, RTX/Quadro/NVS and Tesla product lines per the published CPEs; exploitation requires only a normal local account and no user interaction, but is strictly local with no network vector. No public exploit code or confirmed active exploitation (CISA KEV) was identified at time of analysis, and the practical risk is highest in shared or multi-tenant GPU environments (vGPU, VDI, cloud GPU) where gaining kernel-level control of the GPU driver crosses a meaningful tenant boundary.
Use-after-free in the NVIDIA GPU Display Driver for Linux allows a local, unprivileged user to corrupt driver memory by racing or abusing object lifetime handling, with a successful exploit potentially yielding code execution in kernel context, privilege escalation to root, denial of service, information disclosure, and data tampering. The flaw scores 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and is confined to local attackers who already hold an account on the GPU host, with no network vector and no user interaction required. This is a genuine but not emergency-grade issue: no public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, so realistic exposure is concentrated on shared or multi-tenant GPU systems - VDI desktops, cloud GPU instances, and HPC nodes - where untrusted users share a single driver instance.
An integer underflow (CWE-191) in the kernel-mode component of the NVIDIA GPU Display Driver for Windows lets a local, authenticated low-privileged user corrupt kernel memory in a way that can lead to code execution, privilege escalation, denial of service, information disclosure, or data tampering (CVSS 3.1: 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The issue affects the GeForce, RTX/Quadro/NVS and Tesla Windows driver branches and is not network-reachable, so an attacker must already be able to run code as a normal user on the host. There is no public exploit identified at time of analysis and no CISA KEV listing; the practical risk is concentrated on multi-user, VDI and cloud-GPU hosts where an unprivileged tenant shares the same machine as the vulnerable driver, while single-user desktops where the attacker must already hold a foothold face lower marginal risk.
Type confusion in the kernel-mode component of the NVIDIA GPU Display Driver for Windows allows a local attacker who already holds low-privileged code execution to corrupt kernel memory and potentially escalate to SYSTEM, crash the machine (BSOD/DoS), disclose kernel memory, or tamper with data. The issue is rated CVSS 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning the attacker must be local and authenticated with low privileges and no user interaction is required, and it affects the GeForce, RTX/Quadro/NVS and Tesla Windows driver branches. No public exploit code and no confirmed active exploitation were identified at time of analysis, so this is an access-gated local privilege-escalation risk rather than a remotely reachable mass-exploitation threat.
Local privilege escalation in NVIDIA Display Driver on Windows allows an authenticated low-privileged user to trigger a use-after-free in the kernel-mode driver, potentially enabling code execution with SYSTEM privileges, denial of service, information disclosure, or data tampering. The vulnerability requires local access and high attack complexity (AC:H) due to race conditions or kernel-pool reclamation, making reliable exploitation non-trivial, and it is not known to be actively exploited. The highest risk is in shared multi-user, VDI, or cloud-GPU environments where crossing a trust boundary from low-privileged user to kernel is significant.