Remote Code Execution

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, code execution, denial of service, information disclosure, and data tampering are possible in NVIDIA GPU Display Driver for Linux due to a use-after-free in the open-source kernel module's event-delivery path. An authenticated local user with access to NVIDIA GPU device nodes can race asynchronous event delivery against file close (CVSS 7.0, AV:L/AC:H/PR:L/UI:N), though the high attack complexity makes success non-deterministic and typically requires repeated attempts; no public exploit has been identified at time of analysis. Risk is concentrated on Linux hosts using the affected open-source kernel module, particularly multi-tenant vGPU, VDI, and cloud GPU deployments.

Local privilege escalation in the NVIDIA GPU Display Driver for Linux kernel-mode layer allows an already-present local user or code-execution foothold (PR:L) to write to memory that should be read-only because memory permissions are not preserved, potentially achieving code execution and elevated privileges on affected GeForce, RTX/Quadro/NVS, and Tesla systems, including vGPU Guest Driver deployments. Exploitation requires local access and high attack complexity, with no remote or unauthenticated network path; no public exploit was identified at time of analysis and the CVE is not listed in CISA KEV. The vendor-supplied CVSS vector uses AV:P while our independent assessment uses AV:L, so the physical-access requirement should be confirmed against NVIDIA bulletin 5861.

Out-of-bounds write in the NVIDIA GPU Display Driver for Windows kernel module can let a local, authenticated low-privileged user execute code, escalate privileges, cause denial of service, disclose information, or tamper with data on affected GeForce, RTX/Quadro/NVS, and Tesla systems. Exploitation requires local access to the GPU-equipped Windows host plus a low-privileged account able to reach the kernel module, and the high attack complexity means it is not reliably one-shot; multi-user, VDI, and cloud/virtual-GPU environments are the main risk. No public exploit identified at time of analysis, and CVSS is 7.0 with high confidentiality, integrity, and availability impact.

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.

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.

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 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.

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.

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.

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.

Incorrect buffer size calculation in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows allows a local attacker who already holds low-privileged code execution on the host to escalate to kernel-level privileges, with downstream risk of code execution, denial of service, information disclosure, and data tampering. The flaw affects GeForce, RTX/Quadro/NVS, Tesla data-center, and vGPU/Virtual GPU Manager drivers, and rates CVSS 3.1 base 7.8 (AV:L/AC:L/PR:L/UI:N) - it is strictly local, not remotely triggerable, so exposure is limited to shared workstations, multi-tenant vGPU/VDI environments, and cloud-GPU nodes where an untrusted party can already run code. No public exploit code or confirmed active exploitation was identified at time of analysis.

Local privilege escalation in NVIDIA GPU Display Driver for Windows allows an authenticated attacker with low-privileged code execution to exploit an integer overflow (CWE-190) in the kernel module, potentially achieving code execution, denial of service, information disclosure, and data tampering. The flaw requires local access (AV:L) and low privileges (PR:L) with no user interaction, affecting systems with GeForce, RTX/Quadro/NVS, or Tesla drivers. No public exploit code or active exploitation has been identified at the time of analysis; the CVSS 3.1 base score is 7.8 (HIGH).

Local code execution and denial of service on Windows systems with affected NVIDIA GPU Display Drivers stem from an integer overflow in the display driver's DIAG escape handler that results in an out-of-bounds write (CWE-787). An unprivileged local user (CVSS PR:L) can trigger the flaw via a device I/O call to the handler; no user interaction is required, and exploitation is confined to the local machine, meaning an attacker must already have a foothold. No public exploit identified at time of analysis (and no CISA KEV entry), but the shared-system impact-multi-user workstations, VDI, and cloud GPU instances-raises the risk profile.

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.

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 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.

A type-confusion flaw in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux lets a local, low-privileged user who can open the driver's device nodes and issue ioctls trigger memory corruption by winning a handle-recycle race, yielding kernel-level code execution, privilege escalation, denial of service, information disclosure and data tampering. Affected platforms are the Linux driver branches covering GeForce, RTX/Quadro/NVS, Tesla/data-center GPUs and the vGPU guest driver and Virtual GPU Manager (CVSS 3.1 base 7.8; our independent assessment rates it AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H, i.e. 7.0, because the race window makes exploitation timing-sensitive rather than deterministic). This is a local privilege-escalation-class issue with no remote vector: no public exploit code was identified at time of analysis and the flaw is not confirmed actively exploited (CISA KEV), though it is most consequential on multi-user, VDI and cloud/virtualized GPU hosts where untrusted tenants share a single driver instance.

A NULL pointer dereference in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux allows a locally present, low-privileged authenticated user to crash the driver - and potentially the kernel - by supplying a crafted request to the kernel-mode driver layer (for example via device ioctls). Affected platforms span the GeForce, RTX/Quadro/NVS, and Tesla driver lines on Linux, and the 'Guest Driver' / 'Virtual GPU Manager' tags indicate the vGPU path is also in scope, so a guest session inside a virtualized vGPU deployment is a valid attack position. The vendor claims the flaw 'might' lead to code execution, privilege escalation, information disclosure, and data tampering, but the reliably achievable outcome is a denial-of-service crash; there is no CISA KEV listing, no EPSS score provided, and no public exploit identified at time of analysis.

