Unauthenticated arbitrary file upload in the Web to Print Online Designer WordPress plugin (versions 1.7.0 through before 2.15.0) allows any remote visitor to obtain the token that protects the plugin's upload handler and then push arbitrary files, including PHP scripts, into a web-reachable location - resulting in remote code execution with total confidentiality, integrity, and availability impact (CVSS 9.8). No authentication, user interaction, or non-default configuration is required; the plugin simply fails to validate file type or extension and discloses the upload token to anonymous requesters. Publicly available exploit code exists, so weaponization against exposed installations is a realistic short-term risk, although the vendor (WPScan-reported) has shipped a fix in 2.15.0 and EPSS currently rates near-term exploitation probability low at 0.14% (4th percentile), tracking the plugin's comparatively small install base.
Stored cross-site scripting and open redirect in Warpgate's SSO endpoints (versions prior to 0.25.5) allow an unauthenticated remote attacker to inject markup and JavaScript into the authenticated Warpgate origin. The attacker stores an arbitrary 'next' parameter via /@warpgate/api/sso/providers/:name/start, which the return handler later reflects without HTML escaping; the victim must follow the crafted link and complete an SSO login before the payload executes. Successful exploitation grants access to session data and user-level APIs, escalating to administrator APIs when the victim is a Warpgate administrator, and the same unvalidated value enables an open redirect via the GET /@warpgate/api/sso/return path. The vendor rates this 9.3 (CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:N), reflecting network reachability with no attacker privileges but mandatory victim interaction; no public exploit code or confirmed active exploitation was identified at time of analysis.
Local privilege escalation in the Moore Threads MTT S80 Driver Package 340.150 allows a low-privileged local user to abuse an improperly secured IOCTL handler and gain high-impact control over the system. The flaw resides in the Windows kernel-mode driver mtdispkm64.sys, specifically function sub_140006F0C, and is classified as CWE-269 improper privilege management; successful abuse yields high confidentiality, integrity and availability impact on both the vulnerable component and the subsequently compromised host. Exploitation requires an existing local foothold on a Windows machine with this specific GPU driver installed, with low privileges and no user interaction needed (CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H; vendor-published CVSS 4.0 score 9.3). No public exploit code has been identified at time of analysis, and no CISA KEV listing exists, but the low attack complexity and the absence of a vendor patch make the flaw attractive to local attackers already present on a host.
Cache poisoning in the Open VSX registry allows an unauthenticated remote client to inject attacker-chosen download, signature, and public-key URLs into per-extension metadata that is then served to every other client, so downstream VS Code-compatible editors fetch and install an attacker-supplied VSIX. Exploitation requires the deployment to be reachable directly by clients, or fronted by a reverse proxy that relays rather than overwrites the client's X-Forwarded-Host/X-Forwarded-Proto/X-Forwarded-Prefix headers, with ovsx.server.url left unset and the attacker's source address treated as a trusted proxy (by default only loopback and private ranges are). Because the VSIX download URL, its signature URL and the verifying public key URL are all derived from the same base URL, extension signing provides no protection; poisoned entries persist for the cache lifetime (one hour by default) and spread cluster-wide when ovsx.redis.enabled is set. No public exploit code or confirmed in-the-wild exploitation was identified at time of analysis, but the prerequisite is a common default deployment shape, so the risk is real and high rather than theoretical.
Joplin Server instances prior to 3.7.2 expose an SSO login-code redemption endpoint (GET /api/login_with_code/:id) that is not protected by the limiterLoginBruteForce rate limiter, allowing an unauthenticated remote attacker to make unlimited guesses against a nine-digit authentication code whose lifetime is only ten minutes; a single correct guess yields a full session token granting read and write access to the victim's notes, notebooks, and account settings. Successful exploitation is constrained by timing and throughput: the attacker must target a user during an active SSO login, know the login id, and search roughly 10^9 possible codes inside a 600-second window (about 1.6 million requests per second for reliable coverage), so the flaw is only practical against servers reachable at high request rates. The issue is confirmed by the vendor fix diff (CWE-307, missing limiterLoginBruteForce) and is fixed in 3.7.2; no public exploit code was identified at time of analysis and the flaw is not listed in CISA KEV.
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.
Username enumeration is possible against Tinyauth instances running versions before 5.1.0 because the local-user login handler and the HTTP basic-auth middleware return as soon as an account is reported missing, while an existing account triggers a comparatively slow bcrypt password verification, leaving a remotely measurable timing discrepancy (CWE-208). Unauthenticated attackers with network reach to the authentication endpoints can take repeated latency measurements and statistically distinguish valid local usernames from invalid ones; the independent assessment rates this CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:L/I:N/A:N, so the outcome is limited to disclosure of valid usernames with no direct password, session, or data compromise, and exploitation is constrained by network/server jitter requiring many samples. Deployments that authenticate exclusively through external OAuth/OIDC providers and maintain no local users do not exercise the vulnerable bcrypt path, and no public exploit code was identified at time of analysis; the vendor-released fix is version 5.1.0.
Sync-in Server versions prior to 2.4.0 fail to increment the failed-attempt counter when a valid username and password are paired with an incorrect TOTP code on the desktop sync registration endpoint (POST /api/app/sync/register), so the account lockout threshold of 10 is never reached. An attacker who already possesses working first-factor credentials-and is targeting an account with 2FA enabled-can repeatedly guess the rotating 6-digit TOTP without triggering lockout; a successful guess yields a client ID and token that can be exchanged for a full JWT, after which the attacker can call POST /api/auth/2fa/disable to permanently remove MFA. Exploitation requires authenticated access (PR:L) and the high attack complexity (AC:H) reflects the need to guess a time-based code within its short validity window; no public exploit identified at time of analysis. This is a real, credible authentication-security issue but not a mass-exploitation emergency.
An authenticated user of Sync-in Server (any version prior to 2.4.0) can render the entire instance unresponsive indefinitely by submitting a catastrophic-backtracking regular expression to the sync diff endpoint, which compiles the user-supplied string into a RegExp without complexity validation. Because Node.js runs JavaScript on a single shared event loop, a pattern such as '^(a+)+b' stalls processing for all connected users, and the service remains frozen until the container is manually restarted - an availability-only impact rated CVSS 6.5 (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H). Version 2.4.0 fixes the issue; no public exploit code was identified at time of analysis and there is no confirmed active exploitation (not in CISA KEV).
File owners on Nextcloud Server cannot release TYPE_TOKEN file locks that other users have placed on their files, leaving the file locked with no in-product recovery path; administrators currently have to clear the orphaned lock directly in the database. The defect is an access-control gap (CWE-284) reachable over the network by any authenticated user who can acquire a token lock, typically in shared-folder or multi-user collaboration scenarios, and it is availability-only - no confidentiality or integrity impact - as reflected in the assessed vector CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:N/A:H. No public exploit code has been identified and there is no evidence of active exploitation, so despite a 6.5 base score this behaves as an accidental or malicious file-lockout rather than a scalable remote attack.
Deeply nested JSON or XML parsed by Dasel 3.0.0 through 3.11.0 exhausts the Go goroutine stack and triggers an unrecoverable fatal error that terminates the entire process, giving attackers a denial-of-service condition against any tool, pipeline, or service that runs dasel on untrusted documents. Exploitation requires the attacker to control the parsed input - via the dasel CLI, the parse selector function, or a program embedding the library through parsing.Format(...).NewReader(...).Read(data) - and the assessed vector is local (CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H), so realistic risk concentrates on wrappers that feed externally sourced data into dasel. No public exploit code and no confirmed active exploitation were identified at time of analysis, and the flaw is strictly availability-only: there is no confidentiality or integrity impact, and the fix in 3.11.1 simply rejects input nested beyond 10,000 levels.
Command injection in MaxKB before 2.10.5-lts allows unauthenticated remote attackers to execute arbitrary shell commands when an assistant is configured with a tool, MCP tool, skill, or sub-application. Untrusted chat messages or ingested documents can coerce the LLM into invoking the un-gated `execute` shell tool, which lacks human approval and is exposed by the SandboxShellBackend. Both source deployments with MAXKB_SANDBOX disabled and the official root container's vulnerable gosu wrapper permit command execution outside the intended sandbox; no public exploit code or confirmed active exploitation was identified at time of analysis. A vendor patch is available in version 2.10.5-lts.
Authenticated users of the Ajenti server admin panel - at any privilege level - can achieve root-level code execution and full host compromise on installations below version 2.2.16 by invoking the task API endpoint /api/core/tasks/start, which enforces no plugin-management authorization before enqueuing InstallPlugin, UnInstallPlugin, or UpgradeAll tasks whose package specifications are built from unvalidated name and version fields and then executed by pip under root. The assessed vector (CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H, 9.9) confirms a network-reachable, low-privilege, no-interaction attack that escapes the panel's own security scope by gaining root on the underlying host, and exploitation works against default configurations since the missing permission check is the pre-2.2.16 default state. No public exploit code has been identified at time of analysis, and the flaw is not confirmed as actively exploited (no CISA KEV entry); nonetheless it is a genuine top-priority issue because a valid low-privileged account converts directly into root on the server.
Authentication bypass in Mailu 2.0 through 2024.06.55 and Mailu helm-charts before 2.7.3 allows unauthenticated remote attackers to spoof the trusted proxy identity via a client-controlled X-Forwarded-By header, bypassing header-based proxy authentication. This affects only deployments with PROXY_AUTH_WHITELIST configured and REAL_IP_HEADER unset; default configurations are not vulnerable. The vendor has released fixes in Mailu 2024.06.55 and helm-charts 2.7.3, and no public exploit has been identified at time of analysis.
Arbitrary command injection on Windows in the Perl distribution Email::Sender (Email::Sender::Transport::Sendmail versions before 2.602) lets an attacker who controls a From, To, or Cc header address execute commands as the sending process, because on MSWin32 the envelope sender and recipients are concatenated into a single command string that Perl's open() hands to a shell. The flaw is strictly Windows-only: on every other platform the transport uses open()'s list form and passes arguments directly to sendmail with no shell involved, so the injection path does not exist there, and exploitation additionally requires that the application use the sendmail transport rather than the SMTP transport and that the caller supply no explicit envelope (letting Email::Sender::Simple derive addresses from headers). The vendor CVSS of 9.8 (AV:N/AC:L/PR:N/UI:N) overstates real-world risk given that hard platform gate; our assessment uses CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H, EPSS is low at 0.22% (13th percentile), SSVC records no observed exploitation with automatable attack and total technical impact, and no public exploit code was identified at time of analysis, though a vendor patch (2.602) and an upstream commit are public.
Unauthenticated remote code execution affects ZLMediaKit builds based on commit 9fd5152, where broken access control in the HTTP API allows a remote attacker to overwrite the ffmpeg.snap snapshot configuration parameter with arbitrary shell commands through the setServerConfig endpoint, which are then executed with the privileges of the ZLMediaKit process when getSnap is invoked. Per the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8), no credentials or user interaction are required - the only practical prerequisite is network reachability to the exposed HTTP API service. Exploitation has not been confirmed as active (not in CISA KEV) and no public exploit code was identified at time of analysis; the EPSS score is low at 0.21% (11th percentile), but the unauthenticated, full-compromise nature of the flaw makes it a top-priority fix for any internet-facing or hostile-network-reachable deployment.
Remote code execution affects Univer v1.0.0-alpha.2 through its Uniscript feature: the UniscriptExecutionService.execute() function in /services/script-execution.service.ts evaluates attacker-influenced script content (CWE-94), allowing arbitrary code execution with the privileges of the hosting process. The input CVSS vector rates this 9.8 (AV:N/AC:L/PR:N/UI:N), but the authoritative assessment refines the privilege requirement to PR:L, meaning an attacker generally needs a delivery channel - and for most deployments at least application-level access - to place a crafted script into the execution service, and the exposure is further limited to deployments that actually enable Uniscript on this early alpha build. No confirmed active exploitation (not in CISA KEV) and no public exploit code identified at time of analysis; EPSS is 0.21% (11th percentile), indicating low modeled near-term exploitation likelihood.
Remote code execution in Univer v1.0.0-alpha.2 allows unauthenticated network attackers to execute arbitrary code via a crafted payload sent to the RemoteRegisterFunctionService endpoint (/remote/remote-register-function.service.ts). The vulnerability is rated CVSS 9.8 (critical) and requires the remote function-registration service to be reachable; only this pre-release alpha build is named as affected. No public exploit code or confirmed active exploitation has been identified, and EPSS indicates a low likelihood of exploitation (0.21%).
Arbitrary code execution in the npm front-matter parser gray-matter is reachable through its built-in JavaScript engine, which evaluates front matter with eval() whenever the document declares a js/javascript language fence. Any application that passes attacker-influenced markdown or front-matter text into gray-matter's parse call can be induced to run attacker-supplied JavaScript in the Node.js process - the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, 9.8) rates this as unauthenticated remote code execution, with the practical caveat from our assessment that the attack surface is gated by whether the host application exposes gray-matter parsing to untrusted content. Affected coverage is broad rather than version-specific: the reporter states all versions are impacted and verified 4.0.3, while there is no CISA KEV entry, no confirmed public exploit code, and a low EPSS of 0.17% (7th percentile) indicating limited observed exploitation pressure at time of analysis.
SQL injection in NocoBase v2.1.21 lets an attacker reach the SQL handling path behind the checkSQL function and submit crafted SQL statements that disclose sensitive database contents. Publicly available exploit code exists (SSVC Exploitation: poc, Automatable: yes, Technical Impact: total), though the EPSS score is only 0.15% (5th percentile) and CVE-2026-88402 is not confirmed actively exploited (CISA KEV). The published CVSS vector is 9.8 with PR:N/UI:N, but independent assessment rates the vector lower (AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:L) and concludes that the SQL data-source/SQL-collection feature is normally an authenticated administrative capability, so the realistic limiting factor is a valid account with permission to define or run SQL sources rather than an unauthenticated remote attacker; this discrepancy should be confirmed with the vendor.
Unauthenticated remote code execution risk in Apache MINA 2.0.X through 2.0.30 and 2.1.X through 2.1.14 arises because those maintenance branches never received the resolveProxyClass() override that closed CVE-2026-47065. An attacker who can reach an application that uses MINA's ObjectSerializationDecoder and relies on acceptMatchers can wrap a malicious serialized object in java.lang.reflect.Proxy to bypass the allow-list, and, if a suitable gadget chain is present, execute code. No public exploit identified at time of analysis; upgrades within 2.0.X or 2.1.X do not remediate, so affected users must move to the 2.2.X line at 2.2.8 or later.
Server-side request forgery in CKAN MCP Server (ondata/@aborruso ckan-mcp-server) before version 0.4.108 allows an attacker who can influence the caller-supplied server_url parameter to force the server to issue requests to loopback addresses and to the cloud instance metadata service at 169.254.169.254. The flaw is the third bypass of the same validateServerUrl guard: because that guard only inspects the hostname string and never resolves DNS, any hostname that resolves to an internal address (documented examples lvh.me to 127.0.0.1 and *.nip.io to IMDS) slips through, and exploitation realistically requires prompt injection into content the victim's AI assistant processes while the MCP server is connected (CVSS UI:R). No confirmed active exploitation (CISA KEV) and no public exploit identified at time of analysis, though a proof-of-concept for an earlier, related SSRF variant in the same package is published; impact is highest for cloud-hosted deployments where IMDS returns IAM credentials.
Command injection in the Netcore NBR200V2 router (firmware 1.3.241127.071246) lets remote attackers execute arbitrary shell commands on the device through the /www/cgi-bin/network_tools CGI diagnostic endpoint by supplying crafted param, key, or val arguments. The vendor CVSS 4.0 vector (9.3) rates this remote, unauthenticated, and requiring no user interaction, and publicly available exploit code exists; the vendor was contacted early but never responded, so no fix is available. Any deployment that exposes the router's web management interface to an untrusted network is at risk of full device compromise.
Missing authentication in the Role Permission API of Omega Solution HRM OS (versions up to 20260717) lets remote, unauthenticated attackers read role-permission data without a session or credential. Manipulating the roleId argument on the /role-permission/permission endpoint bypasses the intended access check entirely (CWE-306), and publicly available exploit code exists for this path. The exposure is limited to low-confidentiality disclosure - no integrity or availability impact was assessed - so the practical risk depends on whether the HRM OS instance and this API endpoint are reachable from attacker-controlled networks.