2026-11-03
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.
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.
Memory corruption in Solanum IRCd's server-to-server KILL handler (ms_kill) lets an attacker who controls a linked peer server crash the ircd and potentially execute code by sending a kill reason longer than KILLLEN, which overflows a static 512-byte buffer. Only builds prior to commit 2ea1382 are affected, and the flaw is not reachable by ordinary IRC clients - the attacker must already hold an established, trusted server-to-server link (the CVSS 4.0 vector rates PR:H for this reason). A vendor patch exists via PR #550 / commit 2ea1382, and no public exploit code was identified at the time of analysis.
Heap-based memory corruption in the Solanum IRC daemon (builds from before commit 2ce64de) lets a malicious linked server corrupt process memory by sending JOIN or SJOIN messages whose channel names exceed CHANNELLEN, crashing the ircd and potentially yielding remote code execution. The flaw sits on the server-to-server path of a federated network: the attacker must already control a server that is peered into the target Solanum network, so ordinary unauthenticated IRC clients cannot reach it, and the assessed CVSS 3.1 vector (PR:H) reflects that gating. No public exploit identified at time of analysis; the upstream fix is available as a commit and pull request rather than a confirmed tagged release, and the priority signal places it in this_week rather than an emergency tier.
Remote code execution in SolarWinds Dameware can be triggered by an authenticated low-privilege user who satisfies high-complexity preconditions, through insufficient input validation that leads to a buffer overflow. The CVSS 8.4 rating reflects network reachability (AV:N), PR:L authentication, no user interaction (UI:N), and high confidentiality, integrity, and availability impact; the exact vulnerable feature and the additional AC:H preconditions are not described in available sources. Upgrade to the vendor-released Dameware 2026-3-1 build to remove exposure; no public exploit identified at time of analysis, and the this_week decision label indicates a high-priority but not drop-everything response.
Symlink following in Docker Sandboxes' `sbx cp` command allows a malicious sandbox to redirect a user-initiated copy outside the shared workspace, pulling host files into the sandbox or pushing sandbox-controlled content onto host paths with the invoking user's permissions. All releases prior to v0.51.0 are affected (CPE `docker:docker_sandboxes:*`), and exploitation is conditional: an attacker must already be running code inside a sandbox that shares a workspace with the host, plant a symlink there, and wait for the user to run `sbx cp` (UI:R, PR:N, AV:L). Impact is high for confidentiality and integrity but bounded by the invoking user's own filesystem permissions; there is no public exploit identified at time of analysis and no CISA KEV entry, and v0.51.0 strengthens workspace-copy and credential protections per the vendor release notes.
Arbitrary command execution in nnn through 5.3 (CVSS 8.4 High) occurs when the togglex plugin processes selected filenames containing a double quote and shell syntax, allowing an unauthenticated local attacker who can plant such a filename to run commands as the user invoking togglex. The victim must actively run togglex on a selection that includes the malicious file; simply opening the directory is not enough, and there is no remote or unauthenticated network path. No public exploit was identified at time of analysis, and an upstream fix commit is referenced (released patched version not independently confirmed).
bbs-go through 4.4.6 disables TLS certificate verification when sending SMTP email, so a network-positioned attacker who can intercept the connection between the bbs-go server and its configured mail server can present any certificate and be trusted. Interception exposes SMTP PLAIN authentication credentials and lets the attacker read or tamper with outgoing password-reset and account-verification messages. The flaw requires an active man-in-the-middle position plus a bbs-go deployment that sends mail over a TLS/STARTTLS SMTP connection; no authentication or user interaction against bbs-go itself is needed once that position exists, and no public exploit code was identified at the time of analysis.
Nodemailer 3.0.0 through 10.1.3 misparses angle-addresses in its addressparser, letting a crafted recipient value such as `<"a@evil.com>"@good.com>` validate as an allowed domain but be delivered to an attacker-chosen domain. The flaw crosses the application's recipient allow-list boundary, disclosing whatever message content the application sends, and also affects standalone parser consumers such as mailparser. Exploitation additionally requires an application that both passes attacker-influenced address text to Nodemailer and enforces a domain allow list validated with a conformant parser; no application access or user interaction is needed, and a public proof-of-concept reference exists but is not verified as working exploit code. No public exploit has been identified at time of analysis, EPSS is unavailable in the provided data, and the reported severity is 8.3 (CVSS 4.0).
Nodemailer 3.0.0 through 10.1.3 contains a recipient-injection flaw in its bundled addressparser: a semicolon inside a quoted display name or comment inside an RFC 5322 group terminates the group early, so text a conformant parser treats as display text is re-parsed as a live recipient address. An application that validates user-supplied recipient lists with a conformant parser and then hands the same text to Nodemailer can be made to deliver mail to an attacker-chosen address outside its allow list - for example `G: (a; <evil@evil.com>) <v@victim.com>;` is approved as v@victim.com but resolved by Nodemailer to evil@evil.com, disclosing message content and suppressing delivery to the intended recipient. The vendor fixed this in 10.1.4; a public proof-of-concept reference is documented in the GitHub advisory, and no confirmed active exploitation or public working exploit code was identified at time of analysis.
Nodemailer's addressparser (versions 3.0.0 through 10.1.3) terminates a nested RFC 5322 comment at the first closing parenthesis instead of the one that closes the outermost comment, so a value such as `Victim (x(y) <evil@evil.com>) <v@victim.com>` - which conformant parsers read as the address v@victim.com - is parsed by Nodemailer as evil@evil.com. Unauthenticated remote attackers who can influence address text handed to sendMail, or the From/To header of an inbound message parsed with mailparser, can therefore redirect mail intended for an approved recipient to an attacker-chosen domain or make a mailparser-based layer disagree with a conformant DMARC/display check about the author of the same message, crossing recipient allow-list and sender/author boundaries. The vendor advisory publishes a PoC reference (a code snippet demonstrating the mis-parse); it is not verified as working exploit code, no active exploitation is confirmed, and the practical impact is bounded to deployments that actually enforce conformant validation plus an allow list or author check. Fixed in 10.1.4.
Response mispairing in the MongoDB Node.js driver can return one request's database reply to a different request, potentially disclosing other users' records and producing incorrect results or failed legitimate requests when an application enables the optional client-side operation timeout. An unauthenticated remote party able to send ordinary requests through such an application can trigger the condition, but exploitation is opportunistic and timing-dependent because an earlier operation must time out and leave data outstanding on a pooled connection. No public exploit or active exploitation is identified in the available data, and the decision label is this_week rather than emergency.
DLL hijacking in SolarWinds Dameware installers lets a local attacker who can write a malicious DLL into a location searched by setup execute code in the installer's context when a victim runs the installation. The issue is limited to installation time and is not exploitable against an already-installed or running Dameware instance; the CVSS 8.2 score reflects high confidentiality, integrity, and availability impact plus a scope change, not remote reachability. The vector requires local access and user action to launch the installer, and the description additionally cites admin privileges; no public exploit was identified at time of analysis.
WPPConnect Server through 2.10.74 allows unauthenticated remote attackers to send arbitrary WhatsApp text or file messages from a connected session by POSTing crafted Chatwoot webhook payloads to /api/:session/chatwoot, a route registered without the verifyToken middleware. Exploitation is constrained: the endpoint must be reachable and the attacker must know or guess a session name whose client is in CONNECTED status; random or secret session names reduce risk, while default or disclosed names make abuse straightforward. No public exploit was identified at time of analysis, and the vendor references an upstream fix in PR #2702.
cordova-plugin-advanced-http 1.5.0 through 3.3.1 on native iOS and Android can leak cookies to a third-party host when a request to an origin with stored cookies is redirected and the plugin's native HTTP stack follows the redirect. The JavaScript layer builds Cookie headers from the plugin cookie jar and passes them as ordinary request headers, so an open or attacker-influenced redirect can forward them across origins; the upstream fix tests also show Authorization and Proxy-Authorization being dropped on cross-origin hops. No public exploit identified at time of analysis; unauthenticated attackers need the app to hold cookies for the original origin and to follow a redirect to an attacker-influenced host.
CPU exhaustion in enshrined/svg-sanitize 1.0.0 occurs when removeRemoteReferences(true) is enabled: crafted SVG CSS containing many unclosed -webkit-image-set( tokens drives super-linear regex matching in stripRemoteCssTokens(), holding a PHP worker for tens of seconds. If PCRE hits its backtrack or JIT limits, preg_replace() returns null and sanitize() throws a TypeError instead of failing closed, so an application that stores the upload before sanitizing in place may retain unsanitized content. The vendor advisory includes a proof-of-concept harness; no CISA KEV entry is indicated, and impact is availability-focused with conditional integrity exposure.
Denial of service in Parse Server (npm package parse-server) lets a remote client terminate the Node.js process by sending an object update whose dot-notation key targets the object identifier of a pointer field on a class that has an afterSave trigger registered. All clients lose service until the server is restarted. The request is unauthenticated (CVSS PR:N) only when the targeted object is writable without a session; otherwise the attacker needs whatever write access the object's ACL/CLP grants, and classes without an afterSave trigger or without pointer fields complete the identical request normally, which bounds the set of exposed deployments. No public exploit code has been identified at time of analysis and the issue is not in CISA KEV; the vendor has released fixes in 8.6.110 and 9.10.6-alpha.2.