2026-11-03
Ivanti Connect Secure before 25.1.1.3 and 22.8R2.6 uses predictable filenames, allowing a remote authenticated attacker to write attacker-controlled content to a deterministic, known location on disk. The assessed CVSS 3.1 vector (AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N, base 4.3) describes an integrity-only impact with no confidentiality or availability effect. Despite the low base score, the flaw is confirmed actively exploited (CISA KEV); the exact upload endpoint and trigger are not described in the available sources, and patched builds are 25.1.1.3 and 22.8R2.6.
Code injection in the Lua Handler of Ziroom ZHOME A0101 (version 1.0.1.0, Build 202004151405) lets a remote attacker with high privileges pass attacker-controlled data into the Lua loadstring function through the zrUsb API controller, resulting in code execution with full confidentiality, integrity and availability impact on the device and on subsequent systems (CVSS 4.0 score 8.5, scope-changed). Exploitation requires an authenticated administrative session (PR:H) but needs no user interaction and is low complexity once that access is obtained, so exposure is greatest where the management interface is reachable from untrusted or multi-tenant networks. A public PoC reference has been published; it is not verified as working exploit code, and the vendor did not respond to disclosure so no vendor fix is available.
Concurrent order requests to Bagisto's onepage checkout can redeem a single-use or usage-limited coupon multiple times, allowing an attacker to apply the same discount across multiple orders. The issue affects Bagisto before 2.3.16 and 2.4.x before 2.4.1 and stems from a race condition in manageCartRule(); impact is limited to coupon accounting and discount integrity, with no confidentiality or availability impact. A public PoC reference exists but is not verified as working exploit code, and there is no confirmed active exploitation (CISA KEV).
Command injection in SolarWinds Dameware lets an authenticated attacker with low-privilege credentials execute arbitrary commands on a remotely controlled host, with scope change and high confidentiality, integrity, and availability impact. The network-reachable flaw requires no user interaction, but valid Dameware authentication is the main limiting prerequisite; no public exploit identified at time of analysis, and no CISA KEV entry is present in the supplied data. The vuln.today decision label is act_now.
Authentication bypass in WSO2 API Manager allows a self-registered user to gain access to the product's System REST APIs when WSO2 Identity Server is configured as a Resident Key Manager with a shared database. The vendor rates this 9.8 critical (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H), but the assessed vector is PR:L because the described flow starts from a self-registered account; a token obtained from the Identity Server token endpoint is improperly honored by API Manager. Affected deployments are limited to that Resident Key Manager plus database-sharing architecture; no public exploit identified at time of analysis.
Elo 1.0.0 and earlier - a purely functional expression language used as a rule-engine, config and form-builder DSL - lets an attacker who controls a plain Elo source string reach the JavaScript `Function` constructor and run arbitrary code in the host runtime. The vulnerable string can arrive through `defaultFormats.elo.parse()`, the `bin/elo` CLI (including the `-f elo` flag documented to pass user files as data), or the auto-running `elo-lang.org/try?code=...&run=1` playground, where a shared link yields 0-click script execution and session compromise in the visitor's browser. The vendor advisory ships proof-of-concept payloads for all three entry points, and the issue is fixed in 1.0.1; no CISA KEV entry was provided in the source data, and the priority decision is act_now.
Ruby code execution in Elo (npm @enspirit/elo) through 1.0.0 lets an attacker who controls Elo source gain arbitrary Ruby and shell command execution whenever that source is compiled to the Ruby target and the emitted code is run. The Ruby backend in src/compilers/ruby.ts inserts string literals and labelled subtype-constraint messages into Ruby double-quoted strings without escaping '#', so payloads such as 'RES=#{`id`}' survive compilation intact and execute when the generated Ruby is evaluated; the server-side /try playground with the Ruby target, bin/eloc -t ruby -x, and library integrations that call a Ruby emission step on parsed input are all exposed. The network-facing playground surface needs no authentication or user interaction (CVSS 3.1 AV:N/AC:L/PR:N/UI:N, 9.8), and the advisory ships working proof-of-concept Elo snippets; the same Elo source compiled to JavaScript, Python, or SQL is harmless, so only pipelines that emit and execute Ruby from untrusted Elo are exploitable, and no CISA KEV listing or independent confirmation of exploitation in the wild is present in the available data.
Unauthenticated attackers can invoke arbitrary WordPress functions with attacker-controlled arguments through the render_field method in the Advanced Custom Fields: Extended PRO plugin for WordPress, affecting all versions up to and including 0.9.2.6. Exploitation is not unconditional: it requires either the non-default 'shortcode_preview' setting to be enabled on the targeted form, or a server environment lacking OpenSSL functions so that ACF Pro's acf_decrypt falls back to unverified base64 decoding - default installations with shortcode_preview disabled and OpenSSL present are not exploitable. No public exploit code and no confirmed active exploitation were identified at time of analysis, but the vendor-reported severity is critical and the priority decision is act_now, so exposed sites running the PRO plugin should be triaged promptly.
Incorrect type conversion in phpMyAdmin SQL-Parser 6.0.0 and 6.0.1 allows remote attackers to degrade availability when attacker-controlled SQL containing an EXPLAIN statement reaches ExplainStatement::parse with a manipulated nextToken argument. Only applications embedding these two library versions and passing untrusted SQL into the parser are exposed; the parser itself imposes no authentication requirement, but exploitability depends entirely on whether the consuming application parses untrusted input. A public PoC reference (a GitHub gist) has been published but is not verified as working exploit code, and the vendor did not respond to the disclosure; impact is limited to availability with no confidentiality or integrity effect.
Missing access-control enforcement in Zoho ManageEngine Log360 and EventLog Analyzer 13062 and below lets remote attackers reach product functionality without authorization, with the CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N) indicating no credentials, privileges, or user interaction are needed against an exposed instance, and high confidentiality and integrity impact but no availability impact. Both the SIEM/log-management products share the affected build range, so internet-facing or otherwise reachable management interfaces are the exposure that matters. No public exploit code and no confirmed active exploitation were identified at time of analysis, but the priority decision for this CVE is act_now given the unauthenticated network vector and the sensitivity of the data these products aggregate.
Unauthenticated attackers can forge payment-confirmation webhook requests to the Eupago Gateway For WooCommerce WordPress plugin (versions 4.5.0 through 4.7.5) when the store runs a configuration in which the plugin fails to verify webhook authenticity, letting them mark a pending order as paid without actually paying. Impact is integrity-only (no data exposure or availability loss) at CVSS 5.3, and the flaw is scoped to 'some configurations,' so properly validated deployments are not affected. A public PoC reference exists via the WPScan advisory, but it is not verified as working exploit code; there is no KEV listing and exploitation has not been confirmed in the wild.
Unauthenticated attackers can forge CryptoCloud payment notifications to mark arbitrary WooCommerce/WordPress orders as paid or failed without any cryptocurrency payment being made, affecting plugin versions 3.0.0 through 3.0.1. The gateway callback skips its payment-notification authenticity check whenever the webhook secret is still at its empty default, so the flaw is exploitable only on default or unconfigured installs; sites where an administrator has set a non-empty secret retain the integrity check and are unaffected. Severity is moderate and integrity-only (CVSS 5.3, AV:N/AC:L/PR:N/UI:N, C:N/I:L/A:N), and a public PoC reference exists at the WPScan advisory though it is not verified as working exploit code; there is no CISA KEV entry and no public exploit identified at time of analysis.
Eclipse Mnestix Browser 1.6.0 through releases before 2.3.0 allows unauthenticated remote attackers to exfiltrate the MNESTIX_BACKEND_API_KEY for every configured Infrastructure. The issue is classified as CWE-918 (SSRF) with a CVSS 4.0 base score of 9.2 (AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:N/VA:N/SC:H/SI:N/SA:N), and the independent CVSS 3.1 vector confirms network reachability, no privileges, no user interaction, and high confidentiality impact. No public exploit code or CISA KEV entry is identified at time of analysis, but the priority label is act_now and exploitation requires only that the affected instance be reachable and have at least one Infrastructure configured with such a key.
Remote login as the built-in Axxon One administrator is possible through the web client on newly installed systems running versions before 3.0.0, because the default credential is not forced to change at first sign-in. An unauthenticated network attacker who knows the default password can gain high-impact administrative access on Windows or Linux deployments that have not been remediated. No public exploit code was identified at time of analysis, and the vuln.today priority is act_now.
FreeRDP clients through 3.32.1 silently accept a server certificate whose identity does not match the RDP target, letting an on-path attacker impersonate the RDP server and read or alter the session - keystrokes, clipboard, screen content, and injected input - without any client-side prompt. The defect is an incomplete fix for GHSA-43hh-p3vw-hfx3: tls_verify_certificate() still consults the Common Name via an unconditional OR even when non-matching dNSName SAN entries are present, and still matches IP-literal targets as plain strings against CN/DNS entries because true iPAddress SANs are never parsed. FreeRDP 3.32.2 is the vendor-fixed release; a detailed public proof-of-concept reproduction exists at function level with isolating control cases (not demonstrated end-to-end over a live RDP handshake), no confirmed active exploitation (not in CISA KEV), and the issue carries an act_now priority label - but exploitation is gated on both an on-path position and a certificate chaining to a CA the client already trusts (misissuance, or a rogue/private CA).
Unauthenticated arbitrary file deletion in the BuddyPress XProfile Image Field plugin through 3.1.0 allows remote attackers to remove server files, including wp-config.php, when web-server filesystem permissions permit the deletion, potentially leading to remote code execution. The vulnerable path is built from visitor-supplied signup metadata and passed to unlink() without realpath() resolution or containment checks; exploitation requires open registration and an image-type XProfile field on the signup form. No public exploit is identified in the available data, and the vuln.today decision label is act_now.
Missing authorization in Eclipse Mnestix Browser 1.2.0 through releases before 2.3.0 lets remote unauthenticated attackers invoke privileged functionality - such as changing Infrastructure settings or calling the connected, authenticated AAS Generator backend - without holding a Mnestix user session. The CVSS 4.0 vector (8.8, AV:N/AC:L/AT:N/PR:N/UI:N, high integrity impact) and the assessed CVSS 3.1 vector agree that no credentials or user interaction are required once the instance is network-reachable, and the issue is tagged as an Authentication Bypass affecting Eclipse Foundation software. The vuln.today decision label is this_week; no public exploit identified at time of analysis, and the advisory's version range indicates 2.3.0 is the first unaffected release.
The TYPO3 'frontend_user_registration' extension trusts an attacker-supplied frontend user identifier in its email-driven action handlers, so unauthenticated remote attackers can confirm registrations, disclose the username and email address of frontend users, and delete arbitrary frontend user accounts without a valid hash. Affected are TYPO3 installations where the extension is installed and active and its email-linked actions (registration confirmation, account deletion) are in use; every version of the extension is listed as affected in the CPE data. No confirmed public exploit code and no CISA KEV entry are identified at time of analysis, but the exploitation profile is unusually accessible (CVSS 4.0 AV:N/AC:L/PR:N/UI:N, assessed CVSS 3.1 8.8 with Integrity:High and Confidentiality:Low), which is why it is prioritised as a near-term 'this week' item rather than a high-score-but-low-reality case.
An unauthenticated adjacent attacker who can reach the web management interface of Zyxel GS1900 series switches running firmware through 2.90(AAHK.2)C0 can trigger an out-of-bounds write in the device's CGI program via a crafted HTTP request, with the potential for OS command execution (CVSS 3.1: 8.8, AV:A/AC:L/PR:N/UI:N, C:H/I:H/A:H). The CPE data lists the whole GS1900 family as affected - GS1900-8, -8HP, -10HP, -16, -24, -24E, -24EP, -HPv2, -48 and -48HPv2 - so exposure is not limited to the GS1900-24E named in the description. No public exploit code and no confirmed active exploitation were identified at time of analysis; Zyxel published a security advisory on 11-03-2026 and the issue is prioritised for remediation this week rather than as a drop-everything emergency, because the attacker must first be on the same adjacent/Layer-2 network as the switch's management plane.
A buffer overflow in the zdp_wtp binary of Zyxel NWA110AX access points running firmware through 7.12(ABTG.0)C0 allows an unauthenticated attacker who can reach the device over the local network to escalate privileges, with high impact on confidentiality, integrity and availability. The CVSS 3.1 vector (AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) confirms the flaw is not remotely exploitable from the internet, but requires no credentials or user interaction once the attacker is on an adjacent network segment such as a guest or untrusted LAN. Zyxel has published a security advisory and patched firmware is available for the affected branch; no public exploit code has been identified at the time of analysis, and the issue is assessed as a near-term (this week) priority rather than an emergency, with risk bounded by the adjacent-network precondition.
Use-after-free in SurrealDB Core before 3.3.0 can crash or corrupt memory in Rust applications that embed the database as a library. The defect affects KV backends that pass borrowed transaction state into affinitypool::spawn_local closures; the embedder must leak the returned future and then drop the transaction while a pool worker is still running, defeating the future's Drop-based safety barrier. Exploitation is local and in-process - remote SurrealQL, JS, WASM, or RPC input cannot reach the leak - and a proof-of-concept is documented in the advisory, though publicly available working exploit code is not confirmed in the provided data.
Incorrect boundary conditions in Mozilla Firefox's Layout: Block and Inline component, fixed in Firefox 159.0.1, can cause memory corruption with high confidentiality, integrity and availability impact (CVSS 8.8). An unauthenticated remote attacker can only trigger the flaw if the victim loads attacker-controlled web content that reaches the affected layout code, which is the user-interaction requirement (UI:R); default browser configurations are affected because this is core rendering code. No public exploit identified at time of analysis, SSVC assesses exploitation as none and the attack as not automatable, and this is a genuine high-priority issue but not an emergency by the input signals.
A use-after-free in Zephyr's CAN subsystem lets a local, unprivileged user-mode thread corrupt kernel heap memory by registering a CAN RX filter against a message queue whose lifetime it controls, then releasing or exiting to free that queue while the CAN controller driver still holds a raw pointer to it. The flaw affects builds with CONFIG_USERSPACE=y and CONFIG_DYNAMIC_OBJECTS=y (the latter is default-off but is automatically selected by CONFIG_DYNAMIC_THREAD together with CONFIG_USERSPACE), and requires that the thread already hold a deliberate application-level grant to a CAN device; the next matching CAN frame is then copied through the reused block's write_ptr in supervisor context, and the queue's wait_q (and poll_events under CONFIG_POLL) list nodes are manipulated, crossing the user-to-kernel boundary with high confidentiality and integrity impact. No CISA KEV entry and no EPSS signal are present in the supplied data, but a public proof-of-concept reproducer (delivered via CAN_MODE_LOOPBACK on qemu_x86_64) is published with the vendor advisory; it demonstrates the dangling-pointer path and address reuse with a supervisor-owned queue but is not confirmed as weaponized exploit code.
Authenticated arbitrary file upload in the BuddyBoss App plugin for WordPress, affecting all versions through 3.2.1, lets any subscriber-level user or higher submit files through the send_feedback function, which trusts only the client-supplied Content-Type header and performs no server-side content or extension validation. Uploaded files may be executable, so the defect can lead to remote code execution, but the assessed vector is AC:H because reliable code execution depends on winning a race during the SMTP/email-send window before the file is deleted, or on wp_mail() failing and leaving the file on disk indefinitely. No public exploit was identified at time of analysis, and the issue is not in CISA KEV.
Remote CPU exhaustion in rsync's delta-transfer sender lets a malicious receiving peer starve a public rsync daemon module of processing capacity. The flaw affects rsync builds through 3.5.1 when exposed through rsyncd with a module that permits anonymous or public pull/download transfers; the attacker supplies weak checksums that collide at consecutive rolling-window offsets while the paired strong checksums do not match, forcing hash_search() in match.c into a per-byte strong-checksum walk instead of the normal per-block stride, and parallel connections compound the load. Impact is availability-only (CVSS 4.0 8.7, VC:N/VI:N/VA:H; independently assessed CVSS 3.1 8.7 AV:N/AC:L/PR:N/UI:N/A:H), no public exploit code exists at time of analysis, and the hard prerequisite is a non-default public daemon deployment - rsync invoked over SSH as a client is not exposed.
Cross-tenant object reference flaw in FastBee through 2.1.0 lets any authenticated tenant user read another tenant's MQTT account, password and secret values, and overwrite or delete foreign product records, by supplying or enumerating sequential product IDs. The by-ID endpoints in ProductController enforced only RuoYi permission strings and omitted the tenant-ownership scoping that the list query applies at the service layer, which yields high confidentiality and integrity impact with limited availability impact (reported CVSS 4.0 score 8.7; independently assessed as CVSS 3.1 AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:L). Exploitation requires a valid tenant account on a multi-tenant deployment where other tenants' products exist, and no public exploit code or active exploitation was identified at time of analysis.
Foxel through 2.4.0 exposes its virtual filesystem read endpoints, /api/fs/stream and /api/fs/thumb, without any authentication dependency or per-path permission check, so an unauthenticated remote attacker who can reach the instance can retrieve full file contents or generated thumbnails by supplying a VFS mount prefix and a relative path - even for paths that PathRule grants never authorized. The upstream fix commit 73d9fa8 adds a Bearer-token requirement plus a READ path-permission decorator to both handlers and replaces raw stream URLs in the web client with short-lived signed links, and the issue is assessed as a genuine high-priority unauthenticated data-disclosure flaw rather than a CVSS-inflated one. No CISA KEV listing and no public exploit code were identified at time of analysis, though the endpoints are trivially reachable by any client that can perform an HTTP GET, so the practical limiter is network exposure of the Foxel API rather than any attacker prerequisite.
Incorrect authorization in smart-sso through 2.0.1 lets any registered low-privilege user reach admin console APIs, because PermissionFilter only enforces permissions on request paths that are explicitly registered in sso_permission.code and allows every unlisted path by default. The built-in admin console registers page paths such as xxx.html rather than the backend servlet paths, so a default deployment leaves endpoints like /admin/user-role/save reachable; calling it lets an attacker grant themselves the administrator role, reset passwords, and manage users, roles, and applications across integrated systems. Exploitation requires a valid authenticated session (PR:L) and is not possible for a fully anonymous attacker; the vendor has published an upstream fix (commit 9bccabaa5ec5 plus a second commit) and a fixed release version is not stated in the available data. A public PoC reference exists; it is not verified as working exploit code, and no confirmed active exploitation (CISA KEV) was identified at time of analysis.
Arbitrary file write in AB Download Manager before 1.11.2 allows a malicious web page to place attacker-chosen files at any path the desktop application can write, including per-user autostart locations, by posting crafted folder and name values to the /start-headless-download endpoint of its local browser-integration HTTP server. Exploitation is unauthenticated (PR:N) but requires user interaction: the victim must load the attacker's page in a browser on the same host while the integration server is running, since the pre-patch default leaves that API without enforced API-key authentication. The consequence is code execution at the next user login or reboot, when the dropped payload is launched from the startup folder; no public exploit code was identified at time of analysis, and the vendor has released 1.11.2 together with an upstream commit that splits the Ktor routes into auth-optional and auth-required groups and adds an apiKeyEnforced setting.
Authenticated path traversal in Dockhand before 1.0.54 lets any logged-in user read, overwrite, and delete .env files outside the managed stacks root by supplying a double-URL-encoded stack name such as %252e%252e to /api/stacks/[name]/env/raw and roughly eighteen sibling stack routes. Because stack environment files carry database credentials, API keys, and deployment secrets, the flaw exposes cross-environment secrets, permits writes into otherwise guarded directories such as /app/data/db, and enables deploy-time variable poisoning that is interpolated into the next container's environment; unauthenticated requests are rejected with 401, and the cross-tenant dimension is specific to Enterprise RBAC deployments where the trusted env query parameter lets a user scoped to one environment reach another's files. No confirmed active exploitation (CISA KEV) is recorded, but the vendor advisory publishes a public proof-of-concept with captured reproduction output against the official fnsys/dockhand v1.0.53 image; the vendor-released patch is 1.0.54 and the priority signal places remediation in the current week rather than as an emergency.
Algorithmic-complexity denial of service in svg-sanitizer (Composer package enshrined/svg-sanitize) versions 0.11.0 through 1.0.0 lets remote attackers burn extreme CPU by uploading a tiny layered SVG. The <use> reference-graph analysis in Subject.php::hasInfiniteLoop() and countUse() enumerates every root-to-leaf path without memoization, and the only guard (useNestingLimit = 15) caps depth rather than total work, so an acyclic DAG of 15 fanned-out layers (roughly 4-12 KB) projects to tens of hours of CPU for a single sanitize() call; no public exploit code was identified at time of analysis, though the advisory publishes a generator and measured timings. Availability-only impact; the trigger runs during Resolver::collect() before any <use> element is removed, so it cannot be avoided by how the sanitizer later strips elements.
Denial of service in Mistune 3.3.0 through 3.3.3 allows unauthenticated remote attackers to exhaust CPU and stall request workers by submitting small markdown documents that trigger quadratic-time emphasis delimiter processing. The default renderer with no plugins is affected, with repeated "*a_b" driving an O(n²) index-fixup loop; the advisory measured 64KB at roughly 8.2 seconds and a worse "*a**b" pattern at 20.9 seconds for 80KB. The advisory includes a proof-of-concept payload that the reporter reproduced against 3.3.3, no CISA KEV entry or other confirmation of active exploitation is provided, and the vendor has released 3.3.4 as the fix.
Authenticated command injection in AzuraCast through 0.23.8 lets any station user holding the standard Profile permission run arbitrary OS commands on the station backend by planting shell metacharacters in the StereoTool settings, resulting in compromise of the AzuraCast/Liquidsoap container. Exploitation is not anonymous and is not universal: it requires the StereoTool binary to be installed and configured on the target station, and the injected command only fires when the station backend restarts or the Liquidsoap configuration is regenerated. A detailed proof-of-concept request is published in the project's GitHub security advisory, but there is no confirmed active exploitation (not in CISA KEV) and no vendor-released patch was identified at time of analysis; this is a credible, above-average-priority issue rather than an emergency.
Authenticated station managers in AzuraCast through 0.23.8 can turn a station profile edit into root-level command execution by placing a newline-delimited Supervisor [program:] block inside the station timezone field. The value is written into the generated supervisord.conf with only % characters escaped, so the injected program is parsed and executed as root (uid=0 in the vendor's reproduction) when the station configuration is regenerated - whether through the restart API or any later regeneration trigger. The vendor advisory (GHSA-23wx-88m8-pfm2) ships a reproduced proof of concept against 0.23.8 on the official Docker image; this is a this-week priority with no vendor patch available at time of analysis, and exploitation is confined to the AzuraCast runtime (no Docker or host escape was demonstrated).
Configuration injection in AzuraCast through 0.23.8 lets an authenticated station user who holds only the 'Manage station profile' permission rewrite the live Shoutcast sc_serv.conf of a shoutcast2-type station, overriding adminpassword, password and portbase or appending arbitrary directives via newline-bearing keys. The root cause is an authorization gap: PUT /station/{id}/profile/edit strips privileged Liquidsoap backend custom sections for users without 'Manage station broadcasting' but leaves frontend_config.custom_config writable, and that stored JSON is written verbatim as key=value lines into the config file. The injection only materializes when the station or frontend is restarted (in the published proof-of-concept the restart is performed by an admin), and because the Shoutcast binary is absent from stock images, actual daemon execution of the hijacked configuration was not observed. No CISA KEV entry or in-the-wild exploitation is reported, though the upstream GitHub advisory publishes a detailed proof-of-concept and an automated verification script.
Malformed PNG and JPEG image data delivered through the RDP clipboard path terminates FreeRDP client processes up to and including 3.32.1, because WinPR's image readers invoke libpng and libjpeg without the error-handling context those libraries require for untrusted input. A malicious RDP server, or a man-in-the-middle on a session, that offers a crafted image/png or image/jpeg clipboard format can make the client abort (SIGABRT) or call exit() as soon as the format is synthesized, yielding a clean client-side denial of service; a 12-byte PNG and a 62-byte truncated JPEG are sufficient. No client authentication is needed from the attacker, and the advisory publishes reproduction artifacts and a fuzzing harness alongside the source-level root cause, so the trigger is public; the issue is queued as a this_week priority rather than an emergency, and no KEV or EPSS signal was supplied with this report.
Command injection in the IPsec VPN configuration function of Welotec TK100, TK500-v2, and TK500-v3 routers allows a remote attacker who already holds high administrative privileges to inject system commands that run with root privileges. The flaw is network-reachable and needs no user interaction, but the PR:H prerequisite limits it to authenticated high-privileged users; successful exploitation gives full confidentiality, integrity, and availability impact on the device. No public exploit identified at time of analysis, and the independent assessment treats this as a genuine but conditional priority rather than a drop-everything emergency (this_week).
OS command injection in the Digital I/O function of Welotec TK100, TK500-v2 and TK500-v3 gateways allows a remote attacker holding valid high-privilege credentials to inject operating system commands that execute with root privileges, giving full control of the device (CWE-78). All three product lines are listed without version constraints, so every TK100, TK500-v2 and TK500-v3 build should be treated as affected until the vendor's advisory clarifies fixed releases. Exploitation is access-gated rather than open: the attacker must reach the management/configuration interface and already be an authenticated administrative or operator-level user able to invoke the Digital I/O function, and no public exploit has been identified at time of analysis; vuln.today places remediation on a this-week cadence rather than an emergency one.
OS command injection in the WireGuard VPN configuration function of Welotec TK100, TK500-v2 and TK500-v3 industrial routers lets an attacker who already holds administrative access to the device management interface inject and run system commands as root, with no user interaction required. Because the prerequisite is high-privileged management access, this is not a pre-authentication or low-privilege flaw; the practical risk is privilege escalation from an admin-level account or management-plane compromise to full root control of the router. Per the CERTVDE advisory (VDE-2026-119) the issue is improper input validation (CWE-77); no public exploit code or proof-of-concept is identified in the available data, no CISA KEV entry is associated, and EPSS scoring was not available at time of analysis.
Command injection in the ZeroTier VPN function of Welotec TK100 and TK500-v2/v3 devices allows an authenticated attacker with high administrative privileges to inject system commands that execute with root privileges, with high impact to confidentiality, integrity, and availability. The flaw is network-reachable with low attack complexity and no user interaction, but the PR:H requirement means exploitation is limited to actors who already hold administrative-level access to the device. CVSS 4.0 assigns a base score of 8.6 (High); no public exploit was identified at time of analysis.
OS command injection in Welotec TK100, TK500-v2, and TK500-v3 routers allows an authenticated administrator to execute arbitrary commands with root privileges through the management control functions. The flaw is network-reachable and low-complexity, but exploitation is gated by high-privilege access (CVSS PR:H); no public exploit was identified at time of analysis and active exploitation is not confirmed. CERT@VDE tracks it under advisory VDE-2026-119, and vuln.today assigns a this-week remediation priority.
Authenticated users of Volmarg Personal Management System through 2.1.0 can upload a file with a .php extension and base64-encoded content into the web root via the /upload/send/ endpoint, then request it to execute arbitrary code as the web server user. The vendor's CVSS 4.0 vector scores this 8.6 with PR:H, so the flaw is remote and low-complexity but gated behind a privileged authenticated session rather than being exploitable by anonymous attackers. No public exploit code or CISA KEV entry was identified at time of analysis.
Privilege escalation in GLPI's user-cloning feature lets an authenticated Technician clone an existing Super-Admin account and assign the clone new credentials they control, resulting in a fully attacker-owned administrative login. All releases from 10.0.0 before 10.0.28 and 11.0.0 before 11.0.10 are affected, because User::getCloneRelations() and prepareInputForClone() duplicate every Profile_User and Group_User assignment without checking whether the cloning user could grant those rights. Vendor patches and public commits are available, no public exploit code has been identified at time of analysis, and exploitation is access-gated: it requires a Technician (or other user-cloning-capable) session plus the presence of a more privileged account to copy, making this a genuine but scoped priority rather than an internet-wide emergency.
Froxlor 2.3.8 through 2.3.14 renders every stored API key and secret - including the super administrator's - to any authenticated administrator whose customers_see_all flag is set and whose account has API access enabled, because the api_keys.php listing falls into an unscoped WHERE 1 branch and the per-row detail modal prints the credentials verbatim. The API layer compares submitted key and secret verbatim with no owner check, so a reseller-level admin can replay the super administrator's credentials against /api.php to gain full super administrator control and impersonate every customer, a capability their own role does not provide. Exploitation requires a pre-existing privileged multi-tenant admin account (CVSS PR:H, authenticated), a proof-of-concept reproduction is included in the upstream advisory, and no active exploitation has been confirmed (not in CISA KEV).
Cross-user MCP session takeover in SurrealDB 3.1.0 through 3.2.x allows an authenticated holder of even a lowest-role JWT or Bearer token to run MCP tools with a victim's roles and permissions by presenting that victim's mcp-session-id alongside their own valid credential. The flaw only exists when the MCP HTTP transport (POST /mcp) is exposed and the deployment uses a database-, namespace- or root-level DEFINE ACCESS method of TYPE JWT or BEARER that serves more than one user; users authenticated through the user/password signin path and the stdio MCP transport are not affected. Severity is high on paper (CVSS 8.6, C:H/I:H) but the blast radius is capped by those deployment preconditions and by the fact that the attacker cannot exceed the victim's own privileges; the vendor advisory includes a public proof-of-concept reproduction and a fix in 3.3.0, and no confirmed active exploitation or KEV listing is available at time of analysis.
OS command injection in Nagios XI's MIB upload feature (mibs.php) allows an authenticated administrator to execute arbitrary operating system commands as the web server user by uploading a MIB file whose filename is crafted with tab characters and a pipe to sh, evading an incomplete deny-list before the name is handed to a grep command run through exec(). The flaw affects Nagios XI releases before 2026R2 and is gated on a high-privilege administrator account with access to the MIB upload functionality (PR:H in both the CVSS 4.0 score of 8.6 and the assessed CVSS 3.1 vector), making it a post-authentication admin-to-RCE primitive rather than unauthenticated remote code execution. No public exploit has been identified at time of analysis and there is no KEV listing; vendor patch information points to the 2026R2 release.
Alo Suite's user-invitation workflow can assign administrative privileges to a newly invited account because the '/Requests/userInvitation' endpoint does not enforce privilege-assignment checks server-side. An attacker who can intercept and alter invitation parameters may escalate privileges; the supplied CVSS vector requires low privileges (PR:L), while the description says unauthenticated, so the precise prerequisite remains unresolved and should be verified against the INCIBE advisory. No public exploit code or active exploitation has been identified at time of analysis.
Authenticated command injection in ZohoCorp ManageEngine Key Manager Plus builds before 7151 allows a logged-in user to run arbitrary operating-system commands by supplying malicious input while configuring a Microsoft Certificate Authority integration. The vendor's CVSS vector rates confidentiality and integrity impact High with availability impact None (8.1), while our independent assessment also scores availability as High. There is no KEV entry and no public exploit identified at time of analysis, so this is a prioritised fix for exposed, internet-reachable deployments rather than an emergency, but the practical barrier is only a valid low-privileged session plus reachability of the CA-configuration feature (PR:L, UI:N), and no fixed build other than 7151 is documented.
Deserialization of untrusted data in labbench before 0.46.1 allows arbitrary code execution when a user loads a crafted .p or .pickle file through read() or read_relational(). The library's auto-format dispatch selected pandas.read_pickle on the file extension alone, so a malicious pickle file - or a relational data archive containing one - runs attacker-controlled code with the permissions of the loading user. Exploitation requires user interaction (the victim must open the supplied file), the vector is local rather than network-facing, and no public exploit has been identified at time of analysis; the vendor fixed the behavior in 0.46.1 by refusing pickle auto-loading unless the LABBENCH_AUTOLOAD_PICKLE environment variable is explicitly set.
Privilege escalation in the Eclipse ThreadX Module Manager (versions 6.0.1 through 6.5.2.202603) lets a user-mode, memory-protected module post a forged callback request into another module's callback request queue, and the receiving module's callback thread invokes the attacker-supplied function pointer without verifying that the Module Manager sent the request. Where the targeted receiving module runs in privileged mode, a user-mode module therefore achieves execution at kernel privilege, defeating the isolation the Module Manager is meant to enforce; against a user-mode receiving module the attacker can still run code in that module's context or fault and drain its callback thread. The flaw is local-only and requires the attacker to already be able to load or control a memory-protected module (CVSS 4.0 base 8.5, PR:L), and no public exploit code was identified at the time of analysis, although the reporter reproduced the escalation on a Cortex-M3 target under QEMU. A vendor fix is available in ThreadX 6.5.2.202603b.