Local privilege escalation in NVIDIA GPU Display Driver for Linux allows an unprivileged local user to trigger an out-of-bounds write in kernel memory via a crafted ioctl call with an unvalidated buffer size, enabling code execution, privilege escalation, information disclosure, and denial of service. The flaw affects GeForce, RTX/Quadro/NVS, and Tesla drivers, as well as Guest Driver and Virtual GPU Manager components, with highest risk in multi-tenant GPU environments such as VDI and cloud/HPC deployments. No public exploit identified at time of analysis; CVSS 3.1 score is 7.8 (local, low privileges, no user interaction).

Local privilege escalation in the NVIDIA GPU Display Driver for Linux allows an authenticated unprivileged user to trigger a use-after-free in the kernel mode layer, potentially achieving code execution, denial of service, privilege escalation, information disclosure, and data tampering. The flaw is reachable only by a locally authenticated low-privileged account (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) that can issue ioctls to the GPU kernel-mode device interface; there is no remote attack path and no user interaction is required once a foothold exists. The 'Guest Driver' classification makes the issue most consequential in virtualized/vGPU and multi-tenant datacenter environments, where a low-privileged guest can reach the shared GPU driver. No public exploit identified at time of analysis, and the vendor advisory is the authoritative source for fixed driver versions.

Local privilege escalation in NVIDIA's GPU Display Driver (GeForce, RTX/Quadro/NVS, and Tesla, on both Windows and Linux) allows an authenticated low-privileged local user to reach GPU memory belonging to another process, enabling code execution, escalation of privileges, data tampering, denial of service, and information disclosure. Per the assessed vector (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) there is no remote or network path; the flaw is most consequential on shared, multi-user, VDI, or multi-tenant GPU hosts where cross-process GPU memory isolation is the boundary between users and tenants. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the provided vendor reference points to NVIDIA's product security advisory (2026/5861) rather than a fixed driver version named in this data set.

Local privilege escalation in the NVIDIA GPU Display Driver for Linux kernel mode layer allows an authenticated, unprivileged user to trigger a double-free of imported memory state, potentially leading to code execution, denial of service, information disclosure, and data tampering. The flaw requires local access and a low-privilege account; no public exploit code or active exploitation has been identified at time of analysis. The CVSS 3.1 score is 7.8 (HIGH).

Local privilege escalation, code execution, denial of service, and information disclosure in NVIDIA GPU Display Driver on Windows and Linux stem from an integer overflow (CWE-190) in the kernel-mode layer that an unprivileged user can trigger to cause an out-of-bounds write. Exploitation requires local access with an existing low-privilege account (authenticated, PR:L) on a host with an affected GeForce, RTX/Quadro/NVS, or Tesla driver; the CVSS v3.1 base score is 7.8 (High) with a local attack vector (AV:L/AC:L/PR:L/UI:N). No public exploit code or CISA KEV entry was identified at the time of analysis, but the flaw is genuine and actionable for local privilege escalation if the vulnerable driver interface is reachable.

An out-of-bounds write in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux allows an unprivileged local user to corrupt kernel memory, which can lead to code execution in the kernel, privilege escalation, denial of service, information disclosure, or data tampering. Systems running GeForce, RTX/Quadro/NVS, or Tesla driver packages on either operating system are affected; per the CVSS vector (AV:L, PR:L, UI:N) the flaw is reachable only by a user who already has local code execution on the host, making it a local privilege-escalation primitive rather than a remote entry point. No public exploit has been identified at time of analysis.

Local privilege escalation in NVIDIA GPU Display Driver for Linux stems from a missing authorization check in the kernel mode layer, allowing an unprivileged local user to modify privileged configuration and potentially achieve code execution, escalation of privileges, denial of service, information disclosure, and data tampering. Exploitation requires a pre-existing local low-privileged foothold (CVSS:3.1/AV:L/AC:L/PR:L/UI:N), such as an unprivileged account on a host or inside a guest VM using the NVIDIA guest driver or Virtual GPU Manager, so this is an escalation primitive rather than a remote initial-access vector. No public exploit code is identified and no CISA KEV active exploitation is confirmed at time of analysis, but the high confidentiality, integrity, and availability impacts and broad affected driver families make patching a priority.

Use-after-free in the NVIDIA GPU Display Driver kernel mode layer (Windows and Linux) lets a local user who already holds low-privileged code execution on the host trigger a memory-corruption condition inside the kernel driver, with the potential for code execution, privilege escalation, information disclosure, data tampering, and denial of service. Affected platforms span consumer and professional GPU lines (GeForce, RTX/Quadro/NVS, Tesla) as well as the vGPU components, where a malicious or compromised guest can exercise the vulnerable path through the Guest Driver and Virtual GPU Manager. The attack is strictly local (CVSS:3.1/AV:L/AC:L/PR:L/UI:N, score 7.8), requires no user interaction and no non-default configuration beyond having the driver installed, and there is no public exploit identified at time of analysis - no KEV entry and no proof-of-concept code is referenced in the available data.

