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.
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.
Arbitrary code execution on OpenClaw Windows Node hosts before version 2026.7.1 is achievable by an attacker who already holds gateway or agent access to a node, because the system.run tool's environment-variable sanitizer maintains an incomplete denylist (CWE-184). The attacker supplies variables such as GIT_CONFIG_*, GIT_PAGER, DOTNET_STARTUP_HOOKS, or JAVA_TOOL_OPTIONS alongside a request that runs an allowlisted tool (git, dotnet, java), causing that otherwise-permitted tool to load and execute attacker-controlled code or commands when it is next invoked; this requires the attacker to pass the tool's own arguments unchanged, which is why the attack-complexity/attack-requirements component is elevated. Exploitation is not remote-unauthenticated-it presumes prior gateway or agent access (PR:L), it is Windows-only, and it depends on at least one of git, dotnet, or java being present and reachable through system.run. No public exploit code or confirmed active exploitation was identified at time of analysis; the vendor has released a fixed build.
An out-of-bounds read in the NVIDIA Display Driver for Windows kernel module allows local attackers to cause denial of service and disclose sensitive kernel memory. Affected products include GeForce, RTX/Quadro/NVS, and Tesla driver lines on Windows; exploitation requires local access with no elevated privileges or user interaction. No public exploit code has been identified, and the vulnerability is not remotely exploitable.
Certificate hostname verification is silently skipped in CPython's TLS stack when an application enables SSLContext.check_hostname but supplies no server_hostname (None or an empty string) to SSLContext.wrap_bio(), asyncio.create_connection(), or asyncio.loop.start_tls(). In that exact state SSLObject still validates the certificate chain but never matches the peer's identity against the requested name, so an unauthenticated attacker holding a man-in-the-middle position on the connection path and a certificate chaining to a CA the client trusts can intercept traffic while the program believes hostname checking succeeded. Exploitation is gated by two independent conditions - the application-side misconfiguration and an active network-intercept position - no public exploit code has been identified at time of analysis, and applications that pass a valid non-empty server_hostname are completely unaffected regardless of patch status.
Out-of-bounds write in PCRE2, the regular-expression library embedded in PHP, nginx, Apache httpd, Git and numerous language runtimes, allows memory corruption when a consuming application compiles an attacker-controlled pattern through the JIT compilation API in the manner described by the vendor advisory. Only releases before 10.49 are affected, and exploitation is gated on two conditions holding at once: the application must accept untrusted, user-supplied regexes and must route them through PCRE2's JIT path, so default library presence alone does not imply exploitability. The assessed vector is network-reachable with high attack complexity and no privileges required (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:L, base 7.6); no public exploit code and no CISA KEV entry were identified at time of analysis. A vendor patch is available per the advisory, so upgrading to a fixed release remediates.
Blind SQL injection in WPTasty Business Directory plugin versions through 6.4.27 allows an authenticated attacker with high privileges to infer database contents without direct query output, using boolean- or time-based inference. The CVSS vector indicates network exploitability, no user interaction, and high confidentiality impact, but the PR:H requirement means the attacker must already hold a privileged WordPress account, so this is a plausible but not urgent priority. No public exploit has been identified at time of analysis, and KEV status is not indicated.
SQL injection in the Category Discount WooCommerce WordPress plugin (slug woo-product-category-discount, CVE-2026-96828) affects all versions up to and including 5.18 and allows an authenticated WordPress Administrator to inject arbitrary SQL through the plugin's admin-side functionality, yielding high-impact confidentiality exposure (CVSS 7.6, C:H/I:N/A:L, S:C). The PR:H prerequisite is the dominant limiting factor: only the highest-privilege role can reach the vulnerable code, so this is realistically a post-account-compromise or insider-abuse vector rather than an opportunistic unauthenticated attack. No public exploit code has been identified at time of analysis, the issue is not listed in CISA KEV, and no EPSS score was supplied; Patchstack is credited with reporting the flaw.
SQL injection in the Melapress Admin Notices Manager WordPress plugin (versions up to and including 1.6.0) allows an authenticated WordPress Administrator to inject arbitrary SQL into a plugin-handled parameter, giving the attacker read access to data outside the plugin's own tables. The assessed vector CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:N/A:L scores 7.6, but the PR:H requirement means exploitation presupposes top-tier site access; the practical threat model is multi-admin sites, delegated or agency-managed installs, or an attacker who has already escalated a lower-privilege foothold to administrator. No public exploit code has been identified and the issue is not listed in CISA KEV; no EPSS score was supplied with the available intelligence, so no exploit-probability estimate is asserted here.
Authenticated SQL injection in the weDevs WP ERP plugin for WordPress, affecting all releases up to and including 1.17.9, allows an attacker with Author-level or higher WordPress privileges to inject arbitrary SQL and read data from the site's database. The vulnerability is network-reachable and requires no user interaction, and because the CVSS scope is marked as changed (S:C) with high confidentiality impact (C:H), a successful injection can reach data beyond the plugin's own tables, including other plugins' and core WordPress content. Exploitation is privilege-gated by the PR:H rating, so exposure concentrates on multi-author, membership or community sites where Author accounts are handed to third parties; there is no public exploit identified at time of analysis and no confirmed vendor patch version in the available intelligence, making this a genuine but privilege-gated risk.
SQL injection in the Estatik WordPress plugin (versions <= 4.3.5) allows an authenticated attacker with administrator privileges to read sensitive data from the WordPress database. The vulnerability is a CWE-89 SQL injection in an admin-side function, requiring high privileges (PR:H) but no user interaction. No public exploit code has been identified at the time of analysis, and the primary risk is in environments where administrator access is delegated or on multisite installations where raw database access is not otherwise available.
Authenticated SQL injection in the Quiz Cat WordPress plugin (versions 3.1.1 and earlier) allows an attacker holding at least the WordPress Author role to send crafted requests that are woven into backend SQL statements, giving read access to sensitive database contents such as user records and stored quiz data, with secondary potential to alter or disrupt data. Exploitation is remote and requires no user interaction, but it is gated behind the Author privilege, so the realistic exposure surface is multi-author, membership, and user-generated-content sites that hand Author accounts to untrusted or numerous users; anonymous visitors and Subscriber- or Contributor-only accounts cannot trigger it. No public exploit code has been identified at time of analysis. The reported CVSS is 7.6 (AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:N/A:L), while our independent assessment is slightly more conservative at AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:L/A:L - both agree the dominant impact is confidentiality loss.
SQL injection in WP Activity Log 5.6.6 and earlier allows an authenticated WordPress administrator to inject SQL through an admin-accessible plugin function, potentially reading sensitive database contents and causing limited integrity or availability impact. The vulnerability requires a high-privileged admin account per the PR:H vector, so it is not exploitable by unauthenticated visitors or lower-privileged users; no public exploit code was identified at time of analysis. The supplied base CVSS is 7.6, and the independent assessment uses CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:L/A:L, while the provided NVD-style vector is CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:C/C:H/I:N/A:L.
Denial of service in Apache WSS4J (2.x before 2.4.4, 3.x before 3.0.6, and 4.x before 4.0.2) allows unauthenticated remote attackers to force excessive CPU and memory consumption by sending crafted WS-Security messages whose derived-key Length and Offset values are not validated by the library. The issue is a CWE-20 improper input validation flaw rated by the vendor at CVSS 3.1 base 7.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so the rated impact is availability only, although the same unchecked bounds could in principle yield cryptographically weak derived keys. Vendor patches are available in 4.0.2, 3.0.6, and 2.4.4; CISA SSVC lists Exploitation: none with Automatable: yes, and no public exploit identified at time of analysis.
Unauthenticated file write in Kiteworks Email Protection Gateway lets any attacker who can reach the appliance's administrative upload endpoint push files containing attacker-controlled content onto the underlying filesystem, because that handler performs no authentication or authorization check (CWE-306, CVSS 3.1 base 7.5, AV:N/AC:L/PR:N/UI:N). The directly reachable impact is integrity-only - no standalone code execution is achievable, since achieving RCE would require chaining a separate vulnerability to relocate the written file into an executable location. No public exploit code exists and no confirmed active exploitation was identified at time of analysis, so risk is genuine but bounded, concentrated on deployments that expose the management/upload interface to untrusted networks rather than those that firewall it to a management VLAN.
Unauthenticated server-side request forgery (SSRF) in Kiteworks Secure Data Forms before 9.5.0 allows remote attackers to force the server to issue arbitrary outbound network requests and read back the responses, exposing internal-only services, cloud metadata endpoints, and other network-restricted resources. Exploitation requires no authentication (PR:N) and no user interaction (UI:N); our independent assessment rates it CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N, reflecting the high confidentiality impact of reading internal responses rather than the vendor's C:N/I:H weighting. No public exploit code or confirmed active exploitation was identified at time of analysis.