Command injection in the Netcore NBR200V2 router's firmware upgrade CGI endpoint (/www/cgi-bin/upgrade) allows authenticated administrative attackers to execute arbitrary shell commands by manipulating the QUERY_STRING parameter. The flaw affects firmware version 1.3.241127.071246, and publicly available exploit code exists. The vendor did not respond to disclosure, so no official fix is available; exploitation requires reaching the admin interface, which is typically LAN-only unless remote management is enabled.
Command injection in the Netcore NBR200V2 router (firmware 1.3.241127.071246) allows an authenticated attacker who can reach the web management interface to run arbitrary shell commands on the device by manipulating the QUERY_STRING argument processed by restore.cgi in the Backup Restore component. The flaw is network-reachable, requires only low privileges (CVSS PR:L) with no user interaction, and produces high confidentiality, integrity and availability impact - on embedded routers this typically equates to root-level control of the device's OS. Publicly available exploit code has been released and the vendor did not respond to the disclosure, so no patch is available; the CVE is not listed in CISA KEV, meaning active exploitation has not been confirmed.
Elevated-privilege container restoration in CRI-O 1.34 and later, including downstream Red Hat OpenShift Container Platform 4.17+, lets an authenticated Kubernetes user who can create a pod from a crafted checkpoint image bypass the destination pod's security context. The restored process keeps credentials, Linux capabilities, no_new_privs and seccomp state stored in the checkpoint instead of the destination configuration, allowing execution across the container security boundary. Exploitation requires non-default checkpoint/restore (CRIU) support to be enabled and RBAC permission to create pods from malicious checkpoints; no public exploit code is identified and no vendor-released fix is available at time of analysis, so the vendor CVSS 3.1 score of 8.8 overstates urgency given those prerequisites (our assessment raises attack complexity to High).
Authenticated clients on deepstream.io 10.1.0 can bypass record-write authorization and modify arbitrary protected records, corrupt application state, or cause service disruption when the server is configured with permission.type 'config'. The root cause is an omitted PATCH_MULTI entry in the permission rules map, which makes the config permission engine treat the absent rule specification as an unconditional allow instead of requiring write permission. Any user holding valid credentials can exploit this remotely with no user interaction (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:H per independent assessment), and no public exploit code has been identified at time of analysis; deployments using the default permission.type 'none' already permit all operations and are not additionally affected.
Denial of service in Temporal Server allows an authenticated caller holding at least namespace read permission to crash the receiving Matching process by submitting a malformed MySQL version comment through the ListWorkers API when that API is enabled. The root cause is in the bundled temporalio/sqlparser Go library, where ExtractMysqlComment fails to validate the -1 returned by strings.IndexFunc before using it as a slice boundary, producing an unhandled Go runtime panic whenever a '/*! ... */' comment has empty contents or one to five decimal digits. Impact is availability-only (process termination, repeatable to sustain an outage) with no confidentiality or integrity effect; no public exploit identified at time of analysis, and exploitation is gated on both API enablement and authenticated namespace read access.
Authenticated users can exploit a missing authorization check in jshERP 3.6 and earlier to manipulate userBusiness authorization-relation rows, enabling privilege escalation, access revocation, or role-function modification for any tenant user. Publicly available exploit code exists (POC), and while no active exploitation has been confirmed, the flaw is network-reachable, low-complexity, and requires only a low-privileged account, posing significant risk. The vulnerability is rooted in CWE-862 (Missing Authorization).
Authenticated account takeover in jshERP through 3.6 allows any logged-in user to reset the password of any other account, including administrators, by issuing POST /user/resetPwd with an arbitrary target user ID. Because the endpoint performs no ownership or authority check on the supplied user ID and resets the victim's password to a known default value, an attacker holding even the lowest-privilege credentials can seize administrative control of the application. Publicly available exploit code exists (a Python PoC), and while there is no confirmed active exploitation (CISA KEV) or exploitation telemetry, the flaw is trivial to trigger and needs no user interaction, making insider or low-privilege-credential exposure the primary risk.
Privilege escalation in jshERP 3.6 allows an authenticated low-privilege tenant user to grant themselves arbitrary roles, including tenant administrator, by sending a crafted POST request to the updateOneValueByKeyIdAndType endpoint with type=UserRole, their own user ID, and a role ID list. The endpoint applies no ownership or privilege validation (CWE-862), and publicly available exploit code exists. Exploitation requires only a valid low-privilege session; no victim interaction or special configuration is needed, and no CISA KEV listing is present in the provided data to confirm active exploitation.
Authenticated users of jshERP through 3.6 can read, modify, and delete other users' business objects - such as materials - by supplying direct object identifiers to by-id info, update, and delete endpoints that lack ownership checks (CWE-639). Exploitation requires a valid low-privileged account (PR:L per the CVSS vector) and network access to the affected API; publicly available exploit code exists, and object IDs are likely enumerable, though CISA KEV does not list active exploitation. With a CVSS 4.0 base score of 8.7, the flaw is a moderate-to-high priority for multi-user or multi-tenant deployments, while single-user instances have little data to expose.
Privilege escalation in jshERP through 3.6 lets any authenticated user - including one holding only a low-privileged tenant account (CVSS PR:L, no administrative rights, user interaction, or non-default configuration required) - modify or delete arbitrary role definitions through the /role/update and /role/delete endpoints in RoleController, which perform no caller-permission checks. Successful abuse allows an attacker to widen a role's data scope to 'all data', delete roles, and consequently read every business record in the tenant. Publicly available exploit code exists (a proof-of-concept script has been published); there is no indication of confirmed active exploitation (not in CISA KEV), and no vendor-released fixed version has been identified from the available data, making this a genuine, actionable priority within its limited install base.
Authenticated buffer overflow in the Netcore NBR200V2 router's management daemon (/usr/bin/routerd) allows a low-privilege logged-in user to corrupt memory and potentially achieve code execution or a denial of service by supplying a manipulated vlan_wanX.ports argument to the WAN VLAN reconfiguration function wan_config_set_vlan. Only firmware build 1.3.241127.071246 has been confirmed affected, and publicly available exploit code exists; there is no confirmed actively exploited (CISA KEV) status and no vendor patch, as Netcore did not respond to the disclosure. This is a classic high-CVSS-but-modest-real-risk embedded-router flaw: it requires an authenticated session (PR:L in the assessed CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H vector), the specific WAN VLAN reconfiguration code path must be exercised, and the affected management interface is typically LAN-side rather than internet-facing, which constrains realistic remote reach.
Buffer overflow in the Netcore NBR200V2 router (firmware 1.3.241127.071246) allows an authenticated, low-privileged attacker who can reach the device's management interface to corrupt memory through the wan_num argument processed by vlan_load_form_uci in /usr/bin/routerd, with high impact to confidentiality, integrity and availability. Publicly available exploit code exists, and the researcher published the details after the vendor did not respond to early notification; no CISA KEV listing or EPSS score was supplied at time of analysis. Exploitation is gated by a valid credential/session and by exposure of the configuration handler, which on consumer and SMB routers is normally LAN-side by default, and requires no user interaction.
Local privilege escalation in the BioStar Temperature Monitor Utility (1.2.1806.2200, all versions flagged by CPE) lets a low-privileged process on an affected Windows host write attacker-controlled data to an arbitrary physical address through the bundled BS_HWMIO64_W10.sys kernel driver, escalating to SYSTEM and gaining full control of the machine. According to the assessed CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), exploitation requires local low-privilege code execution able to open the driver's device object and send the crafted IOCTL, with no user interaction and no non-default configuration once the signed driver is loaded. Publicly available exploit code exists (the CVSS 4.0 vector carries E:P and the disclosure states the exploit was released publicly), but there is no indication of confirmed active exploitation in the wild and no CISA KEV listing; the vendor was contacted and did not respond, so no vendor patch was identified at time of analysis.
Local privilege escalation in BioStar BIOS Update Utility 1.9.7.3 enables a low-privileged local attacker to gain kernel-level code execution on Windows via a write-what-where condition in the BSMEM64_W10.sys driver. The driver's IOCTL handler (sub_110BC) fails to validate user-supplied PhysicalAddress and Size parameters, resulting in arbitrary physical memory writes. Publicly available exploit code exists, and the vendor has not responded to disclosure, leaving no official fix at time of analysis.
Telegram Desktop before 6.9.4 fails to escape inline-keyboard button text when a chat is exported to HTML, so attacker-controlled button captions are written verbatim into the generated file and execute as script when the victim opens that HTML in a browser. Exploitation is tightly gated: the victim must have used the HTML export feature, must have an attacker-crafted message forwarded into a group they belong to (the original author does not need to be a group member), and must then open the resulting HTML file locally. Publicly available exploit code exists (an expatch.com writeup), but there is no confirmed active exploitation (not in CISA KEV); the vendor scores it 8.3 High under CVSS 4.0, while an independent reassessment places it lower as a user-interaction-gated, scope-changed XSS with limited confidentiality and integrity impact (CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N).
Unauthenticated administrator account creation in nginx-ignition affects deployments running versions prior to 2.41.1 that are still in their pre-onboarding state. The endpoint POST /api/users/onboarding/finish is registered as anonymous and, because its "onboarding already completed?" check is not atomic with the subsequent user write, a remote unauthenticated attacker (CVSS 3.1 vector: AV:N/AC:H/PR:N/UI:N, base 8.1) who can reach such an instance can create a full ReadWrite administrator account for themselves, and concurrent requests can create multiple admin accounts in a single race. No public exploit identified at time of analysis, and the practical window is narrow: exploitation requires the instance to be network-reachable while deployed but before a legitimate operator has completed onboarding - once onboarding is legitimately finished, the path is guarded.
Authorization bypass in Tinyauth releases prior to 5.1.2 allows an authenticated, low-privilege user to reach applications whose per-app access controls are configured to exclude them. Tinyauth matches forwarded hostnames case-sensitively in lookupStaticACLs/GetAccessControls and in the Docker-label fallback (GetLabels), while nginx, Traefik, and Caddy route hostnames case-insensitively; requesting the target app with a differently-cased hostname therefore misses the configured policy, returns an empty access-control object, and proxyHandler treats the empty user/group/OAuth/LDAP/IP restrictions as permissive. Exploitation requires valid low-privilege credentials (CVSS PR:L) and a deployment that enforces per-app ACLs behind a case-insensitive proxy; unauthenticated visitors are still stopped at login and global login-time allowlists are not bypassed. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, and the vendor-released fix is version 5.1.2.
Credential-holding attackers can completely bypass TOTP two-factor authentication on Sync-in Server versions prior to 2.4.0 by sending a single unauthenticated-looking request to POST /api/auth/token, which issues full access and refresh JWTs without ever checking the account's twoFaEnabled flag. The flaw is only exploitable by an authenticated party in the sense that the attacker must already hold a valid username and password obtained through phishing or credential theft (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N, base 8.1), and it only yields an advantage against accounts that actually have TOTP enabled; the parallel POST /api/auth/login endpoint enforces the second factor correctly. No public exploit code was identified at time of analysis and CISA KEV does not list this CVE, but because the bypass converts stolen passwords directly into long-lived session tokens, the practical risk is high wherever 2FA is the last line of defense.
Unauthenticated denial of service in nginx-ignition 2.29.0 through 2.40.0 lets any remote client that can reach the management API burn roughly 2.4 seconds of server CPU per request by sending a GET whose Accept-Language header is built from underscore-separated malformed language tags, since the gin i18n middleware parses the raw header unconditionally with no size or shape limit. Impact is availability-only (CVSS 3.1 7.5, AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H): ten concurrent attackers saturate a ten-core host for the duration of the attack while consuming about 10 MiB/s of upstream bandwidth, with no path to data access or code execution. No public exploit code identified at time of analysis and no CISA KEV entry; the vendor-released patch 2.40.1 fixes the issue.
DesktopSMS 1.11.0 (MrPear) exposes a local/loopback service that performs privileged SMS operations - sending messages, returning SMS-derived content, and persisting a paired identity - without any pairing confirmation, authentication, or user interaction, so any process already running on the same device can exercise the victim app's SMS permissions. Exploitation is strictly local: an attacker must first have code execution on the device (a co-installed malicious app, or ADB/loopback access), which is why the assessed vector is AV:L with PR:N and UI:N but a hard device-foothold prerequisite. Publicly available exploit code exists (a proof-of-concept client has been published), and while no confirmed active exploitation is recorded, the low complexity and absence of user interaction make this a practical post-foothold privilege-escalation primitive against the app's SMS capabilities.
jshERP through 3.6 exposes unsalted MD5 password hashes via the /user/info endpoint, allowing any authenticated user to retrieve password digests for arbitrary users by supplying their user IDs. This information disclosure (CWE-200) affects all versions up to 3.6, and publicly available exploit code exists. Attackers with a low-privilege account can enumerate user IDs to obtain hashes, which can be cracked offline to recover plaintext passwords, potentially leading to full account takeover for weak passwords. The assessed CVSS 3.1 vector is AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N, reflecting the need for authentication and the high confidentiality impact.
Authenticated profile tampering in dromara lamp-cloud through 5.10.0 lets any logged-in user overwrite other users' profile records - nickname, ID card, sex, nation, education, work description and avatar attachment - by supplying a victim's user ID in the body of a PUT request to /anyone/baseInfo or /anyone/avatar. The root cause is a broken object-level authorization (BOLA/IDOR, CWE-639) in the lamp-oauth UserInfoController, which takes the target identity from attacker-controlled request data instead of the authenticated session; exploitation requires only a low-privilege account (CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N, no user interaction) and is scored 7.1 with impact confined to integrity. Publicly available exploit code exists (two Python BOLA proof-of-concept scripts published alongside the VulnCheck advisory), while no confirmed active exploitation (CISA KEV) is reported for this issue at time of analysis.
Authenticated users of lamp-cloud (dromara/lamp-cloud) through version 5.10.0 can permanently delete notifications belonging to other users by calling DELETE /anyone/extendNotice/deleteMyNotice with arbitrary notice IDs, because the endpoint deletes by the attacker-supplied key without verifying that the notice belongs to the requester. Any low-privilege account with network access to the application is sufficient - no administrative role and no user interaction are required (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L) - and because notice IDs appear to be sequential/enumerable, a single authenticated user can systematically purge the notification records of other tenants/users. Publicly available exploit code exists (a PoC script targeting the notice-delete BOLA was published in the LinYuanyi1/cve-request-poc repository and reported by VulnCheck), though the impact is bounded to integrity and availability of the notice subsystem with no data disclosure.
Authenticated users of Dromara lamp-cloud through 5.10.0 can download other users' stored attachments by supplying a valid attachment identifier to the /anyone/file/down or /anyone/file/download endpoints in FileAnyoneController, which never validate the file's created_by owner column against the requesting principal (CWE-639, IDOR/BOLA). The flaw is network-reachable and low-complexity, requires only a low-privilege authenticated account and no user interaction, and yields high confidentiality impact with no integrity or availability effect; it is rated 7.1 under CVSS 4.0 (assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N). Publicly available exploit code exists (a Python proof-of-concept published on GitHub), but the issue is not listed in CISA KEV, so no confirmed active exploitation is established at time of analysis.
Authenticated users on any Dromara lamp-cloud deployment up to and including 5.10.0 can read the complete profile of every other user by calling the getUserInfoById endpoint with an arbitrary userId, exposing mobile numbers, email addresses, national identity card numbers, and WeChat/DingTalk OpenIDs. The flaw is a classic object-level authorization bypass (CWE-639) requiring only a valid low-privileged account - no elevated role, user interaction, or non-default configuration - and publicly available exploit code exists (a Python BOLA PoC in the LinYuanyi1/cve-request-poc repository), so userIds can be enumerated at scale to harvest PII. There is no confirmed CISA KEV entry and no evidence of active exploitation; the risk is best characterized as a moderate, not urgent, priority driven by the high confidentiality impact and the low-effort, automatable nature of the enumeration, tempered by the relatively small footprint of this open-source Spring Cloud framework. Vendor-released patch: none identified at time of analysis.
Missing authorization in jshERP through version 3.6 lets authenticated low-privilege users rewrite or delete tenant-wide system configuration through the systemConfig endpoint, because SystemConfigService.updateSystemConfig performs no privilege check. Successful abuse corrupts the integrity of company identity, stock rules, approval behavior, and printing configuration, with a secondary risk of disrupting tenant operations; there is no confidentiality exposure reported. Exploitation requires only a valid low-privilege tenant account (no user interaction or non-default configuration), and publicly available exploit code exists, so the practical threat is mainly malicious insiders or holders of compromised or self-registered accounts. Rated 7.1 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:L) and tracked as CWE-862, this is a genuine but moderate-priority issue rather than a critical emergency.
Account fixation in Hatchet's OAuth callback handling lets an unauthenticated attacker bind a victim's existing Hatchet session to an OAuth identity the attacker controls, achieving login CSRF and account takeover. The flaw affects Hatchet versions prior to 0.91.1 and is only reachable when the deployment has enabled at least one OAuth integration (auth.google.enabled, auth.github.enabled, or the Slack integration) and the victim has already completed an OAuth flow in the current browser session; exploitation still requires victim interaction (the victim's browser must follow the attacker's crafted callback URL containing an empty state parameter and the attacker's own authorization code). The vendor-released patch is version 0.91.1 (upstream commit f90464189ad642251e09412d0f99fde353036428); there is no indication of confirmed active exploitation (no CISA KEV listing) and no public exploit code identified at time of analysis, although the upstream fix ships an integration test that documents the bypass chain.
Code execution with access to GCP, AWS, and Snowflake credentials is possible in Feast's own CI pipeline prior to version 0.65.0, because the pr_integration_tests.yml workflow uses pull_request_target together with the synchronize event and preserves ok-to-test, approved, or lgtm labels on newly pushed commits. A fork contributor can get maintainer approval for a benign revision and then push altered commits that are checked out from refs/pull/${{ github.event.pull_request.number }}/merge and run through privileged make targets, resulting in runner code execution, credential disclosure, and possible access to downstream cloud resources; the CVSS vector indicates the attacker needs only a low-privilege GitHub identity (PR:L) plus a maintainer's approval action (UI:P), and no public exploit code was identified at the time of analysis. This is a CI/CD pipeline misconfiguration in the upstream feast-dev/feast repository rather than a flaw in deployed Feast installations, and it is fixed in 0.65.0.
Heap-based buffer overflow in X.Org libXrender before 0.9.13 allows a malicious or compromised X server to inject and execute arbitrary code in attached X11 clients via a crafted response to the RenderQueryPictFormats request. This is a reverse-direction attack where the victim must actively connect a vulnerable X11 client (linked against libXrender < 0.9.13) to an attacker-controlled or hijacked X server - typical exposure is via SSH X11 forwarding to an untrusted host or a remote DISPLAY connection; local trusted X servers are not affected. No public exploit code has been identified at time of analysis, and exploitation is non-trivial (AC:H) with no attacker authentication required (PR:N), but an upstream fix is available and the CVE description identifies 0.9.13 as the fixed version boundary.
Persistent root command execution in luci-app-adblock-fast prior to 1.2.4-2 on OpenWrt: an authenticated LuCI user who has been granted the component's write ACL can abuse the luci.adblock-fast.setCronEntry RPC by embedding carriage-return or line-feed characters in the entry argument. Because the value is serialized into /etc/crontabs/root as if it were a single line, the delegated user can create an additional physical cron entry that runs as UID 0 when cron executes. The CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H (8.8 High) is directionally sound but materially gated by the mandatory pre-existing luci-app-adblock-fast write ACL and by cron actually running; exploitation is not demonstrated for unauthenticated users or users lacking that ACL. No public exploit identified at time of analysis, and the vendor fix is 1.2.4-2.
Shell command injection in KubeEdge's v1alpha2 NodeUpgradeJob upgrade workflow allows an authenticated user who holds RBAC permission to create or update NodeUpgradeJob resources to run arbitrary commands on targeted edge nodes with the privileges of the edge upgrade process. Affected deployments are those running KubeEdge 1.12.0 through 1.21.1, 1.22.0/1.22.1, or 1.23.0 that actually process node-upgrade tasks; the vulnerability is high-priority and genuine rather than a CVSS-inflated finding, but it is gated on the NodeUpgradeJob create/update privilege (PR:L, not anonymous) so it is not reachable by unauthenticated users or on clusters that do not grant that permission. No public exploit code and no confirmed active exploitation were identified at time of analysis; EPSS/KEV data were not supplied for this CVE. Vendor-released patches exist in 1.21.2, 1.22.2, and 1.23.1.
Authenticated command injection in KubeEdge (1.21.0 up to 1.21.2, 1.22.2, and 1.23.1) lets a principal holding Kubernetes RBAC rights to create or modify ConfigUpdateJob resources inject shell metacharacters into the updateFields passed to the keadm config-update command, which the edge taskmanager then runs through a system shell, yielding arbitrary command execution on the enrolled target edge node with the privileges of the KubeEdge process. The vendor rates this 8.8 (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H), and our independent assessment is slightly more severe because compromise of the node process is a scope change (S:C); the PR:L vector confirms the attacker must be authenticated and authorized, so this is not anonymous or remotely unauthenticated abuse. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, but the flaw is a genuine, actionable CWE-78 issue rather than an inflated score, and it is fixed in KubeEdge 1.21.2, 1.22.2, and 1.23.1.
Authenticated delegated LuCI sessions that hold the luci-app-advanced-reboot read ACL can execute arbitrary commands as root on affected OpenWrt routers, because that read ACL grants rpcd file.exec permission for the general shell interpreter /bin/sh and passes caller-controlled parameters to it. Only builds that actually ship this /bin/sh exec grant prior to version 1.1.2-6 are vulnerable; the vendor explicitly states the checked openwrt-24.10 and openwrt-23.05 branches do not carry the grant and are not affected by this chain. Exploitation requires a valid low-privilege delegated rpcd/LuCI session (CVSS vector PR:L, no unauthenticated path), and no public exploit code was identified at time of analysis; the issue is fixed in 1.1.2-6.
Conda versions prior to 26.5.2 will follow an unvalidated entry-point command from a noarch:python package's info/link.json and write the generated executable wrapper to a path that can escape the installation prefix or overwrite a different in-prefix entry point, a classic CWE-22 path traversal in the package installation workflow. The victim must install the malicious package themselves (UI:R) and the resulting code runs with the installing user's privileges rather than elevated rights; the out-of-prefix variant additionally requires the destination parent directory to already exist, while the overwritten-entry-point variant only detonates when that entry point is later invoked. CVSS 3.1 rates this 8.8 (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H) and no public exploit has been identified at time of analysis.
OS command injection in ntopng prior to 6.7.260717 allows an authenticated non-administrator user to run arbitrary operating-system commands as the ntopng process account, because the vulnerability-scan REST endpoints accepted the scan_ports parameter without an administrator check and passed it through a validator that still permits shell metacharacters. Exploitation requires nmap to be present on the host, and a secondary no-credentials path exists: the affected endpoints accept GET requests while ntopng's CSRF validation only covers POST bodies, so a logged-in victim's browser can be induced to trigger the command. The vulnerability is rated CVSS 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 or KEV-listed active exploitation was identified at time of analysis, and the issue is fixed in 6.7.260717.
A crafted, attacker-controlled serialized graph payload processed by FalkorDB 4.20.1 through 4.20.4 overflows a buffer in the GraphBLAS matrix decoder (_Decode_GrB_Matrix in /v19/decode_matrix.c), crashing the Redis module process and denying service to the instance. Reaching the flaw requires an authenticated network connection to the FalkorDB/Redis port (CVSS PR:L) plus the ability to submit matrix data into the decode/restore path; no user interaction is needed, and the confirmed outcome is a process-crash DoS rather than code execution or data disclosure. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the vendor-published CVSS 8.8 (C:H/I:H/A:H) overstates impact relative to the availability-only assessment.
Authenticated non-administrator users of ntopng prior to 6.7.260718 can list and download complete system-configuration backups through the REST v2 endpoints get/system/configurations/list_available_backups.lua and download_backup.lua, which lack the administrator authorization check that the vendor's fix adds. Because the backup payload includes the ntopng.user.* Redis key space, the downloaded archive routinely discloses local-user password hashes and, on deployments where those features are configured, API tokens, TOTP secrets and WebAuthn credential material - enabling account takeover via usable or crackable credentials. Exploitation requires only a valid low-privileged login (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N per independent assessment, PR:L means authenticated but not administrative), with no user interaction and no non-default configuration; no public exploit code or active-exploitation activity (CISA KEV) was identified at time of analysis. The vendor's own CVSS of 8.8 with I:H/A:H is judged slightly overstated, since the flaw is an information-disclosure primitive rather than direct integrity or availability loss.
Authenticated remote code execution affects the Jazzware RT1000 Edge webUI version 20.0.1, where the upgrade-package upload feature accepts server-side executable files and stores them in a web-accessible, executable directory that can be invoked directly over HTTP without authentication. An attacker who already holds valid webUI credentials (CVSS vector PR:L) can reach the upload function, place a malicious executable, and trigger it remotely, yielding full compromise of confidentiality, integrity, and availability (CVSS 8.8). Exploitation status: no public exploit identified at time of analysis; the CVE is not in CISA KEV, and EPSS is low at 0.24% (16th percentile), reflecting the niche target and the credential prerequisite rather than weak impact.
Unauthenticated remote denial of service in github.com/temporalio/tchannel-go (the Go implementation of the TChannel RPC protocol) before v1.22.1 lets any network peer that can complete the standard TChannel initialization handshake crash the hosting process. A crafted call fragment that carries checksum metadata but contains no length-prefixed argument chunks leaves the fragment reader's chunk slice empty, and the unconditional selection of the first element triggers an unrecovered Go slice-bounds panic on a library-created dispatch goroutine, terminating the process. There is no confidentiality or integrity impact, exploitation requires network reachability to a TChannel listener exposed to untrusted peers, and no public exploit code was identified at time of analysis (not confirmed actively exploited / not in CISA KEV); the assessed CVSS:3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H.
Denial of service in Temporal Server stems from uncontrolled recursion (CWE-674) in the bundled temporalio/sqlparser library: SQL containing deeply nested unary expressions is accepted and produces a correspondingly deep abstract syntax tree, and the library's recursive String and Walk traversals then exhaust the Go stack and abort the process in a way that Go panic recovery cannot contain. Affected are Temporal Server deployments prior to v1.30.7 and v1.31.3 that pass caller-controlled query text to the parser through the archival, visibility, and worker-query paths, including validation code that recursively formats an invalid expression while constructing an error. Exploitation requires an authenticated caller holding namespace read permission (the published CVSS 4.0 vector lists PR:N, but the reported prerequisites specify an authenticated caller and the independent assessment scores PR:L), the dynamically confirmed ListWorkers route additionally requires at least one retained worker heartbeat, and repeated requests can sustain the outage; impact is availability-only and no public exploit code or confirmed active exploitation was identified at time of analysis.
Unauthenticated network peers that can reach a live Ringpop TChannel/SWIM gossip listener can drive memory and gossip-bandwidth exhaustion in github.com/temporalio/ringpop-go, because peer-supplied label maps are retained and re-disseminated without being checked against the application's configured LabelOptions limits. Applications that use ringpop's label feature are affected; repeated membership changes for distinct member addresses carrying oversized label keys, values, or counts inflate the member list and propagate to the whole cluster, degrading and potentially taking down the hosting process (availability only, no confidentiality or integrity impact). Exploitation requires network reachability to the gossip/TChannel port - typically an internal cluster interface - and there is no public exploit identified at time of analysis, though the assessed severity (CVSS 3.1 base 8.7, PR:N, A:H) makes the exposure of that port the decisive risk factor.
Remote denial of service in temporalio/tchannel-go allows any network peer that can reach a TChannel listener to crash the hosting process: after completing the standard TChannel initialization handshake, the peer sends a call frame whose one-byte checksum-type field carries an unsupported value, which the parser uses directly as an index into a four-entry checksum pool and thereby triggers an unrecovered Go panic on the connection's read goroutine. Only availability is affected (the assessed vector is AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H with no confidentiality or integrity impact), and exploitation is unauthenticated with no user interaction, requiring only that a TChannel listener be reachable by untrusted or multi-tenant peers rather than confined to a trusted internal mesh. No public exploit code or confirmed in-the-wild exploitation has been identified at time of analysis; a vendor patch is available and the issue is fixed in v1.22.1 (PR #14), so priority is driven almost entirely by listener exposure.
OS command injection in Dassault Systèmes Tuleap Enterprise Edition versions 17.3 through 17.5 allows an authenticated remote attacker with a low-privilege account to execute arbitrary operating system commands on the server, as indicated by CVSS 3.1 vector AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H and a base score of 8.8. No public exploit identified at time of analysis, and the vulnerability is not listed in CISA KEV; however, the potential for full server compromise makes this a genuine high-priority issue that is not a drop-everything emergency. Instances are only affected if they run versions 17.3-17.5 and permit low-privilege authenticated access, so environments with tightly controlled account provisioning or network restrictions face reduced exposure.
Authenticated callers holding only a write role in a single namespace can execute arbitrary commands on the host running Temporal Server's Worker Service, because the built-in `subprocess` compute provider derives the program name and argument vector from caller-supplied compute provider configuration instead of operator configuration, and the configuration handler invokes it immediately after spec validation with no scaling decision or task arrival required. Deployments are affected when running Temporal Server 1.31.0 through 1.31.2 with the Worker Service active and the per-namespace dynamic config `workercontroller.compute_providers.enabled` either unset (the default, in which case the allowlist check is skipped entirely) or explicitly containing `subprocess`; authentication with a namespace write role is required (CVSS vector PR:L), and a deployment with no authorizer is already fully open rather than being a special case of this flaw. Since the Worker Service process holds persistence credentials for every namespace in the cluster plus the cluster TLS material, successful exploitation reaches beyond the caller's namespace to the cluster as a whole, making this a genuine high-priority issue rather than CVSS inflation. Vendor patches are available in releases 1.31.3 and 1.32.0, and no public exploit was identified at time of analysis.
GPU memory exhaustion in vLLM through 0.29.0 allows remote, unauthenticated attackers to permanently leak GPU KV cache blocks by submitting completion requests containing multiple prompts whose concurrent child requests share a single Mooncake transfer ID. The leak is only reachable in prefill/decode (P/D) disaggregated deployments that have the Mooncake KV-transfer connector enabled - a non-default topology in which the vulnerable ownership bookkeeping runs - and orphaned blocks are never reclaimed until the vLLM process is restarted, progressively starving legitimate inference requests of GPU memory. No public exploit code has been identified at time of analysis and the flaw is not listed in CISA KEV, though the attack is network-reachable, low-complexity, and requires no authentication or user interaction (CVSS 4.0 8.7; independent assessment scores the availability-only impact as CVSS 3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H).
Memory exhaustion in vLLM through 0.29.0 lets remote, unauthenticated attackers crash the inference service by supplying an arbitrary 'tp_size' value inside the 'kv_transfer_params' field of requests to the OpenAI-compatible completion endpoints. Because kv_transfer_params is honored only when the server runs in a prefill/decode (P/D) disaggregated deployment using the NIXL KV-transfer connector, the attacker causes unbounded memory allocation in the decode worker that ends in a kernel OOM-kill and full loss of service availability; confidentiality and integrity are unaffected. No public exploit code was identified at time of analysis and there is no CISA KEV listing, but the flaw is trivially reachable over the network (CVSS 4.0 8.7, AV:N/AC:L/PR:N/UI:N/VA:H), and an upstream fix exists as pull request 51137.
Denial of service in vLLM through 0.29.0 lets unauthenticated remote attackers crash the EngineCore and halt all inference by feeding arbitrary remote host and port values through kv_transfer_params when the P2P secondary KV-offload tier is enabled. Each bogus peer address causes the server to allocate a ZeroMQ socket for an unreachable peer session; because no limit is enforced on concurrent sessions, the sockets accumulate until the context quota is exhausted and an uncaught ZMQError terminates the engine (CWE-770, unlimited resource allocation). Exploitation is gated on a non-default configuration - OffloadingConnector configured with TieringOffloadingSpec plus a p2p secondary tier - and availability is the only affected property; an upstream fix exists in pull request 51504, but no public exploit code has been identified at time of analysis.
Denial of service in vLLM through 0.29.0 allows an unauthenticated remote attacker to crash the NIXL decode worker by submitting a single OpenAI-compatible completion request containing multiple prompts of differing lengths together with kv_transfer_params. The crash occurs in NixlBaseConnectorWorker._apply_prefix_caching, where block-count mismatches between the decode and prefill sides hit a reachable assertion (CWE-617); the decode worker terminates and stays unavailable until manually restarted, so a low-effort request loop can repeatedly take serving capacity offline. Impact is confined to availability (CVSS 4.0 8.7, AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H), with no confidentiality or integrity effect, and exploitation is gated on a non-default prefill/decode DISAGGREGATED topology that uses the NIXL KV-transfer connector - standard single-node vLLM serving is not affected. No publicly available exploit code and no confirmed active exploitation (CISA KEV) were identified at time of analysis, though the trigger is a trivially crafted multi-prompt API call.
Denial of service in vLLM through 0.29.0 allows an unauthenticated remote attacker to crash the decode engine by sending a single inference request whose kv_transfer_params dictionary is incomplete, for example containing only {"do_remote_prefill": true} without the required remote_block_ids, remote_engine_id, remote_request_id, remote_host, and remote_port fields. The malformed metadata raises an uncaught KeyError inside EngineCore scheduling (CWE-248) during add_new_req_to_recv, terminating the decode engine and causing every subsequently routed request to fail until an operator manually restarts it, yielding a vendor CVSS 4.0 score of 8.7 (VA:H, C/I both N). Exposure is limited to deployments running prefill/decode disaggregated mode with the NIXL connector, which is a non-default serving configuration; standard single-node vLLM never processes kv_transfer_params on this path. No public exploit code and no confirmed active exploitation were identified at time of analysis, though the upstream fix and regression tests are public in PR #54807.
Denial of service via memory exhaustion affects Zapros, the Python HTTP client, in all releases prior to 0.14.0. An unauthenticated remote attacker who controls, or can man-in-the-middle, the origin server can return a small compressed response that the built-in decompression decoder inflates far beyond the caller-supplied bound, because iter_bytes(chunk_size=...) and its default are ignored during decoding - a single chunk can therefore exhaust process or host memory (CVSS 4.0 8.7 High, availability-only: VA:H, VC:N, VI:N, PR:N, UI:N). The vendor released a fix in 0.14.0, and no public exploit code or confirmed active exploitation was identified at time of analysis.