Local privilege escalation in NVIDIA GPU Display Drivers for Windows (GeForce, RTX/Quadro/NVS, Tesla, and vGPU) allows an unprivileged local user to execute code in kernel mode by supplying an untrusted pointer that the driver dereferences without validation. Affected hosts include multi-user and virtualized Windows systems with default driver installations, where exploitation can lead to escalation to SYSTEM, denial of service, information disclosure, and data tampering. No public exploit code has been identified at time of analysis, and CISA KEV does not list this CVE; the CVSS 3.1 base score is 7.8 (High).

A locally-triggered out-of-bounds write in the NVIDIA GPU Display Driver kernel-mode layer lets an attacker who already holds low-level privileges on a Windows or Linux host corrupt kernel memory, with the potential for code execution in kernel context, escalation of privileges, denial of service, information disclosure and data tampering. The affected driver ships by default across the GeForce, RTX/Quadro/NVS, Tesla and Virtual GPU Manager product lines, so any host with a current NVIDIA driver installed is in scope, but exploitation is not remote: an attacker must first obtain code execution on the target (an authenticated local user, a compromised low-privileged process, or sandboxed code with driver access) and then develop a reliable kernel corruption exploit. CVE-2026-47548 carries a vendor/NVD CVSS 3.1 vector of AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8, High); no public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV.

Local attackers with low-privileged code execution can trigger an out-of-bounds read (CWE-125) in the kernel-mode layer of the NVIDIA GPU Display Driver on Windows and Linux, which may lead to escalation of privileges, code execution, denial of service, information disclosure, and data tampering. This locally exploitable flaw (CVSS 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) affects GeForce, RTX/Quadro/NVS, Tesla, and Virtual GPU Manager products, and no public exploit has been identified at the time of analysis. A vendor advisory with remediation guidance is available from NVIDIA via its product security page.

Integer underflow in the kernel-mode layer of NVIDIA GPU Display Driver for Windows and Linux allows a local attacker with low privileges to potentially achieve code execution, denial of service, privilege escalation, information disclosure, and data tampering. The flaw affects GeForce, RTX/Quadro/NVS, Tesla, and vGPU Manager products, and exploitation requires local access (CVSS AV:L) with no user interaction (UI:N) but low privileges (PR:L). No public exploit code has been identified at time of analysis, and there is no indication of active exploitation.

An out-of-bounds write in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux allows a local, low-privileged authenticated user to corrupt kernel memory, with the potential to escalate privileges to kernel-level code execution, crash the system (denial of service), disclose information, or tamper with data. The flaw rates CVSS 3.1 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning exploitation requires pre-existing code execution as a standard user on a host with the driver loaded, but no user interaction and no non-default configuration; the vulnerable kernel-mode layer ships and loads by default once the driver is installed. There is no confirmed active exploitation (not in CISA KEV) and no public exploit identified at time of analysis, but the affected GeForce, RTX/Quadro/NVS, and Tesla product families are extremely widely deployed, making this a genuine high-priority patch-management item rather than an emergency.

Local attackers with low privileges can exploit an uninitialized pointer access flaw (CWE-824) in the firmware of NVIDIA Display Driver for Windows and Linux to achieve code execution, denial of service, privilege escalation, information disclosure, or data tampering. The vulnerability requires local access (AV:L) and authenticated low-privilege credentials (PR:L); no public exploit identified at time of analysis. Affected products include GeForce, RTX/Quadro/NVS, and Tesla product lines, including vGPU Manager deployments.

An out-of-bounds write in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux lets a local attacker who already holds low-privilege code execution corrupt kernel memory, with potential outcomes of privilege escalation, arbitrary code execution, denial of service, information disclosure and data tampering (CWE-787, CVSS 7.8). The assessed vector CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H shows low attack complexity and no user interaction, but the attack is strictly local: an attacker must first have a foothold on the host, or on a guest in a vGPU configuration, which confines it to privilege-escalation and sandbox-escape scenarios rather than remote mass exploitation. No public exploit code and no confirmed active exploitation were identified at time of analysis (no public exploit identified at time of analysis), so this is a genuine local privilege-escalation priority despite the absence of exploitation signals, and it warrants prompt patching on endpoint, workstation, and multi-tenant virtual-desktop estates.

