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.
Malformed signaling input delivered to Pexip Infinity deployments running versions before 41.0 can abort the signaling software, denying conferencing service to users of the affected node. The issue is network-reachable and carries a CVSS 3.1 base of 8.6 (AV:N/AC:L/PR:N/UI:N/S:C/C:N/I:N/A:H), with the severity driven almost entirely by the high availability impact plus the scope-change component rather than by any loss of confidentiality or integrity. The CVSS vector's PR:N indicates no privilege requirement, but exploitation still carries an access precondition: the attacker must be able to reach the WebRTC/API signaling entry point and participate in a gateway call, so internet-facing nodes that permit open WebRTC/API gateway calling are directly at risk while internal-only or call-restricted deployments are substantially less exposed. There is no public exploit identified at time of analysis, and the fixed release (Pexip Infinity 41.0) is available.
OpenSave through 2.4.0 contains a path-validation bypass (CWE-73) in which a paired peer can supply save paths that fall outside the operator's configured save locations, enabling arbitrary file read and write on the target instance via the manifest request handler and sync routes. The CVSS 4.0 base score of 8.6 (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H) reflects high confidentiality and integrity impact with no user interaction and low attack complexity, though the attacker must already be a paired peer of the target (authenticated, PR:L), so an unpaired remote party cannot reach the flaw. No public exploit code and no confirmed active exploitation were identified at time of analysis, but a public advisory and the affected source locations are documented, making the issue straightforward to reason about for anyone already inside a peer trust relationship.
Privilege escalation in MISP before 2.5.48 allows an authenticated user who holds the tag editor permission (perm_tag_editor) to smuggle sibling User and Organisation records into tag collection create or edit requests, which the affected controller then persists alongside the intended tag collection - letting the attacker create or modify accounts and escalate to site administrator. Exploitation requires network access to the instance and a delegated tag-editor role; no user interaction or administrative rights are needed, and the accompanying source fix (commit 96f735e7b) shipped in MISP 2.5.48. No public exploit code was identified at time of analysis, and instances that never delegate perm_tag_editor to non-administrative accounts are not exposed to an unprivileged external actor.
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.
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.
Authenticated SQL injection in the Event Tickets WordPress plugin through version 5.29.5 allows any account holding the Contributor role to inject arbitrary SQL through plugin-supplied input, giving read access to data well beyond what the plugin itself stores (CVSS 3.1: 8.5, AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:L). The practical barrier is the Contributor authentication requirement, which limits mass exploitation but is trivially satisfied on sites with open registration or large numbers of low-trust contributors; the Scope:Changed rating reflects that successful injection can expose the broader WordPress database, not just plugin tables. No public exploit code or confirmed active exploitation has been identified at time of analysis, and the vendor has not published a fixed version in the available data, so this is a genuine mid-to-high priority issue rather than an emergency.
SQL injection in GamiPress WordPress plugin versions 8.0.2 and earlier allows unauthenticated attackers to read sensitive data from the database. Our independent assessment indicates no user interaction or authentication is required (PR:N), though the originally provided CVSS vector specifies PR:L, creating a discrepancy that should be verified with the vendor. No public exploit code has been identified at time of analysis.
Arbitrary file write during plugin installation in ZeroClaw before 0.8.5 (when built with the plugins-wasm feature) lets attackers place files outside the plugins directory by supplying a crafted manifest.toml whose wasm_path field contains '..' or absolute/root/drive-prefix components; overwriting shell startup files or similar executed content yields code execution under the victim's account. The attack is local (AV:L) and unauthenticated per the assessed vector (PR:N), but it requires user interaction (UI:P/UI:R) - the victim must be persuaded to install the attacker-supplied plugin package - and only functions when plugin signature verification is left in its default Disabled mode, making the path check the sole gate. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor has released a fix in v0.8.5.
SQL injection in the WordPress plugin Media Library Assistant (version 3.41 and earlier) allows an authenticated Contributor-level account to inject arbitrary SQL into the plugin's media/attachment query handling, reading database content such as user password hashes, private or draft posts, and stored configuration secrets. The issue is remotely exploitable with low complexity and no user interaction, and the CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:L) yields a base score of 8.5 (High), reflecting confidentiality-only impact plus a scope change that lets the injection reach tables outside the plugin itself. There is no public exploit identified at time of analysis and no CISA KEV entry, so the practical barrier to abuse is obtaining a Contributor account - realistic on sites with open registration, multi-author blogs, or guest-post/membership setups, but not on locked-down single-admin installs.
Authenticated SQL injection in the Easy Pricing Tables WordPress plugin affects versions up to and including 4.1.2, allowing any account holding at least the Contributor role to inject arbitrary SQL into the site's database and read sensitive data such as user credential hashes, password reset tokens, and stored configuration. Exploitation requires a valid logged-in account with Contributor privileges, needs no user interaction, and is network-reachable; no public exploit code has been identified at time of analysis, and the issue is not reported as actively exploited. Realistic exposure is concentrated on multi-author sites, membership or community sites with open registration granting Contributor, or any site where an attacker can obtain low-privilege credentials, while single-admin sites with registration disabled are at substantially lower risk.
Improper validation of a client-supplied SID over a local IPC named pipe in the Cato Networks SDP Client for Windows (versions before 6.12.6) lets a local, low-privileged user coerce the client's SYSTEM-level service into deleting arbitrary files with SYSTEM privileges, resulting in high integrity and availability impact on the affected endpoint. Exploitation is purely local - it requires an authenticated local user (PR:L per the CVSS vectors) with the ability to reach the client's local IPC named pipe, no user interaction, and the affected client installed and running on the target Windows host; there is no remote or network-facing attack path. This is confirmed neither as actively exploited (no CISA KEV listing) nor as having public exploit code: no public exploit identified at time of analysis, and the bounded local scope makes it a genuine but non-emergency privilege-escalation and file-tampering primitive rather than a remotely exploitable critical issue.
Improper verification of the source of ADS discovery responses in Apache PLC4X (CWE-940) allows an attacker on the adjacent network to redirect subsequent connections to an arbitrary host by spoofing a UDP discovery response, potentially exposing ADS route credentials. Affected versions are PLC4Go 0.11.0-<1.0.0, PLC4J ADS/Modbus 0.10.0-<1.0.0, and PLC4J EtherNet/IP 0.11.0-<1.0.0. Exploitation requires the consuming application to invoke the opt-in discovery API and act on discovered items; no public exploit identified at time of analysis. Upgrade to 1.0.0 to fix.
Command injection in the Ziroom ZHOME A0101 smart-home gateway running firmware 1.0.1.0 allows a remote, high-privilege authenticated attacker to execute arbitrary operating-system commands on the device by supplying shell metacharacters in the 'url' argument of the /api/ZRnetwork/ping diagnostic endpoint. Publicly available exploit code exists - the reporting researcher published a proof-of-concept write-up on GitHub - and the vendor was contacted early about the disclosure but never responded, so no vendor-released patch is available and no CISA KEV entry or EPSS score was provided in the source data. The published CVSS 4.0 score of 8.5 is driven upward by subsequent-system (SC:H/SI:H/SA:H) metrics that our independent assessment considers inflated for a single embedded gateway; the practical risk is bounded by the PR:H administrative authentication prerequisite in the vector and by the fact that consumer smart-home management interfaces such as this are normally reachable only from the LAN.
Denial of service in the npm package @angular/router when Server-Side Rendering (SSR) is enabled on Node.js allows an unauthenticated remote attacker to crash the SSR worker by exhausting the V8 old-space heap. Numeric matrix-parameter or outlet names (e.g. /a;990;2522) are stored as array-indexed properties on plain parameter objects, causing V8 to allocate dense HOLEY_ELEMENTS backing stores sized to the largest index, producing roughly 350x memory amplification (~20-25 KB of heap per 11-byte path segment) and a fatal 'JavaScript heap out of memory' error. Exploitation requires the app to run Angular SSR on Node.js, to parse user-controlled URLs directly through @angular/router, and an edge/reverse proxy that forwards semicolons and deep paths; roughly 12-22 concurrent 8 KB-path requests or 50-100 concurrent 1-2 KB-path requests are enough to kill a 256-512 MiB worker. Client-side Angular SPAs without SSR are not affected, and no public exploit code has been identified at time of analysis; the only impact is availability (no confidentiality or integrity impact).
Cross-tenant data disclosure in Soft Machine workspaces running version 0.2.247 and prior lets any peer Fly Machine on the same private 6PN mesh read arbitrary files under a workspace's /workspace root and pull entire project trees as tar archives through the unauthenticated /file/<path> and /archive/<dir> endpoints exposed on 0.0.0.0:8080. Exploitation is bounded by network topology rather than open to the internet: an authenticated tenant that controls another sm-ws-* machine in the same Fly app/org can reach peer workspaces (discoverable via the unauthenticated _instances.internal TXT record) with no further authentication, credentials, origin check, or user interaction, while single-tenant or network-isolated deployments are unreachable by outside parties. At time of analysis no public exploit code has been identified and no vendor patch is available, but the missing trust boundary between workspace owner and co-tenants makes this a genuine confidentiality risk anywhere multiple tenants share a Fly org.
Stored cross-site scripting in MISP's event graph preview lets an authenticated user who can create or modify an event graph entry persist a malicious preview_img value that executes in the browser of a second user who opens the graph and triggers the preview popover. The stored value is concatenated directly into an img src attribute in app/webroot/js/event-graph.js, so a crafted string can break out of the attribute context and inject arbitrary JavaScript in the MISP origin, enabling session/cookie theft or actions performed as the victim; exploitation is bounded by the required prior authentication (PR:L) and mandatory victim interaction, and no public exploit code or confirmed active exploitation was identified at time of analysis. Only MISP instances running versions prior to fix commit 92c7ccc43, which landed after v2.5.48, are affected, making internet-exposed multi-user deployments the realistic risk surface.
Cross-tenant record tampering in MISP (Malware Information Sharing Platform) versions before 2.5.48 lets any authenticated user holding the basic write role (perm_add) overwrite attribute values, re-parent objects into their own events, or soft-delete rows owned by other organizations and events they have no read access to. The root cause is that the CakePHP ORM's set() gives precedence to an attacker-supplied nested key matching the model alias, so MISP's sanitization (primary-key stripping, event_id/object_id pinning) is applied to the outer flat record while the ORM actually persists the inner attacker-controlled one; the independent assessment confirms this is a fully remote, low-complexity exploit (PR:L, no UI) with integrity-only impact that extends across tenants (SI:H), and no public exploit code or in-the-wild activity has been identified at time of analysis. A vendor fix is available via upstream commit 9485ae40d, with the affected range ending at MISP 2.5.48.
Quadratic CPU consumption in basic-ftp before 6.2.1 lets a malicious or compromised FTP server freeze a Node.js application that calls Client.list(): the RE_LINE pattern in src/parseListUnix.ts backtracks across the optional, unbounded owner and group fields of a crafted Unix-style directory line, and because parseList() picks a parser from the last nonblank line and then applies it to every line, a normal trailing entry can force the vulnerable Unix parser onto the earlier hostile line and block the event loop. The attack requires the victim to connect out to an untrusted or attacker-controlled FTP endpoint and perform a listing (CVSS 3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H - availability only, no confidentiality or integrity impact); unauthenticated attackers are sufficient, but the trust direction is the limiting factor, so systems that only talk to trusted FTP servers are not realistically exposed. There is no public exploit identified at time of analysis and the issue is not confirmed as actively exploited (no CISA KEV), and the vendor-released patch is version 6.2.1.
Improper URL construction in the @astrojs/node adapter for the Astro web framework (versions prior to 11.1.3) allows an unauthenticated remote client to terminate or disrupt a Node-hosted Astro site by sending a Host header whose port cannot be parsed, such as example.com:65536, example.com:99999, example.com:-1, example.com:abc, or a duplicated port like example.com:8080:8080. In the default standalone configuration the malformed host triggers an HTTP 500 while the server keeps running, but when the non-default staticHeaders option is enabled the exception is thrown from a synchronous handler, escapes the adapter's error handling, and crashes the Node process, producing a full availability loss. Impact is availability-only with no data exposure and no code execution path; any fronting proxy or CDN that rejects malformed Host headers prevents the request from reaching the origin and neutralizes the attack. No public exploit code or confirmed active exploitation was identified at time of analysis, and the vendor-released fix is @astrojs/node 11.1.3.
Broken access control in the MakeCommerce for WooCommerce WordPress plugin (versions up to and including 4.1.0) lets a low-privilege authenticated Subscriber reach a plugin action that is missing its capability check, allowing unauthorized modification of store data. The published CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:L) scores 8.2, but our independent assessment adjusts the privilege requirement to PR:L, since the 'Subscriber Broken Access Control' classification implies an authenticated Subscriber session is needed; open registration on many WooCommerce stores makes obtaining such an account trivial. The result is high integrity impact and limited availability impact with no confidentiality exposure, no user interaction required, and no public exploit identified at time of analysis.
Unauthenticated SQL injection in the WordPress plugin WP Data Access affects all versions up to and including 5.5.84, allowing remote attackers to inject arbitrary SQL into the site's database queries without logging in or any user interaction (CVSS 8.2, AV:N/AC:L/PR:N/UI:N). The assessed impact is primarily to database confidentiality (C:H) with only limited integrity impact (I:L) and no availability effect, which confines the practical worst case to large-scale data disclosure rather than site takeover or denial of service. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (CISA KEV), though the low attack complexity and lack of authentication prerequisites make weaponization straightforward; EPSS data was not provided in the source intelligence. This is a genuine priority for any WordPress site running the plugin, since exploitation requires only that the affected version be installed and reachable, with no special configuration needed.
Deserialization of untrusted data in Kiteworks Core before 9.5.0 can escalate to remote code execution on the appliance, but only as a secondary, chained weakness rather than a standalone attack. The issue is not exploitable in isolation: an attacker must first obtain a way to influence the data that Core deserializes, which in practice means chaining a separate flaw (for example one of the file-write or injection issues in the same CISA CSAF batch, va-26-274-01) or leveraging an existing foothold. No public exploit code has been identified at time of analysis and the CVE is not listed in CISA KEV, and although the base score is 8.1, the local/config-adjacent reachability (AV:L), high attack complexity (AC:H) and the mandatory data-influence precondition materially lower real-world risk; the CVSS vector indicates no privileges are required (PR:N), but exploitation is not remotely self-contained.
Path traversal in AgentScope 1.0.0 through 1.0.18 lets an attacker who can influence the path argument passed to the agent's write_text_file tool cause file writes outside the intended directory, resulting in arbitrary file overwrite on the host running the agent. The assessed CVSS 3.1 base score is 8.1 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L), reflecting a network-reachable, low-complexity issue that requires the attacker to hold low privileges relative to the agent (PR:L) while the primary impact is integrity, with limited availability impact and no confirmed confidentiality impact. Exploitation is realistic in deployments where the agent is wired to call write_text_file with attacker-influenceable paths, most plausibly via untrusted content processed by the agent (indirect prompt injection) or a malicious task submitted to it; no public exploit code was identified at time of analysis, and the CVE is not listed in CISA KEV.
Path traversal in ModelScope AgentScope 1.0.0 through 1.0.8 allows an attacker who can reach the built-in insert_text_file tool and influence its path or filename argument to read and write files outside the intended workspace directory, giving both high confidentiality and high integrity impact (CVSS 8.1, AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N). The attacker is not anonymous: exploitation requires at least low-privilege access to the agent or tool surface (PR:L), typically via a direct agent tool call, an exposed agent API endpoint, or prompt injection through untrusted content the agent processes, and the reachable damage is bounded by the filesystem permissions of the AgentScope process user. No confirmed active exploitation exists (not listed in CISA KEV) and no public exploit was identified at the time of analysis, so this should be treated as a real but conditional risk that depends on whether insert_text_file is enabled, exposed, and influenceable by an untrusted party.
Stored cross-site scripting in Kiteworks Core allows an administrator holding only a single narrowly scoped delegated permission to plant crafted content that later executes as JavaScript in the authenticated session of a higher-privileged System Administrator, enabling the lower-privileged attacker to escalate to full tenant administrative control and create a new administrative account. The flaw is tracked as CVE-2026-102126 with a vendor CVSS 3.1 score of 8.1 (AV:N/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:N) and is rated high severity under CWE-79. Exploitation requires an authenticated admin with the delegated permission (PR:H) and depends on the victim System Administrator viewing the affected page (UI:R); no public exploit code has been identified at time of analysis, and the issue is not in CISA KEV.
In Tugtainer versions before 1.31.3, the OIDC login flow accepts unverified JWT claims from the identity provider's id_token, allowing an unauthenticated remote attacker who can influence the token exchange to impersonate any identity and gain full control of the Tugtainer session. The flaw is a pre-authentication authentication bypass (CWE-347) with high confidentiality, integrity, and availability impact once triggered; exploitation requires OIDC to be configured and enabled. No public exploit has been identified at the time of analysis, and the issue is not listed in CISA KEV. A vendor patch is available in version 1.31.3.
Stack-based buffer overflow in apcupsd through 3.14.14 allows unauthenticated remote attackers to corrupt memory and potentially execute code through the optional CGI web interface. The flaw lives in getupsvar() in src/cgi/upsfetch.c, which is invoked by upsstats.cgi, multimon.cgi, and upsfstats.cgi; exploitation requires one of those CGI scripts to be deployed and reachable, plus the ability to control or man-in-the-middle the UPS variable data fed to it from an apcupsd Network Information Server. This is an AC:H, PR:N issue with full confidentiality, integrity, and availability impact; no public exploit code has been identified at time of analysis, and it is a related issue to CVE-2026-15544.
An out-of-bounds read in the kernel-mode layer of NVIDIA GPU Display Driver on Windows and Linux allows a local, authenticated unprivileged user to potentially achieve code execution, privilege escalation, denial of service, information disclosure, or data tampering. Affected products include GeForce, RTX/Quadro/NVS, and Tesla GPUs, as well as Guest Driver and vGPU Manager deployments. With a CVSS score of 7.8, the vulnerability requires local access and low privileges (CVSS vector AV:L/AC:L/PR:L/UI:N), making it primarily a risk in multi-user or shared-GPU environments; no public exploit has been identified at time of analysis, and patched driver branches are available in NVIDIA security bulletin 5861.
An out-of-bounds write in NVIDIA NVAPI for Windows allows a locally authenticated attacker holding standard user privileges to corrupt memory by invoking NVAPI entry points, potentially leading to code execution, elevation of privileges, information disclosure, denial of service, or data tampering. The flaw affects hosts running the NVIDIA GPU driver package on Windows - including GeForce, RTX/Quadro/NVS, and Tesla driver-equipped systems - with a CVSS 3.1 base score of 7.8 (HIGH) under vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H. No public exploit code and no confirmed active exploitation (CISA KEV) have been identified at time of analysis, but the local-only, low-privilege prerequisite makes shared and multi-tenant GPU/VDI hosts the most exposed environment.
Type confusion in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux allows a local low-privileged user (CVSS vector AV:L/AC:L/PR:L/UI:N) who can reach the driver's device-node/ioctl interface to trigger memory corruption with high impact across confidentiality, integrity, and availability, potentially yielding code execution in kernel context, privilege escalation to root, denial of service, information disclosure, and data tampering. The CVSS 3.1 base score of 7.8 reflects a local attack vector paired with uniformly high impacts rather than any remote reachability, and despite the 'RCE' tag in the source metadata the vulnerability is not remotely exploitable. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and no EPSS or CISA KEV signal was provided.
Local privilege escalation in NVIDIA GPU Display Driver for Windows (CUDA driver component) allows an authenticated attacker with low privileges to execute arbitrary code by planting a malicious library in an uncontrolled search path. Affected products include GeForce, RTX/Quadro/NVS, Tesla, and vGPU guest driver branches. No public exploit identified at time of analysis; exploitation requires local access and write permissions to a directory resolved by the driver's search path, making it most relevant on shared multi-user or VDI/cloud-GPU hosts.
Local privilege escalation in NVIDIA Display Driver for Windows allows an authenticated low-privileged user to trigger a stack-based out-of-bounds write in the kernel mode layer, potentially leading to code execution, privilege escalation, and denial of service. Affected systems include Windows hosts with GeForce, RTX/Quadro/NVS, or Tesla drivers, as well as the Guest Driver in virtualized deployments. No public exploit code or active exploitation has been identified at time of analysis, and the flaw requires local access, making it most relevant to shared multi-tenant environments.
Local privilege escalation in Kiteworks Core lets an attacker who already holds code execution as an unprivileged backend service account invoke a privileged routine that mishandles attacker-influenced input, running arbitrary OS commands as root. The flaw requires a prior local foothold on the appliance - the CVSS vector (AV:L, PR:L, UI:N) confirms it cannot be reached directly over the network and demands an existing initial compromise or misconfiguration to obtain the service account. No public exploit code or active exploitation is identified at time of analysis, and the realistic risk is bounded by how easily that initial service-account access can be obtained on a given deployment; the vendor's advisory is GHSA-658c-86vw-g9hf.
Local privilege escalation and potential code execution in NVIDIA GPU Display Driver for Windows and Linux arise from a use-after-free (CWE-416) reachable by a low-privileged local user who can issue a crafted sequence of driver commands. The CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) rates confidentiality, integrity, and availability impact as high, with the greatest risk in shared or virtualized GPU deployments where guest-driver or virtual GPU manager isolation may be broken. No public exploit code or confirmed active exploitation is identified in the available data, and EPSS is not provided; exploitation requires local access and construction of the specific command sequence.
Local privilege escalation in NVIDIA Display Driver for Windows and Linux allows an unprivileged local attacker to trigger a use-after-free condition by issuing a crafted sequence of driver commands, potentially achieving code execution, privilege escalation, denial of service, or information disclosure. The vulnerability affects systems with GeForce, RTX/Quadro/NVS, or Tesla GPUs running vulnerable driver versions. No public exploit identified at time of analysis.
Local privilege escalation and memory corruption in NVIDIA GPU Display Driver on Windows and Linux, affecting GeForce, RTX/Quadro/NVS, and Tesla lines. An unprivileged local user can trigger a use-after-free (CWE-416) by issuing a specific sequence of driver commands, leading to potential code execution, privilege escalation, denial of service, or information disclosure. Requires local access and low privileges (AV:L/PR:L) with no user interaction (UI:N); no public exploit identified at time of analysis. Risk is highest in multi-user or shared-GPU environments such as VDI, terminal servers, and cloud/virtualized GPU hosts.
Local privilege escalation in the NVIDIA GPU Display Driver for Linux allows an authenticated, unprivileged user to trigger a use-after-free condition by issuing a specific sequence of driver commands, potentially leading to code execution, privilege escalation, denial of service, and information disclosure. The vulnerability affects GeForce, RTX/Quadro/NVS, and Tesla GPU drivers, including guest-VM vGPU deployments, and requires local access with low privileges. No public exploit code or confirmed active exploitation has been identified at time of analysis.
Local privilege escalation in Kiteworks Core allows an attacker who already holds a shell under a low-privileged service account to elevate to root on the appliance, gaining complete control of the system and the sensitive content it brokers. The weakness is a link-following issue (CWE-59) in a root-privileged operation, reachable with local access as the service account (CVSS:3.1/AV:L/AC:L/PR:L/UI:N), no user interaction, and no non-default configuration, making it a realistic second-stage escalation after a separate initial-access compromise. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the CVE is not associated with a KEV listing; the primary limiting factor is the prerequisite service-account foothold, while the primary risk is full root compromise of the appliance.
Local privilege escalation in the kernel-mode layer of the NVIDIA GPU Display Driver for Linux allows an unprivileged local user to bypass read-only memory protection and gain write access to memory the driver marked read-only, which can result in kernel code execution, denial of service, privilege escalation, information disclosure, and data tampering. Exploitation requires the attacker to already hold low-privileged local access on an affected Linux host (CVSS 3.1 vector AV:L/AC:L/PR:L/UI:N, score 7.8) with no user interaction and no network vector; the risk is greatest on shared, multi-tenant vGPU, VDI, and cloud-GPU hosts where crossing the user-to-kernel boundary breaks tenant isolation. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, but NVIDIA has published a fix through security bulletin 5861. This is a genuine local privilege-escalation risk rather than an emergency, and it should be prioritized on multi-tenant GPU infrastructure.
Local privilege escalation in Kiteworks Core lets an attacker who already has code execution as an unprivileged backend service account on the appliance obtain root. A privileged, root-owned routine consumes a filesystem path that the lower-privileged service account can influence, so the attacker can steer that root operation into executing arbitrary commands with full privileges (CWE-59 link-following / unsafe path handling). The attack is local-only (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8) and is a second-stage primitive requiring an existing foothold; no public exploit was identified at time of analysis and the CVE is not reported as confirmed actively exploited (CISA KEV), though the 7.8 severity and availability of a vendor advisory make prompt patching advisable.
Local code execution in JetBrains IntelliJ IDEA before 2026.2.3 is possible when a developer opens an attacker-supplied untrusted project, because malicious Structural Search script constraints then run within the IDE. The flaw is assessed as CVSS 7.8 (AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H), meaning exploitation is local and requires the victim to open the project, but no target authentication is needed and default configurations are affected once that action occurs. No public exploit or confirmed active exploitation was identified at time of analysis; the risk is real but gated by social engineering and the local attack vector.
Privilege escalation in NVIDIA's GPU Display Driver for Windows lets a local, low-privileged authenticated user bypass an authorization check in the driver's kernel-mode escape handling, gaining kernel-level capabilities that can lead to code execution, data tampering, information disclosure, or denial of service on the affected host. The issue is classified as CWE-863 (incorrect authorization) with a CVSS 3.1 base score of 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H); it is strictly local with no remote or network attack surface. No public exploit code has been identified and the vulnerability is not listed on CISA KEV, so it should be treated as a genuine but access-gated privilege-escalation risk concentrated in multi-user, VDI, and cloud-GPU hosts where an untrusted tenant or guest driver instance can reach the driver's escape interface.
Local privilege escalation in NVIDIA GPU Display Driver for Linux allows an authenticated local unprivileged user to write to memory that the kernel-mode display driver should keep read-only because permissions are not preserved (CWE-281), potentially causing code execution, privilege escalation, denial of service, information disclosure, or data tampering. The affected CPE branches are GeForce, RTX/Quadro/NVS, Tesla, and Guest Driver on Linux, with CVSS 7.8 (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) indicating high impact after local access. No public exploit identified at time of analysis, and the practical risk is a genuine but not emergency-grade local privilege-escalation issue, most meaningful in shared or multi-tenant GPU environments.
Container escape in CRI-O - the OCI runtime that underpins Red Hat OpenShift Container Platform 4 - is achievable when a workload-level actor can create or influence pod metadata that overwrites CRI-O's own reserved sandbox bookkeeping; the poisoned state is then reloaded as trusted after a CRI-O daemon restart, and a subsequent container recreate inside that sandbox can expose a host-side runtime-management resource to the container. Rated CVSS 3.1 7.8 (AV:L/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:H), the flaw is not remotely reachable without cluster workload access, and the mandatory restart-then-recreate sequencing is the principal limiter on realistic exploitation. No public exploit code has been identified at time of analysis and the issue is not confirmed actively exploited (no CISA KEV listing); no EPSS score was supplied in the available intelligence.
Local privilege escalation on Reachy Mini Wireless robots running OS images built from pollen-robotics/reachy-mini-os prior to v0.2.4, where a sudoers entry granted the low-privileged pollen daemon user (uid 1000) passwordless root access to /usr/bin/systemctl with no subcommand or argument restriction. Any code already executing as pollen - for example through a compromised reachy daemon - can escalate to full root (uid 0) without user interaction or a TTY, because systemctl can be pointed at an attacker-supplied unit file whose ExecStart runs as root. Rated CVSS 3.1 7.8 HIGH (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), confirmed by the vendor advisory GHSA-7rhg-9v48-x3h2 and closed by release v0.2.4; no public exploit code or CISA KEV entry was identified at time of analysis, and exploitation requires an existing foothold as the pollen user on an unpatched image.
Local privilege escalation to root in Pexip Infinity (versions before 38.2, plus 39.0, 39.1, and 40.0) allows an attacker who already holds a foothold on a node to break out of a low-privileged local context and obtain full root control. Per the CVSS vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8), the flaw is local-only, requires low privileges, and is not remotely exploitable on its own: the attacker must first run arbitrary code on the node, either by chaining a separate remote code execution vulnerability or by already possessing administrative access to the node's operating system. There is no public exploit identified at time of analysis and no confirmed active exploitation (not in CISA KEV); the practical risk is that this bug turns any successful initial compromise of a Pexip Infinity host into a complete root compromise, so it should be treated as a meaningful post-exploitation escalation rather than a standalone remote threat.
Incorrect resource transfer between spheres in the NVIDIA vGPU Virtual GPU Manager for Linux allows a locally positioned, low-privileged attacker to break an internal resource-handling boundary and gain high-integrity impact - code execution, privilege escalation, data tampering, information disclosure, or denial of service on the host running the vGPU Manager. This affects virtualization/vGPU deployments on Linux (the manager component on the hypervisor host), not standard desktop GPU drivers, and the CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, base 7.8) confirms the attacker must already hold local low-privileged access to a context served by that manager, such as a guest VM or a local account on the host; there is no network or unauthenticated path. It is a genuine local privilege-escalation class issue rather than a remotely triggerable one, and no public exploit was identified at time of analysis.
An out-of-bounds write in the kernel-mode layer of NVIDIA vGPU Virtual GPU Manager for Linux lets a local attacker with low privileges corrupt kernel memory, which the vendor rates as potentially leading to code execution, denial of service, privilege escalation, information disclosure, and data tampering (CVSS 3.1 base 7.8, HIGH). The attack is strictly local - vector AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H - so it is not remotely exploitable and requires only an authenticated low-privileged context or a tenant/guest that can reach the host kernel module; the risk is highest in multi-tenant VDI and cloud-GPU deployments where local access is comparatively easy to obtain. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so there is no evidence of confirmed active exploitation.
Local privilege escalation, code execution, denial of service, and information disclosure affect Linux hosts running NVIDIA vGPU Virtual GPU Manager because of an out-of-bounds read in the kernel-mode layer that services vGPU requests. A low-privileged local account or existing code-execution context (CVSS PR:L) is required, and no user interaction is needed, but the flaw is not remotely reachable and only impacts hosts with the vGPU Manager component installed. No public exploit or proof-of-concept has been identified at time of analysis, and EPSS data was not provided; the independent assessment rates this as a moderate, locally-scoped risk.