Reuse of a caller-supplied options mapping in PyJWT 2.11.0 through 2.13.0 can silently leave registered-claim verification disabled on subsequent decode calls, allowing a correctly signed but otherwise invalid token to be accepted. When an application first calls decode() or decode_complete() with a mutable options mapping containing verify_signature set to false, PyJWT._merge_options() mutates that same mapping in place, writing verify_exp, verify_nbf, verify_iat, verify_aud, verify_iss, verify_sub, and verify_jti to false; if the application then reuses that identical mapping for a later call after flipping verify_signature to true, the stale false flags persist and expired, not-yet-valid, wrong-audience, wrong-issuer, or wrong-subject tokens are accepted even though signature verification is nominally on. This is a conditional integrity flaw rather than a signature bypass, it is reachable by unauthenticated remote attackers (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:H/A:N) but only in applications that reuse a mutable options mapping, and no public exploit code or confirmed active exploitation was identified at time of analysis.
Denial of service in vLLM through 0.26.0 lets remote attackers crash or exhaust inference workers by submitting inputs containing deeply nested '{...}' or '[...]' delimiter structures that the Gemma4UnifiedParser expands recursively without any depth bound, exhausting the thread stack. The flaw is confined to the Rust parser component (rust/src/parser/src/unified/gemma4.rs) and only affects deployments that route requests or model output through the Gemma4 unified parser - typically Gemma-family model serving with tool-calling or structured-output parsing. Publicly available exploit code exists (a published GitHub gist demonstrates the nested-input trigger), and the vendor has released a fix in v0.29.1rc0 via PR #54303; no CISA KEV listing or confirmed in-the-wild exploitation was provided in the source data. Impact is availability-only (no data disclosure, no code execution), and the CVSS 4.0 vector scores it 6.9 with E:P while the independent assessment rates it CVSS 3.1 A:H.
SQL injection in AdithyaYelloju Restaurant-Management-System through commit 7f0e7e84255e8fcfd488e83f8f91451bbbff6b9c allows unauthenticated remote attackers to manipulate the ID argument in User/cancel.php and potentially read or alter order-related database records. Publicly available exploit code exists, and the upstream project has not responded to the issue report, but there is no CISA KEV listing or confirmed active exploitation. The independent assessment rates this as a low-priority, low-impact issue constrained mainly by the scarcity of deployed instances of this unmaintained single-developer project.
Integer overflow in the image-encoding routines of nothings/stb (stb_image_write.h, stb through version 1.16) allows remote attackers who can influence image dimensions or channel counts passed to stbi_write_png_to_mem, stbi_write_jpg_core, or stbi_write_tga_core to corrupt memory or crash the encoding process. Publicly available exploit code exists (no CISA KEV entry, so active exploitation is not confirmed), and the flaw requires an application that feeds attacker-controlled sizing into the encoder rather than simple network reachability. The published CVSS 4.0 score of 6.9 overstates practical risk: an independent assessment rates it CVSS:3.1/AV:N/AC:H/PR:N/UI:N with only low integrity and availability impact and no confidentiality impact - a genuine but modest-severity issue whose real exposure depends entirely on whether the host application passes untrusted dimensions to the write functions.
Integer overflow in the hexwave_init() function of Nothings stb (stb_hexwave.h) corrupts allocation sizing when an application passes attacker-influenced width or oversample arguments during wave-table initialization. Exploitation is remote and unauthenticated at the library level and publicly available exploit code exists (no confirmed active exploitation), but the practical attack surface is limited: these are initialization parameters normally hardcoded by the developer, so exploitation requires an application that surfaces them to untrusted input. Impact is bounded to low integrity and availability loss, consistent with memory corruption or a crash rather than reliable code execution, and the project has not responded to the issue report, leaving no confirmed vendor patch.
Unauthenticated remote SQL injection in SourceCodester Car Driving School Management System 1.0 allows attackers to inject arbitrary SQL through the f=save_enrollment action of /classes/Master.php, potentially reading or altering data in the application's backend database. The CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) confirms the flaw is reachable without credentials or user interaction, though all vulnerable-system impacts are rated Low (VC:L/VI:L/VA:L) with no subsequent-system impact, yielding a moderate 6.9 rather than a critical score. Publicly available exploit code exists (referenced via a GitHub issue and the VulDB entry), and the affected version is 1.0 of this open-source PHP application; no public exploit identified at time of analysis beyond that released proof-of-concept, and the software has no CISA KEV listing.
SQL injection in the test_id parameter of exam-delete.php in SourceCodester Online Reviewer Management System 1.0 allows remote attackers to manipulate database queries, resulting in low-impact confidentiality, integrity, and availability loss (CVSS 4.0 6.9, medium). Publicly available exploit code exists and the attack is network-reachable with no user interaction; the published CVSS 4.0 vector rates it PR:N (unauthenticated), although our independent assessment notes the vulnerable script sits under the /admins/ administrative directory, implying a valid admin session is required in practice and that authentication requirements should be confirmed before the PR:N rating is trusted. The product is a small-footprint PHP application by SourceCodester, so real-world exposure is limited, and no CISA KEV listing indicates confirmed active exploitation.
SQL injection in the admin/table_booking.php script of AdithyaYelloju Restaurant Management System (commit 7f0e7e84255e8fcfd488e83f8f91451bbbff6b9c) enables unauthenticated remote attackers to execute arbitrary SQL commands via the 'Name' parameter, potentially compromising data confidentiality and integrity (CVSS 4.0 score 6.9; assessed CVSS 3.1 C:H/I:H/A:L). Publicly available exploit code exists, but the affected codebase is unreleased and pinned to a single commit with no packaged versions and an unresponsive maintainer, making active exploitation unlikely in production environments.
Unauthenticated SQL injection in the Order Placement component (User/ord.php) of AdithyaYelloju Restaurant-Management-System lets remote attackers manipulate the id and name arguments passed to mysqli_query, giving them arbitrary read and partial write access to the underlying database. Publicly available exploit code exists (the issue thread linked from the CVE record), and no vendor patch is available because the maintainer has not responded to the report; the vulnerability is not confirmed as actively exploited (no CISA KEV entry). Real-world risk is driven almost entirely by product obscurity rather than defect quality - this is an unversioned, single-commit GitHub project with essentially no production deployments, so any exposed instance running the vulnerable commit is exploitable by default but few such instances are expected to exist.
SQL injection in the AdithyaYelloju Restaurant-Management-System allows remote, unauthenticated attackers to manipulate database queries through the ID parameter of admin/delete1.php, a script the description treats as an unauthenticated action endpoint despite its location under the admin/ directory. Successful exploitation grants low-level confidentiality, integrity, and availability impact on the application's database, and publicly available exploit code exists, raising the likelihood of opportunistic scanning and abuse. The project is distributed via rolling releases with no versioned builds, the maintainer has not responded to the early issue report, so no vendor-released patch is available and every running instance should be considered affected; the practical risk is narrowed by the product's very low deployment footprint and the need for the endpoint to be reachable over the network.
SQL injection in SourceCodester Online Reviewer Management System 1.0 allows remote attackers to execute arbitrary SQL commands via the access_code parameter in /reviewer_0/admins/assessments/examproper/btn_functions.php. Per the CVSS vector, no authentication or user interaction is required, though the endpoint's location under an 'admins/' directory suggests it may be intended for authenticated administrators; a public exploit exists. No vendor-released patch has been identified at time of analysis, but the product is a niche educational PHP application with minimal enterprise deployment, so real-world risk is limited.
SQL injection in SourceCodester Online Reviewer Management System 1.0 allows remote attackers to manipulate the 'ID' request parameter of /reviewer_0/admins/assessments/examproper/questions-view.php, altering backend database queries with partial confidentiality, integrity and availability impact (CVSS 5.5; vendor-disclosed, VulDB-tracked). Publicly available exploit code exists - a proof-of-concept is published at https://github.com/Aszadom/cve/issues/1 - but there is no confirmed active exploitation (CISA KEV). The CVSS 4.0 vector records PR:N/UI:N (no authentication or user interaction required), although the '/admins/' segment of the vulnerable path suggests the questions-view function is part of the administrative interface and may in practice require an authenticated admin session, which would materially limit realistic exploitation. No vendor-released patch was identified at time of analysis.
Unauthenticated OS command injection in HKUDS AnyTool 0.1.0 lets a remote attacker execute arbitrary shell commands on the host running the tool, because the Execute Endpoint in anytool/local_server/main.py passes attacker-controlled 'command'/'shell' arguments directly into subprocess.run. Per the CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N) the endpoint requires no credentials or user interaction, so any deployment that exposes the local_server on a reachable interface - rather than loopback-only - is directly exploitable. Publicly available exploit code exists, and the project was notified via GitHub issue #6 but has not responded; no vendor patch has been identified at time of analysis. VulDB scored this 6.9 by rating impact conservatively as VC:L/VI:L/VA:L, while our independent assessment (CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) treats shell-level compromise of the host as high impact - treat the practical risk as higher than the published 6.9 suggests.
Information disclosure in gedelumbung HospitalManagement lets unauthenticated remote attackers obtain sensitive diagnostic output generated through the error_reporting handling in index.php, because PHP error text is emitted into HTTP responses. Exploitation requires only that the deployed instance runs with PHP error reporting/display enabled (the project's default or a common production misconfiguration) and that the attacker can remotely induce an error condition; no authentication or user interaction is needed (PR:N/UI:N). Publicly available exploit code exists (a public GitHub issue), and while CVSS 4.0 scores it 6.9 with E:P, our independent CVSS:3.1 assessment rates it as a low-severity confidentiality-only issue (C:L, no integrity or availability impact); there is no CISA KEV entry and no vendor-released patch identified at the time of analysis.
Improper output escaping in Satori (an HTML/CSS-to-SVG rendering library) allows crafted values to be interpreted as SVG markup, and when those values are routed through the Node.js ImageResponse implementation from Next.js's next/og, the same flaw escalates to remote code execution. Affected are Satori versions 0.0.27 through 0.33.4 and Next.js versions 16.2.0 through 16.3.5 that pass attacker-controlled data into SVG content, attributes, or styles; the Edge ImageResponse path and applications that never feed untrusted values into SVG are not affected. Exploitation is unauthenticated per the CVSS vector (PR:N) but hinges on that deployment prerequisite, and no public exploit identified at time of analysis. Vendor-released patches exist in Satori 0.33.5 and Next.js 16.3.6.
Axios versions 1.15.0 through 1.19.x silently ignore CIDR-form NO_PROXY entries in its Node.js adapter, so requests destined for loopback, RFC1918 private, Kubernetes, CI, or cloud-metadata ranges can be routed through a configured HTTP_PROXY/HTTPS_PROXY that the operator intended to bypass. The assessed severity is moderate (CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:L/A:N, 4.8) because exploitation depends on a specific non-default configuration - Node.js adapter, proxy environment variables set, and CIDR notation used in NO_PROXY - and only causes exposure or tampering of proxied traffic rather than code execution or authentication bypass. There is no confirmed active exploitation (CISA KEV) and no EPSS data supplied, but the vendor advisory ships a working local proof-of-concept demonstrating that NO_PROXY=127.0.0.0/8 does not prevent HTTP_PROXY from receiving a request to 127.0.0.1; the vendor-released fix is axios 1.20.0.
Unauthenticated information disclosure in the yii2-starter-kit application template through version 4.2.0 allows remote attackers to download file attachments that belong to unpublished (draft) articles by calling the attachment-download endpoint directly. The endpoint in frontend/controllers/ArticleController.php serves the requested file without verifying the publication status of the parent article, and because attachment identifiers are sequential and predictable, an attacker can enumerate them to harvest draft content; no credentials, user interaction, or non-default configuration are needed (CVSS:4.0 PR:N/UI:N, assessed as CVSS:3.1 AV:N/AC:L/PR:N/UI:N with C:L only). Impact is confined to reading draft attachments - there is no write, modification, or denial-of-service effect - and no public exploit code or confirmed active exploitation has been identified at time of analysis, so real-world risk depends mainly on whether a deployed site built from this starter kit leaves the vulnerable controller unmodified.
LightLLM through version 1.2.0 accepts image_url and audio_url parameters on its multimodal inference endpoints without validating or restricting the supplied URLs, allowing unauthenticated remote attackers to coerce the server into making arbitrary outbound HTTP requests (CWE-918 server-side request forgery). An attacker who can reach an instance configured to serve a vision or audio model can point those parameters at internal-only resources, and because the fetched content is passed into model processing, the results (or the resulting error messages) can leak internal content and network topology back to the caller. Impact is limited to confidentiality and topology disclosure rather than code execution; the issue is a genuine but moderate-severity exposure, no public exploit code has been identified at time of analysis, and it has not been confirmed actively exploited (no CISA KEV listing). Deployments that only serve text models, or that do not expose multimodal endpoints to untrusted networks, are out of scope.
IP whitelist and blacklist enforcement in the Pecee simple-php-router library through version 5.4.1.7 can be bypassed by remote unauthenticated attackers, allowing access to routes that are supposed to be restricted by client IP. The IpRestrictAccess middleware derives the caller's address from spoofable HTTP headers - X-Forwarded-For, CF-Connecting-IP, and Client-IP - instead of the trusted socket address, so a crafted request can impersonate a whitelisted host or slip past a blacklist. Impact is limited to confidentiality and integrity of the protected routes (moderate severity); no public exploit code has been identified at time of analysis and there is no CISA KEV listing, but exploitation requires only that the target application actually uses this middleware, and no credentials or user interaction are needed.
Unauthenticated information disclosure in the WPMobile.App (wpappninja) WordPress plugin through version 11.83 lets a remote attacker retrieve embedded sensitive data from the plugin without any credentials or user interaction. The underlying issue is a missing authorization check (CWE-862), and per the assessed CVSS:3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N) the impact is limited to a low-magnitude confidentiality leak with no integrity or availability effect, so it is a data-exposure bug rather than a site-takeover path. No public exploit code or active exploitation has been identified at time of analysis, and overall risk is capped by deployment scope: the target must actually run this mobile-app-builder plugin and expose its endpoint to the network.
Pgpool-II deployments that run in watchdog-based high-availability clustering mode can have an arbitrary watchdog node promoted to leader by an unauthenticated network attacker, because the node-authentication algorithm is implemented incorrectly (CWE-303). The flaw is only meaningful on multi-node clusters with use_watchdog enabled and where the watchdog communication interface is reachable by the attacker - standalone or non-watchdog instances are not exposed - so the practical risk is a genuine but deployment-constrained integrity and availability concern rather than a broadly exploitable one. No public exploit code was identified at time of analysis, and no CISA KEV entry or EPSS data was supplied; authentication is not required (CVSS PR:N) and no user interaction is needed (UI:N) once the watchdog precondition is met.
Missing authentication checks in baserCMS (CWE-306) let remote, unauthenticated attackers reach a critical function and read sensitive information without supplying any credentials. The assessed vector is CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:N/A:N (score 5.3), meaning the constraint is impact scope rather than access: only partial confidentiality is lost, and there is no path to modify data or disrupt the site. No public exploit code has been identified at time of analysis, and the issue is not listed in CISA KEV, so this is a moderate-severity, low-real-risk issue by current signals; the specific affected endpoint and version should be confirmed against JVN14353754.
Client certificate authentication in Pgpool-II can be bypassed by a remote unauthenticated attacker because affected versions fail to properly validate client certificates, allowing access that should require a valid certificate. The flaw carries a vendor CVSS 3.0 base score of 6.5 (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N) and affects multiple 4.x release trains through 4.7.2. Exploitation is conditional: it only matters when the Pgpool-II instance is configured to enforce client TLS certificate authentication; no public exploit was identified at the time of analysis, and it is not confirmed actively exploited (not in CISA KEV).
Arbitrary file deletion in the WEBO MCP WordPress plugin (versions 3.0.18 and earlier) allows authenticated attackers with at least the Author role to delete files on the server, causing availability impact. The vulnerability is a path traversal (CWE-22) that requires a valid content-creator account but no user interaction, and it has a scope change affecting resources outside the plugin. No public exploit code has been identified at time of analysis, and the CVSS base score is 6.8 (Medium).
Arbitrary file deletion in the WordPress plugin Template Kit - Import (versions up to 1.0.16) allows an authenticated attacker with Editor-level privileges to delete files on the hosting filesystem via a path traversal flaw (CWE-22). The vulnerability requires a network-reachable authenticated session (CVSS 3.1 vector AV:N/AC:L/PR:H/UI:N/S:C/C:N/I:N/A:H, base 6.8) and results in availability and file-integrity impact, with no data disclosure. No public exploit code or active exploitation has been identified at time of analysis.
Arbitrary local file disclosure in the Cato Windows SDP Client (versions before 6.12.6) lets a low-privileged local user coerce the client's Windows service, which runs as Local System, into reading and returning files that user cannot otherwise access, exploiting improper file-path validation combined with missing TLS certificate enforcement (CWE-295). The impact is confidentiality-only with no integrity or availability effect, and the attacker must already hold a foothold on the Windows host, which is why the assessed CVSS 4.0 base score is 6.8 (Medium) with a CVSS 3.1 assessment of AV:L/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N. No public exploit code or confirmed active exploitation was identified at time of analysis, and upgrading the client to 6.12.6 remediates the issue.
Stored cross-site scripting in the Content Egg plugin for WordPress before 11.9.0 allows an authenticated attacker holding contributor-level access or higher to plant arbitrary web scripts inside posts that the plugin creates under a more privileged author's identity. The root problem is a missing authorization check on the bulk content-import feature: the plugin never verifies that the acting user is permitted to use the import preset they select, and it then switches to that preset author's identity before the post is written, so the injected markup is stored and later executes in the browser session of anyone who views the content - most damagingly an administrator. No public exploit code has been identified at time of analysis, and the vendor has released a fix in version 11.9.0; exploitation requires the site to grant contributor accounts to untrusted users and requires a victim to view the tainted post.
Authenticated cross-site scripting in the Hostinger Reach WordPress plugin before 1.8.3 lets a user with contributor-level access or higher store an unsanitized widget setting that is rendered without escaping in the editor preview, executing arbitrary JavaScript in the session of a higher-privileged user (typically an administrator) who opens the crafted content in the WordPress editor. Exploitation is not remote-unauthenticated: it requires a foothold contributor account plus victim interaction, and the payload fires only inside the editor preview context rather than on the public front end. No public exploit code or KEV-listed active exploitation was identified at time of analysis, and this is best treated as a low-to-moderate real-world priority on multi-author sites where untrusted users can create content. Our independent assessment scores it CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N (6.8 from NVD is derived from a PR:H/S:U vector), reflecting an authenticated, interaction-dependent issue with limited confidentiality and integrity impact rather than an urgent threat.
Stored cross-site scripting in the Audio Player Block WordPress plugin (affected versions 1.1.0 up to but not including 1.6.3) lets a user with the Contributor role or higher save a post whose Audio Player block uses an unvalidated 'javascript:' style URL as its link target, so the payload executes in the browser session of the administrator or editor who later reviews and clicks that link. Exploitation is not automatic and not unauthenticated: it requires an authenticated low-privilege authoring account (Contributor+) and deliberate interaction by a more privileged victim, which is why our independent assessment rates the real-world risk as LOW-to-MEDIUM rather than the 6.8 score published by NVD. There is no confirmed active exploitation (CISA SSVC records Exploitation: none), no public exploit code identified at time of analysis, and a vendor patch is available in 1.6.3.
Stored XSS in EmbedPress before 4.6.7 lets authenticated users with Contributor role or above inject JavaScript through an Elementor widget setting that is not sanitized or escaped before being output into an HTML attribute. Exploitation requires the Elementor page builder to be active and a victim to view the affected content, and no public exploit or active exploitation is known at time of analysis. The independent assessment rates this as CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N, reflecting Contributor-level authentication, user interaction, and limited confidentiality and integrity impact.
A kernel-mode out-of-bounds write in the NVIDIA GPU Display Driver for Linux lets a local attacker who already holds high privileges corrupt kernel memory in the driver's kernel mode layer, which the vendor states may lead to code execution, denial of service, privilege escalation, information disclosure and data tampering. The flaw carries a CVSS 3.1 base score of 6.7 (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), meaning exploitation is strictly local and requires pre-existing elevated/administrative access on the host; there is no network attack vector and no user interaction is needed. Affected systems are Linux hosts running GeForce, RTX/Quadro/NVS or Tesla driver branches below the fixed releases published in NVIDIA security bulletin 5861, and there is no public exploit identified at time of analysis.
Out-of-bounds read in the firmware component of NVIDIA GPU Display Drivers for Windows and Linux allows a local attacker who already holds high privileges (PR:H, per CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) to read memory beyond intended firmware buffer bounds, most plausibly resulting in memory disclosure or a driver/GPU crash, with the vendor also flagging the potential for code execution, escalation of privileges and data tampering. The CVSS 3.1 base score is 6.7; the attack path is local-only, requires no user interaction, and is gated behind pre-existing high privilege, which materially limits real-world exposure. No public exploit code has been identified for this issue and it is not in CISA KEV, so no public exploit identified at time of analysis.
Code execution, privilege escalation, denial of service, information disclosure, and data tampering are all possible on Windows and Linux hosts running unpatched NVIDIA GPU Display Driver branches, because the kernel-mode layer fails to validate an array index (CWE-129) when processing a crafted GPU command. The flaw is strictly local: per the CVSS vector (AV:L, PR:H, UI:N) and our independent assessment, an attacker must already hold high privileges on the machine and be able to submit work to the GPU kernel driver, and there is no network or unauthenticated path. No public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so this is a genuine but moderate-priority hardening target for GeForce, RTX/Quadro/NVS, and Tesla deployments; fixed driver builds exist for each affected branch.
An out-of-bounds read in the kernel-mode layer of NVIDIA's GPU Display Driver for Windows and Linux can be triggered by a locally present attacker who already holds high privileges, potentially leading to kernel-context code execution, privilege escalation, denial of service, information disclosure, or data tampering. Exploitation requires local code execution at an elevated privilege level (CVSS vector PR:H) against a vulnerable driver build that is installed and loaded, so there is no remote or unauthenticated path and the practical risk is a defense-in-depth and privilege-boundary concern rather than an initial-access vector; no public exploit has been identified at time of analysis. NVIDIA has published fixed driver builds per product line and branch, and the affected install base spans GeForce, RTX/Quadro/NVS, and Tesla GPUs.
Denial of service in JetBrains YouTrack affects all builds before 2026.2.19197, where a project administrator can craft a notification template that drives uncontrolled resource consumption on the server. The requirement for an authenticated account holding project Admin rights (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H, score 6.5) confines realistic exposure to malicious or compromised administrators rather than ordinary or anonymous users, and the impact is limited to availability with no confidentiality or integrity loss. No public exploit code has been identified at time of analysis and the issue is not confirmed as actively exploited, though JetBrains has shipped a vendor patch in 2026.2.19197 and the flaw is tracked in ENISA EUVD as EUVD-2026-90018.
Two cluster-management operations in Kiteworks Core before 9.5.1 fail to validate attacker-supplied file paths, letting an attacker who already holds backend root on one node of a multi-node cluster write files as root onto another node and have them executed there. Exploitation is heavily gated: it is local-only (AV:L), requires pre-existing high privilege (PR:H, backend root), and depends on a software patch being simultaneously pending/staged on the target node to serve as the execution trigger - making this a lateral-movement and privilege-persistence primitive for an already-compromised cluster rather than an initial-access bug. This is a genuine but heavily gated post-compromise flaw, not a top-of-queue emergency; vendor patches are available and no public exploit code has been identified at time of analysis.
Code execution as the gateway service account can be achieved by a trusted party in a Kiteworks Email Protection Gateway cluster that has database replication enabled, via submission of a crafted serialized object that is deserialized without sufficient validation (CWE-502). The flaw is heavily gated: replication is disabled by default, so standard standalone deployments are not exposed, and the attacker must either control a trusted cluster peer or already hold administrative access to the appliance - meaning realistic exploitation is limited to insider abuse, post-compromise lateral movement, or a malicious administrator rather than opportunistic remote attack. All releases below 9.5.1 are affected, a vendor patch (9.5.1) is available, and no public exploit code or confirmed active exploitation was identified at time of analysis; the assessed CVSS is 6.6 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H), reflecting the high attack complexity and high privileges required.
Command injection in the optional repository-connector feature of Kiteworks Core allows an authenticated system administrator to append shell commands to a user-supplied path, resulting in code execution as the connector's service account and arbitrary file writes within that account's permissions. Only deployments running Kiteworks Core below 9.5.1 that have licensed and enabled the non-default repository connector are exposed, and successful exploitation additionally requires the appliance to be able to reach an attacker-controlled host over the network, as the injected command must pull or deliver content externally. Rated CVSS 6.6 (AV:N/AC:H/PR:H/UI:N/S:U/C:H/I:H/A:H); there is no public exploit code identified at time of analysis and the vulnerability is not confirmed actively exploited (no CISA KEV listing), so real-world risk is best characterised as LOW-to-MEDIUM despite the high-integrity/high-availability outcome, given the layered prerequisites of admin privilege, a separately licensed feature, and outbound egress.
Improper numeric conversion in NVIDIA vGPU Virtual GPU Manager for Linux can be triggered from the kernel-mode layer by a local attacker who already holds high privileges, potentially enabling code execution, denial of service, privilege escalation, information disclosure, or data tampering. The assessed CVSS 3.1 vector (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) shows the dominant constraint is PR:H: an unprivileged guest or local user cannot reach the vulnerable path, and only Linux vGPU Manager deployments are in scope. No public exploit or CISA KEV confirmation is identified at time of analysis; this is a genuine but not urgent issue requiring a privileged local actor.
An out-of-bounds read in the kernel-mode layer of NVIDIA's vGPU Virtual GPU Manager for Linux allows a local, already highly privileged user on the hypervisor host to drive the driver past the bounds of an allocated buffer, with the potential for kernel code execution, privilege escalation, information disclosure, denial of service, or data tampering. The issue is rated CVSS 3.1 6.7 (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) and is confined to Linux hosts running the Virtual GPU Manager in vGPU/VDI or cloud-GPU deployments; no public exploit has been identified at time of analysis. Because the attacker must already be authenticated with high privileges on the host and the attack surface is local-only, this is a moderate-priority, defense-in-depth issue rather than an urgent remote threat.
Improper input validation in NVIDIA GPU Display Driver firmware for Windows and Linux (GeForce, RTX/Quadro/NVS, and Tesla product lines) allows a locally positioned attacker who already holds high privileges to trigger code execution, denial of service, privilege escalation, information disclosure, and data tampering within the GPU firmware handling path. Scoring 6.7 (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H), the flaw is not remotely reachable and cannot be exercised by an unprivileged local user, so it is best characterized as a post-compromise privilege/kernel-boundary escalation rather than an initial-access vector. No public exploit code was identified at time of analysis and there is no indication of confirmed active exploitation; EPSS scoring was not provided in the available intelligence.
Local high-privileged attackers can exploit improper input validation in NVIDIA GPU Display Driver firmware on Windows and Linux to potentially achieve code execution, denial of service, privilege escalation, information disclosure, or data tampering. The assessed CVSS vector (CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H) confirms local access and high privileges (PR:H), so this is realistically a post-compromise escalation/persistence primitive rather than an initial-access vulnerability. No public exploit identified at time of analysis.
Improper input validation in the NVIDIA GPU Display Driver kernel-mode layer allows a local high-privileged attacker to achieve code execution, denial of service, privilege escalation, information disclosure, or data tampering. Affected products include GeForce, RTX/Quadro/NVS, and Tesla drivers on Windows and Linux. Exploitation requires administrator or root-equivalent access (PR:H), so risk is limited to scenarios where a high-privilege account is already compromised; no public exploit code is identified at time of analysis.
Improper input validation in the kernel-mode layer of the NVIDIA GPU Display Driver on Windows and Linux allows a local attacker who already holds high privileges to execute code, escalate privileges, disclose information, or crash the system. The flaw is not remotely reachable (AV:L) and requires existing HIGH privileges (PR:H) to reach the vulnerable kernel code path, with no user interaction needed; the resulting CVSS 3.1 base score is 6.7. There is no public exploit identified at time of analysis and no EPSS score or KEV listing was provided in the available intelligence, making this a moderate-priority local privilege-escalation/kernel-compromise primitive rather than an internet-facing emergency.
An out-of-bounds write in the firmware component of the NVIDIA GPU Display Driver for Windows and Linux lets a local attacker who already holds administrator or root privileges corrupt memory, with potential outcomes spanning code execution, escalation of privileges, denial of service, information disclosure and data tampering. Rated CVSS 6.7 (AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, CWE-787), the flaw affects GeForce, RTX/Quadro/NVS and Tesla products; exploitation requires local access to the host plus high existing privileges, and no public exploit code was identified at time of analysis, so real-world risk is moderate rather than urgent. No user interaction is required and there is no network attack path, which rules out remote exploitation entirely.
Out-of-bounds write in the NVIDIA GPU Display Driver for Linux kernel mode layer allows a local attacker who already holds high privileges (PR:H) to corrupt kernel memory, potentially achieving code execution, privilege escalation, denial of service, information disclosure, or data tampering. Affected driver branches cover GeForce, RTX/Quadro/NVS, and Tesla products below the fixed versions listed in NVIDIA's advisory, and the attack surface is local-only, so real-world risk is assessed as MODERATE-LOW. No public exploit identified at time of analysis.
Improper validation of an array index in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux gives a local, already highly privileged attacker a path to full loss of confidentiality, integrity, and availability on the host. The flaw affects driver branches for GeForce, RTX/Quadro/NVS, and Tesla products below the fixed versions published in NVIDIA bulletin 5861, including 580.178.04, 582.78, 595.91.07, 596.86, 610.60, 610.88, 615.71.09 and 616.92 depending on the product line. Exploitation requires local access (AV:L) and pre-existing high privileges (PR:H) to reach the kernel-mode driver interface, with no user interaction and no network vector, so this is a local privilege/kernel-escalation primitive rather than an initial-access vector; no public exploit has been identified at time of analysis. Real-world risk is MODERATE-LOW despite the full-CIA impact assessment, because the attacker must already be highly privileged before the flaw can be touched.
An out-of-bounds write in the kernel-mode layer of the NVIDIA GPU Display Driver for Windows and Linux allows a local attacker who already holds high privileges (PR:H) to corrupt kernel memory, with the potential for code execution, privilege escalation, information disclosure, denial of service, and data tampering. Affected installations are those running GeForce, RTX/Quadro/NVS, or Tesla display drivers at versions below the fixed release for their branch (for example prior to 610.88, 582.78, 616.92, or 580.178.04), on either Windows or Linux. The CVSS 3.1 base score of 6.7 reflects the non-network, high-privilege access prerequisite rather than broad exposure; no public exploit code has been identified at time of analysis.
Improper input validation in the NVIDIA GPU Display Driver kernel-mode layer can be triggered by a locally present attacker who already holds high privileges, potentially yielding kernel code execution, denial of service, privilege escalation, information disclosure, or data tampering on Windows and Linux hosts. The affected code base spans all three major product lines - GeForce, RTX/Quadro/NVS, and Tesla - and NVIDIA has published branch-specific fixed driver versions for each. There is no confirmed active exploitation (the issue is not in CISA KEV) and no public exploit code identified at time of analysis; the dominant real-world constraint is that PR:H means this cannot be used for initial access, only by an actor who has already obtained elevated privileges on the host.
An out-of-bounds read in the NVIDIA GPU Display Driver kernel-mode layer on Windows and Linux lets a locally authenticated attacker who already holds high privileges trigger an unbounded string operation that reads beyond the end of an allocated buffer, with vendor-acknowledged consequences including code execution, denial of service, privilege escalation, information disclosure, and data tampering. The flaw (CWE-125, CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H, base 6.7) affects GeForce, RTX/Quadro/NVS, Tesla, and vGPU guest driver builds below the fixed versions published in NVIDIA's 2026 advisory, and exploitation is strictly local - there is no network vector, no user interaction, and no non-default configuration requirement, only a privileged process on an affected host. Real-world risk is moderate and localized: no public exploit code has been identified at time of analysis and the issue is not listed in CISA KEV, so value to an attacker is mainly as a local privilege-escalation or kernel-tampering primitive after an initial foothold.