A use-after-free (CWE-416) in the NVIDIA GPU Display Driver for Windows and Linux lets a local unprivileged user free and then re-reference a driver-managed memory object, potentially yielding code execution in kernel context, privilege escalation, data tampering, denial of service, and information disclosure. The flaw is rated CVSS 3.1 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) and affects GeForce, RTX/Quadro/NVS, and Tesla product lines; the 'Guest Driver' tag indicates the vulnerable path may also be reachable from inside a virtualized guest, making guest-to-host or guest-context escalation a relevant scenario. Exploitation requires that the attacker already hold a local foothold with normal user privileges on a host with the affected driver installed and the GPU device interface exposed - there is no remote/network vector - and at time of analysis no public exploit code and no confirmed active exploitation have been identified, so this is a priority local privilege-escalation issue rather than an imminent, opportunistically exploited threat.

Local kernel stack memory disclosure in NVIDIA GPU Display Driver for Windows and Linux allows an attacker who already has low-privilege authenticated code execution on the host to read kernel stack contents such as return addresses and pointers. Affected installations include GeForce, RTX/Quadro/NVS, and Tesla driver configurations, and the independent assessment rates the flaw as AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, meaning high confidentiality impact without confirmed integrity or availability impact. No public exploit is identified at time of analysis, and no CISA KEV active exploitation is reported.

An out-of-bounds read in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux allows a local, low-privileged user to read beyond the bounds of kernel heap memory, producing information disclosure and denial of service, with potential for privilege escalation, code execution, and data tampering if the read primitive is successfully leveraged. The flaw affects GeForce, RTX/Quadro/NVS, and Tesla product families on systems with the vulnerable driver branch installed, and exploitation requires an attacker to already hold local access to the host (per the assessed CVSS:3.1/AV:L/AC:L/PR:L/UI:N vector, base 7.8), with no user interaction needed. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV, so exploitation is currently expected to require a motivated local attacker rather than being broadly weaponized.

An out-of-bounds read in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux lets a local attacker who already holds a low-privileged execution context on the host read past the bounds of a kernel buffer, exposing kernel memory contents and creating a pathway toward further privilege escalation or data tampering. Exploitation is constrained to the local attack surface: the attacker must already be able to run code on the machine (AV:L, PR:L) and no user interaction or network path is involved, so despite the 7.8 headline score the practical risk is a local privilege/information-disclosure concern rather than a remotely reachable, mass-exploitable flaw. There is no confirmed active exploitation (not listed in CISA KEV) and no public exploit code identified at time of analysis; the affected hardware spans GeForce, RTX/Quadro/NVS, and Tesla products, with an NVIDIA vendor advisory available.

Local privilege escalation in the NVIDIA GPU Display Driver kernel-mode layer allows a user with standard privileges to trigger an out-of-bounds write in kernel memory, potentially achieving kernel-level code execution, denial of service, information disclosure and data tampering. The affected driver branches span NVIDIA GeForce, RTX/Quadro/NVS and Tesla families on both Windows and Linux, and the 'Guest Driver' tag indicates virtualized/vGPU and guest-VM driver deployments are also in scope, which matters for GPU-accelerated VDI and datacenter estates. Exploitation is constrained to the host: the CVSS 3.1 vector is AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8), so an attacker must already have a foothold and the ability to run code as a low-privileged local user; no public exploit code and no confirmed active exploitation were identified at time of analysis.

Local privilege escalation in NVIDIA GPU Display Driver for Windows and Linux allows a low-privileged local user to trigger an integer overflow in the kernel mode layer, resulting in an out-of-bounds write to GPU memory that can lead to code execution, denial of service, escalation of privileges, information disclosure, and data tampering. Affected platforms include GeForce, RTX/Quadro/NVS, and Tesla drivers, with the 'Guest Driver' tag indicating that VM guests with GPU access are also in scope for guest-to-host or in-guest escalation. No public exploit code or confirmed active exploitation (CISA KEV) has been identified at time of analysis, and the CVSS 3.1 score is 7.8 (AV:L/PR:L/UI:N).

Local privilege escalation in NVIDIA GPU Display Driver for Windows and Linux allows a low-privileged user to trigger an incorrect conversion between numeric types in the kernel mode layer, potentially leading to code execution, denial of service, escalation of privileges, information disclosure, and data tampering. The vulnerability requires local access and low-level privileges (CVSS vector PR:L) with no user interaction, and it is not remotely exploitable. No public exploit code has been identified at time of analysis, but the risk is materially higher on shared or multi-tenant GPU hosts such as VDI, vGPU, or Tesla datacenter deployments where untrusted users can reach the driver.

Local privilege escalation in the NVIDIA GPU Display Driver for Windows and Linux lets a low-privileged local user trigger an out-of-bounds array access in the kernel mode layer, potentially yielding code execution in kernel context, denial of service, escalation of privileges, information disclosure and data tampering. The assessed CVSS 3.1 vector is AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8), meaning the attack is strictly local and requires only low-privileged authenticated code on the host, with no user interaction and low complexity - so any unprivileged process able to reach the affected kernel-mode interface on a system running GeForce, RTX/Quadro/NVS or Tesla drivers (or a vGPU host reachable from a guest) can attempt it. There is confirmed actively exploited (CISA KEV) status: no - the CVE is not in KEV and no public exploit code has been identified at time of analysis, so early patching is key while exploitation activity has not yet been observed.

Local privilege escalation in the NVIDIA GPU Display Driver for Windows allows a low-privileged local user - or a sandboxed process or guest with access to the driver interface - to trigger a use-after-free in the kernel-mode layer, potentially achieving kernel code execution, privilege escalation, denial of service, information disclosure, or data tampering. The assessed vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) means the attacker must already have code running on a host with an affected NVIDIA driver installed, but needs no user interaction and faces low complexity once local access exists; per the affected CPEs, the GeForce, RTX/Quadro/NVS, and Tesla branches are in scope, and the associated Guest Driver and Virtual GPU Manager tags mean a virtual-GPU guest may also be able to reach the kernel layer. No public exploit code or confirmed active exploitation was identified at the time of analysis, and hosts without an NVIDIA GPU/driver installed are unaffected.

Local code execution, privilege escalation, denial of service, information disclosure, and data tampering are possible on Linux systems running vulnerable NVIDIA GPU Display Drivers (GeForce, RTX/Quadro/NVS, and Tesla branches) because of a type-confusion flaw (CWE-843) in the outdated embedded cryptographic library used by the NGX updater. The assessed profile is CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (7.8): an attacker who already holds a low-privileged local account can reach the vulnerable updater code path, with no user interaction required and low complexity, but the flaw is not remotely reachable, so shared and multi-user hosts (VDI, HPC/Tesla compute clusters, and workstations with untrusted local users) are the realistic risk surface. No public exploit code has been identified at time of analysis, and the exact affected and fixed driver versions must be confirmed from NVIDIA's advisory.

Integer overflow in the kernel-mode layer of NVIDIA vGPU Virtual GPU Manager can be triggered by a low-privileged user inside a guest VM, causing memory corruption with high confidentiality, integrity, and availability impact. The vulnerability affects vGPU deployments on Windows and Linux hosts across GeForce, RTX/Quadro/NVS, and Tesla driver branches, and successful exploitation could enable code execution, denial of service, privilege escalation, information disclosure, or data tampering. No public exploit code or active exploitation has been identified in the provided intelligence at time of analysis.

Local privilege escalation in the NVIDIA GPU Display Driver for Linux allows an authenticated, low-privileged user to drive an out-of-bounds write in the driver's kernel-mode layer by supplying mismatched memory buffers during event buffer setup, with a successful exploit potentially leading to kernel code execution, denial of service, privilege escalation, information disclosure, and data tampering (CVSS 3.1 base 7.8, AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The affected code is the Linux kernel-mode component shipped with GeForce, RTX/Quadro/NVS and Tesla driver packages, and the same path can be reached by untrusted code inside a guest VM using the NVIDIA vGPU guest driver on a host running the Virtual GPU Manager. No public exploit code was identified and there is no confirmed active exploitation (CISA KEV) at time of analysis; the bug is local-only, requiring the attacker to already run code with at least low privileges on the host or in a guest, and it is not remotely reachable.

Local privilege escalation in the NVIDIA GPU Display Driver kernel-mode layer lets an attacker who already holds low-privileged code execution on a Windows or Linux host - including code running inside a vGPU guest VM - drive the driver into an error path that mishandles reference counts, producing a use-after-free. The corrupted object is kernel memory, so successful exploitation can yield code execution, escalation of privileges, denial of service, information disclosure, and data tampering (CVSS 7.8, AV:L/AC:L/PR:L/UI:N); it is not remotely reachable and requires a vulnerable driver version to be installed. The GeForce, RTX/Quadro/NVS, and Tesla driver families are in scope, and no public exploit code has been identified at the time of analysis.

Local privilege escalation in the NVIDIA GPU Display Driver for Linux lets an already-authenticated, low-privileged user trigger a format string defect (CWE-134) and potentially achieve code execution, privilege escalation, data tampering, denial of service, and information disclosure; NVIDIA rates it 7.8 (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H). The attack surface is strictly local - there is no remote vector - so real risk concentrates on multi-user and multi-tenant GPU systems such as HPC clusters, ML/AI training nodes, shared engineering workstations, and cloud GPU instances, where a low-privileged tenant could reach the driver while other users' data and the host remain in scope. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV; the impact rating of total confidentiality, integrity, and availability loss is consistent with memory corruption inside a privileged driver context.

Local privilege escalation and kernel memory-safety compromise on Linux systems running NVIDIA GPU Display Drivers allow an unprivileged local user to cause improper release of kernel-mode memory resources, leaving a mapping accessible after the underlying memory has been reused. The flaw affects GeForce, RTX/Quadro/NVS, and Tesla driver lines and carries 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), meaning an attacker who already holds a local login can potentially achieve code execution, denial of service, information disclosure, privilege escalation, and data tampering without user interaction. No public exploit has been identified at time of analysis and the issue is not confirmed as actively exploited, but the local-only vector makes it most dangerous on shared or multi-tenant GPU hosts where one unprivileged tenant could compromise the kernel and other workloads.

Local privilege escalation and memory-protection bypass in NVIDIA GPU Display Driver for Linux allows an unprivileged local user to execute code at higher privilege, tamper with data, disclose information, or cause denial of service. The flaw is in the kernel-mode layer and affects GeForce, RTX/Quadro/NVS, Tesla, and vGPU Guest Driver/Virtual GPU Manager deployments, with a CVSS 3.1 score of 7.8 (AV:L/AC:L/PR:L/UI:N). No public exploit identified at time of analysis, and no CISA KEV active-exploitation signal is present; the assessed attack path requires prior local access on the host or inside a vGPU guest.

Unauthenticated remote attackers can execute arbitrary code in JetBrains YouTrack before 2026.2.19197 by abusing an authorisation bypass in the scripts debugger, a CVSS 3.1 9.8 flaw (PR:N/UI:N, scope unchanged, confidentiality/integrity/availability all High). Real-world urgency is low despite the score: EPSS is 0.36% (28th percentile), no public exploit code has been identified at time of analysis, CISA SSVC reports Exploitation: none, and there is no KEV listing. Exposure depends on deployment - the debugger endpoint being unreachable, behind an authenticating proxy, or disabled materially lowers risk - and a vendor fix is available in 2026.2.19197.

Remote code execution in JetBrains TeamCity (CVE-2026-100253) lets an authenticated attacker with permission to edit a project's versioned settings escape the Kotlin DSL sandbox and execute code on the TeamCity server. Affected versions are those before 2026.2, before 2026.1.4, and before 2025.11.8. No public exploit identified at time of analysis, but this is a genuine high-priority issue rather than an inflated CVSS score because it can compromise a CI/CD server; exploitation requires a low-privileged, non-anonymous account able to supply or commit malicious Kotlin DSL settings.

Unauthenticated remote code execution in OrdaSoft Joomla CCK (all versions below 8.3.16) lets any remote attacker who can reach the component's frontend upload and execute arbitrary PHP, resulting in full compromise of the Joomla site - the CVSS 4.0 base score is 10.0 and the independent CVSS 3.1 assessment is AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H. The upload endpoint site/uploader.php is reachable through the component's normal frontend routing via task=getContent with no authentication or ACL check anywhere in the dispatch chain, and the shipped source has its file-extension allow-list commented out, so an image/PHP polyglot carrying an attacker-chosen .php extension passes the magic-byte MIME check and is written to an executable path under the Joomla web root. Exploitation requires no privileges, no user interaction, and no non-default configuration - only that the extension be installed and its frontend be web-reachable; the supplied CVSS v4.0 vector carries E:A (Exploit Maturity: Attacked), although no CISA KEV entry was supplied in the available intelligence, so that metric is the sole exploitation signal available here.

Unauthenticated remote code execution affects LightLLM through 1.2.0 when it is deployed in visual_only (multimodal/vision) mode, which exposes an RPyC inference service that performs no authentication and unpickles the arguments passed to its remote_infer_images method. Any attacker who can reach that visual RPyC port can send a crafted object whose __reduce__ method runs on the server, achieving code execution with the privileges of the LightLLM service account and resulting in high confidentiality, integrity, and availability impact (CVSS 4.0 base 9.3; independently assessed as CVSS 3.1 AV:N/AC:L/PR:N/UI:N with high C/I/A). Text-only LightLLM deployments do not expose the affected service, no public exploit code has been identified at time of analysis, and real-world exposure hinges on whether the visual RPyC port is bound to an untrusted-reachable interface rather than to localhost or an isolated network.

Remote code execution in the CartFlows WordPress plugin affects versions 3.2.0 and earlier, allowing an authenticated user with Contributor role or higher to execute arbitrary code on the hosting server. The flaw is a PHP include/require path-control weakness (CWE-98) with a CVSS 3.1 score of 8.8 (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), meaning exploitation requires a valid low-privileged account but no user interaction. No public exploit was identified at time of analysis, and the practical exposure depends on whether the site grants Contributor access to untrusted users.

Unauthenticated remote code execution in the SiteSkite WordPress plugin through version 2.1.8 lets any remote attacker run arbitrary code on an affected site with no credentials, no user interaction, and no special configuration required (CVSS 10.0, vector PR:N/UI:N/AC:L, scope changed). The underlying weakness is a CWE-94 code injection flaw, and because the plugin is a niche one, the realistically exposed population is small and exploitation is more likely to be opportunistic scanning than broad mass exploitation. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but the intrinsic severity is high - a single successful request can hand an attacker full control of the WordPress installation and its host context.

Unauthenticated remote code execution in the AcyMailing SMTP Newsletter WordPress plugin (versions 11.0.5 and earlier) allows a remote attacker to execute arbitrary code on the underlying server, leading to full site compromise. The CVSS 3.1 base score is 9.0 (AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:H), indicating no authentication or user interaction is required, though the high attack complexity (AC:H) signals that reliable exploitation likely depends on a specific precondition, application state, or configuration that the attacker must arrange or wait for. No public exploit code is currently identified, and the vulnerability is not listed in CISA KEV.

Unauthenticated remote code execution affects Digiwin EasyFlow .NET, which deserializes attacker-supplied serialized content on the server without validating the incoming type information (CWE-502). Any network-reachable instance can be compromised by a remote attacker with no credentials and no user interaction, per the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H) and the independent assessment (CVSS 3.1 9.8, S:U/C:H/I:H/A:H), yielding full confidentiality, integrity, and availability impact. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV; practical exposure is instead bounded by whether the EasyFlow .NET service is internet-facing and by the product's predominantly regional (Taiwan) install base, though the attacker must first know or discover the endpoint that accepts the serialized payload.

Authenticated administrative users of Digiwin EasyFlow .NET can exploit an arbitrary file upload vulnerability to place and execute .NET web shell backdoors, achieving remote code execution on the server. The CVSS 4.0 base score is 8.6, but the high privilege requirement (PR:H) confines risk to insider threats or cases where admin credentials are already compromised. No public exploit or confirmed active exploitation exists at time of analysis.

An out-of-bounds write (CWE-787) in Pgpool-II, the PostgreSQL connection pooler, allows an authenticated attacker who already holds valid low-privileged credentials to cause abnormal termination of the Pgpool-II process or, depending on memory layout and build hardening, to achieve arbitrary code execution. Affected branches span 3.5.x through 4.2.x as well as 4.3.0-4.3.20, 4.4.0-4.4.17, 4.5.0-4.5.12, 4.6.0-4.6.7 and 4.7.0-4.7.2; exploitation is remote (AV:N), low complexity and requires no user interaction, but the PR:L authentication prerequisite makes this a post-authentication flaw rather than an unauthenticated internet-facing one. The vendor score is 8.7 (CVSS 4.0) and the independent assessment maps it to 8.8 (CVSS 3.1, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); no public exploit code has been identified at time of analysis and there is no CISA KEV listing confirming active exploitation.

Code execution in BcAddonMigrator 5.2.0 and earlier allows an authenticated administrative user to run arbitrary PHP by supplying a baserCMS4-style addon package whose config.php holds attacker-controlled code. The migration routine BcAddonMigrator5Component::migrateAddonConfig calls PHP's include on the uploaded config.php, so the file's contents execute with the web server's privileges during conversion, and the same code path can read or delete arbitrary files on the host. The CVSS 4.0 base score is 8.6, but the decisive limiting factor is PR:H - the attacker must already hold administrator rights - and no public exploit code or CISA KEV entry was identified at the time of analysis.

Local file inclusion in the Simply Schedule Appointments WordPress plugin (all versions up to and including 1.6.12.27) allows remote attackers to include and execute arbitrary .php files present on the server via the 'ssa_locale' GET parameter, enabling access-control bypass, disclosure of sensitive data, and PHP code execution whenever attacker-controlled .php content can be placed on the host. The published CVSS 3.1 base score is 7.5 (AV:N/AC:H/PR:L/UI:N/S:U/C:H/I:H/A:H), but our independent assessment rates the vector as PR:N (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H), because the locale filter in class-translation.php is registered unconditionally during plugins_loaded and its callback returns the raw 'ssa_locale' parameter without any nonce or capability check, so the subscriber-level authentication requirement in the published vector is not a genuine barrier in practice. High attack complexity reflects the fact that including an already-present .php file yields information disclosure or access-control bypass, while executing attacker-supplied PHP additionally requires an upload feature or writable path that can host a .php file; no public exploit code has been identified at time of analysis, and there is no CISA KEV entry indicating confirmed active exploitation.

Unauthenticated arbitrary file upload in the Zella WordPress theme before version 2.6.3 lets remote attackers write arbitrary files - including PHP - into the site by abusing a font upload action that performs no capability or nonce check, yielding full remote code execution with a CVSS base score of 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Every WordPress installation running this theme at a version below 2.6.3 in its default configuration is exposed; no login, user interaction, or non-default setting is required. No public exploit code has been identified at time of analysis and there is no CISA KEV entry, but CISA's SSVC assessment flags the flaw as fully automatable with total technical impact, so rapid weaponization should be assumed. The vendor has released a fix in version 2.6.3.

Unauthenticated remote code execution in Pexip Infinity Conferencing Nodes (CVSS 9.8, AV:N/AC:L/PR:N/UI:N) allows an attacker who can reach the node over the network to run arbitrary code as an unprivileged service account by sending crafted input that triggers an out-of-bounds write. Affected builds are all versions before 38.2 as well as 39.0, 39.1 and 40.0; a fixed 38.2 release and corresponding maintenance releases are referenced in Pexip's security bulletins. No public exploit code has been identified at time of analysis and the flaw is not confirmed actively exploited (no CISA KEV listing), but exploitation requires no authentication, no user interaction and no special conditions, and the resulting code execution is unprivileged - full host takeover would require chaining a separate local privilege-escalation bug such as sibling CVE-2026-103106.

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.

Improper access control in Pexip Infinity's product-internal, inter-node API lets an attacker who already holds a foothold on one node of a multi-node deployment execute arbitrary code as an unprivileged user on another node. The affected builds are Infinity before 38.2 as well as 39.0, 39.1 and 40.0, tracked as CPE cpe:2.3:a:pexip:infinity:*:*:*:*:*:*:*:* and rooted in CWE-863 (incorrect authorization). The internal API requires no authentication (PR:N) and no user interaction (UI:N), but the attack path is adjacent-network only (AV:A) and code runs unprivileged on the target rather than as root; there is no public exploit identified at time of analysis and no CISA KEV listing, though the 8.8 CVSS and lateral-movement potential make this a high-priority fix for any clustered installation.

Code injection in DataElement BiSheng 2.3.0, 2.4.0, and 2.4.0-beta1 allows unauthenticated network attackers to execute arbitrary code and fully compromise affected deployments through the backend validation endpoint src/backend/bisheng/api/v1/validate.py. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H, base 9.8) describes a remote, low-complexity, no-authentication attack that yields complete loss of confidentiality, integrity, and availability. Exploitation is not confirmed as active (not in CISA KEV), no public exploit identified at time of analysis, EPSS is 0.21% (10th percentile), and no fixed version is confirmed in the available data; a GitHub gist referenced in the record may contain further technical detail.

Prompt-driven shell command execution in camel-ai CAMEL 0.2.91a1, 0.2.91a2 and 0.2.91a3 lets anyone who can influence an agent's prompt - directly as an interactive user or indirectly through content the agent ingests - run arbitrary operating-system commands, because TerminalToolkit.shell_exec performs no approval or confirmation step before executing. The independent assessment rates this high (AV:N/AC:H/PR:N/UI:N, C/I/A:H) because the agent must be deployed with the terminal toolkit enabled, whereas the unadjusted NVD vector of 9.8 assumes no such precondition; the attacker is unauthenticated per the vector (PR:N), though exploitation depends on prompt influence. Publicly available exploit code exists (a proof-of-concept gist is linked from the advisory), but there is no confirmed actively exploited status (CISA KEV), and EPSS is low at 0.25 percent (15th percentile), making this an elevated but not emergency-tier priority.

Unauthenticated remote code execution is possible in DB-GPT 0.7.5 and 0.8.0 through the combination of two first-party REST endpoints: a crafted skill uploaded via /api/v1/skills/upload can subsequently be invoked and executed by the /api/v1/chat/react-agent flow, which loads and runs the stored skill without adequate validation. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) indicates an unauthenticated network-reachable attacker with no victim interaction can achieve full confidentiality, integrity, and availability impact, and the SSVC assessment rates technical impact as total with automatability confirmed; publicly available exploit code exists (SSVC Exploitation: poc) but there is no CISA KEV listing, so confirmed active exploitation in the wild is not established. Despite the severe base score, EPSS is only 0.20% (9th percentile), reflecting the practical requirement that both the skills-upload and react-agent features be reachable and exposed - instances bound to localhost, placed behind authentication, or on isolated networks are far less exposed.

Code execution in camel-ai's CodeExecutionToolkit (versions 0.2.91a1, 0.2.91a2, and 0.2.91a3) lets remote, unauthenticated attackers run arbitrary Python through the SubprocessInterpreter with no approval or confirmation boundary. The attacker must be able to influence the agent's model output - for example via prompt or task injection - so that the LLM emits executable Python, and the host application must have opted into the code-execution toolkit and routed untrusted input to it; exposure is therefore conditional rather than default, which is reflected in the independent assessment's High attack complexity (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) versus the vendor's 9.8 AV:N/AC:L rating. Risk weighting is tempered by a low EPSS of 0.22% (11th percentile), no CISA KEV listing, and no vendor-released patch identified at time of analysis, though a public GitHub issue and a third-party gist describing the flaw are referenced.

Unauthenticated code injection in Devika v1.0 allows an attacker who can reach the backend service to run arbitrary code with the privileges of the Devika process, because the Runner.run_code function in src/agents/runner/runner.py executes supplied input without adequate validation. The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, base 9.8) reflects a remotely reachable, no-authentication, no-interaction path, but practical risk is bounded by deployment: Devika is normally run as a local developer tool bound to localhost, and the network-facing exploitation implied by the vector applies only when an operator has deliberately bound the backend to a routable interface (for example 0.0.0.0) or runs it in a shared multi-user environment. EPSS is low at 0.21% (roughly the 10th percentile) and no public exploit was identified at time of analysis, with no CISA KEV entry; a public GitHub issue and an external gist are the only public artifacts referenced alongside the MITRE and ENISA EUVD (EUVD-2026-90411) records.