Node.js

SQL injection in MariaDB Connector/Node.js exposes applications to data exfiltration or modification when using non-default multi-byte character sets (big5, gbk, sjis, cp932, or gb18030) with attacker-controlled Buffer query parameters. Versions prior to 3.2.4, 3.3.3, 3.4.6, and 3.5.3 contain a charset-unaware byte-wise escape routine that allows an attacker-supplied lead byte to absorb the connector-inserted backslash (0x5C) as a multi-byte trail byte, leaving the following quote (0x27) unescaped and terminating the SQL string literal. No public exploit code has been identified at time of analysis and this CVE is not in the CISA KEV catalog, but the root technique is well-documented in public security literature as the classic GBK/Big5 multi-byte escape bypass.

PAM dialog authentication in MariaDB Connector/Node.js discloses account passwords in cleartext when connections use plain TCP, because the SendPamAuthPacketFactory handler omitted the secure-transport gate that was already applied to the sibling mysql_clear_password plugin. Applications connecting to MariaDB with default settings (sslMode=DISABLE, restrictedAuth=null) over untrusted network paths are exposed to credential theft by any on-path attacker or rogue server that issues an Authentication Switch Request for the dialog plugin. No active exploitation or public exploit code has been identified; vendor-released patches are available across all active 3.x branches.

Event loop exhaustion in multer (all versions before 2.3.0) allows unauthenticated remote attackers to render a Node.js server completely unresponsive using a single small multipart/form-data request. Two specially crafted field names - a large numeric array index followed by a non-numeric key - cause multer's underlying append-field dependency to synchronously iterate a maximum-length sparse array, permanently blocking the event loop and preventing the process from handling any further requests. No public exploit has been identified at time of analysis, but the attack requires no authentication and a minimal payload, making it trivially automatable against any Node.js application using unpatched multer.

Remote denial-of-service in the Node.js multer middleware (all versions before 2.3.0) allows unauthenticated attackers to crash the entire Node.js process by submitting a small, specially crafted multipart/form-data request. The attack exploits an uncaught RangeError in multer's append-field dependency: a first field with an extremely large numeric index allocates a maximum-length sparse array, and a second field pushes past that limit, throwing an exception that multer does not catch. No public exploit code has been identified at time of analysis, but the zero-authentication, low-complexity nature of the attack makes this a realistic availability threat for any internet-facing Node.js application using multer.

Race condition in multer's file stream handling allows uploaded files exceeding the configured fileSize limit to bypass size-limit rejection when an application uses an asynchronous fileFilter in combination with the fileSize limit. All multer versions before 2.3.0 are affected. Practical impact is constrained because the underlying busboy multipart parser still truncates the stream at the configured limit, making this a logic bypass of the rejection mechanism rather than uncontrolled resource consumption or data exfiltration; the fix is available in multer 2.3.0.

File descriptor exhaustion in multer 2.2.0's DiskStorage engine allows remote unauthenticated attackers to cause denial of service by repeatedly sending aborted or malformed multipart upload requests. Each aborted request causes multer to delete the visible file entry while leaving the underlying write file descriptor open, retaining disk blocks until process exit. With no public exploit identified at time of analysis and no CISA KEV listing, this is nonetheless trivially automatable - any publicly exposed upload route using DiskStorage is a viable target.

Log forging in morgan HTTP request logger middleware for Node.js (all versions prior to 1.12.0) allows unauthenticated remote attackers to inject Unicode line separator characters - U+0085 (Next Line), U+2028 (Line Separator), and U+2029 (Paragraph Separator) - into log output via attacker-controlled token values such as the Basic auth username surfaced through the remote-user token. This causes Unicode-aware downstream log processors and SIEM pipelines to split a single HTTP request record into multiple logical entries, enabling false log injection and audit trail manipulation. This is an incomplete-fix follow-up to CVE-2026-5078, which addressed only ASCII control characters; no public exploit has been identified at time of analysis.

Remote code execution in Budibase self-hosted server before 3.41.3 lets authenticated administrators run arbitrary JavaScript by uploading a crafted plugin tarball, which the server passes to eval() unsandboxed in the main Node.js process. Because default deployments run that process with root privileges, an attacker who reaches an admin account can read environment variables and stored credentials and fully compromise the host. No public exploit has been identified at time of analysis, though the flaw was reported by VulnCheck with a vendor security advisory.

Log injection in @logtape/syslog allows network-accessible attackers to forge arbitrary syslog records in downstream collectors such as rsyslog, Splunk, and Elastic Stack. The escapeStructuredDataValue() function omits C0 control character escaping, so a literal newline embedded in a log property value terminates the current RFC 6587 TCP syslog frame and begins a new one; if the attacker-supplied bytes constitute a valid RFC 5424 header, the downstream collector accepts them as a separate, authentic-looking record. A second injection path exists through unvalidated SD-NAME keys, which can prematurely close structured-data elements. Both paths require the non-default SyslogSinkOptions.includeStructuredData: true setting. Publicly available proof-of-concept code exists; no CISA KEV listing at time of analysis.

SCTP state cookie forgery in mediasoup (npm 3.20.0-3.20.5, Rust crate 0.22.0-0.22.4) permits an on-path attacker to establish unauthorized SCTP associations and inject DataChannel messages as a trusted peer, violating RFC 9260 Section 5.1.3. The root cause is that cookie validation relies entirely on two hardcoded magic constants ('msworker' and 0xAD81) rather than a per-instance HMAC secret - all remaining cookie fields are attacker-controlled, and COOKIE-ECHO packets bypass verification-tag and CRC32c checks by design. No public exploit has been identified at time of analysis; real-world risk is bounded by the narrow attack surface: only PlainTransport and PipeTransport with SCTP enabled and without DTLS/SRTP are vulnerable, while the far more common WebRtcTransport path is explicitly unaffected.

DNS rebinding in genieacs-mcp's Streamable HTTP transport (versions <= 0.3.1) allows a malicious website to route browser requests through loopback to the unauthenticated /mcp listener and invoke arbitrary GenieACS NBI operations against managed CPE devices. Affected deployments expose full read/write access to TR-069 device state - including firmware update tasks, parameter changes, device reboots, presets, and connection requests - to any attacker who can lure the server operator to a malicious web page. A proof-of-concept is documented in the GitHub security advisory (GHSA-cmwv-wf9p-p8wx); no CISA KEV listing is present, indicating targeted rather than widespread exploitation at time of analysis.

Credential leakage in the urllib Node.js HTTP client (npm package node-modules/urllib) allows attacker-controlled redirect targets to capture sensitive authentication headers sent by the victim application. Versions through 4.9.0 (v3/v4 branch) and through 2.44.0 (v2 branch) recursively reuse the original caller-supplied options object - including Authorization, Cookie, Proxy-Authorization, x-api-key, x-auth-token, and x-access-token headers - when following redirects to a different origin, violating the WHATWG Fetch specification's cross-origin header-stripping requirement. No public exploit code has been released beyond the proof-of-concept topology described in the GHSA advisory, and no active exploitation has been confirmed by CISA KEV at time of analysis.

Path traversal in the Mercado Pago Node.js SDK allows attackers who can influence payment, refund, or disbursement identifiers handled by merchant applications to redirect outbound API calls to unintended Mercado Pago endpoints, carrying the merchant's own access token. The affected clients - payment (get, capture, cancel), paymentRefund (create, total, list, get), advancedPayment (get, capture, cancel, update, updateReleaseDate), and disbursementRefund (create, createAll, listAll) - construct API paths via unencoded template literals, allowing dot-dot sequences and question marks to traverse to alternate endpoints or append attacker-chosen query parameters. No public exploit has been identified at time of analysis, and exploitation is conditional on merchant applications forwarding unvalidated, user-supplied identifiers directly to the SDK.

Server-side request forgery and address-policy bypass in fast-uri, the Node.js URI parser used widely in the fastify ecosystem, allows remote unauthenticated attackers to redirect outbound requests from a target application to local or private IPv6 addresses by submitting crafted bracketed IPv6 literals with invalid trailing characters. The custom IPv6 parser silently normalizes malformed literals - collapsing some to the unspecified address (loopback) and others to private-range addresses - and returns no error on the parsed result, defeating any application-level error checking. No public exploit code or CISA KEV listing has been identified at time of analysis, but the attack requires no special privileges and low complexity, making automated exploitation plausible against any exposed application that normalizes untrusted URLs through an affected fast-uri version.

Parsing and serialization inconsistency in fast-uri, the Node.js URI parser core to the Fastify ecosystem, allows network-accessible, unauthenticated attackers to supply percent-encoded slashes in the scheme component, causing the library to report host as undefined during parsing while serialization emits a network-path reference with an attacker-controlled authority. Applications that allowlist requests on the parsed host value, or that treat a no-authority parse result as safe to resolve against a base URI, are bypassed - enabling server-side request forgery, off-site redirects, and address-policy evasion. No public exploit has been identified at time of analysis, but the CVSS vector (AV:N/AC:L/PR:N/UI:N) confirms exploitation requires no authentication and no special configuration, making affected deployments an immediate upgrade priority.

Double-decoding of percent-encoded hostnames in fast-uri (Node.js URI parser) creates a server-side request forgery and host-policy bypass primitive in versions 2.4.1-2.4.4, 3.1.2-3.1.5, and 4.0.0-4.1.2. The library decodes percent escapes once during hostname parsing and again during authority recomposition, so a single normalize or resolve call on a doubly-encoded input can silently resolve to a different network destination - including loopback addresses - than the encoded form represents. Any application layer sitting fast-uri in front of outbound routing guards, redirect allow-lists, or host-policy checks is therefore vulnerable to SSRF. This is an incomplete-fix variant of CVE-2026-6322; no public exploit code or active exploitation (CISA KEV) has been identified at time of analysis.

Host confusion in fast-uri, a Node.js URI parser in the Fastify ecosystem, allows policy bypass by exploiting inconsistent host canonicalization between the library's own entry points. When a scheme-relative reference (e.g., //unicode-host.example/path) is passed without an explicit scheme, fast-uri's parse, normalize, and equal functions return the host verbatim, while resolve canonicalizes it to ASCII/Punycode - meaning the same input yields different host values depending on which API is called. An application that extracts a host for an allowlist check via one code path and then resolves the URI via another can be tricked into approving one host while the actual request is dispatched to a different one. No public exploit exists and CISA KEV listing is absent, but the EPSS-independent integrity impact (CVSS I:H) is real in applications relying on fast-uri for security-critical URI validation. Fixed versions are 2.4.5, 3.1.6, and 4.1.3.

Path traversal in exceljs-hardened before 5.0.0 allows unauthenticated attackers to read arbitrary files from the server filesystem by supplying crafted paths to the Workbook.addImage() function, which performs no input validation before passing the value to Node.js file system APIs. Any Node.js application that exposes this function to user-controlled input is at risk of exposing secrets, credentials, configuration files, and any other content readable by the process. No public exploit has been identified at time of analysis; vendor-released patch is available as version 5.0.0.

Command injection in better-npm-audit through 3.11.0 (and the 4.0.0-rc.2 prerelease) allows arbitrary OS command execution when a value containing shell metacharacters is supplied to the --registry CLI flag. The vulnerability exists because handleInput.ts interpolates the raw registry value into a shell command string that is then passed to Node.js child_process.exec(), which spawns a system shell and interprets metacharacters such as semicolons, pipes, and backticks as command separators or substitutions. No confirmed active exploitation or CISA KEV listing exists at time of analysis, but the vulnerable code path is publicly documented in GitHub issue #119 and the diff of PR #120, significantly lowering the barrier to exploit development.

Unauthenticated resource exhaustion in Keystone CMS (Node.js) prior to version 6.5.3 allows any remote GraphQL client to bypass the configured `graphql.maxTake` record-count limit by supplying a negative `take` value, since the comparison `(take ?? Infinity) > maxTake` evaluates to false for negative integers regardless of their magnitude. The bypass applies to both top-level list queries and relationship sub-queries, enabling an attacker to force the server to retrieve an unbounded number of database records and exhaust service resources. No public exploit code has been identified at time of analysis, though the fix and advisory are publicly available.

ReDoS (catastrophic regex backtracking) in Checkmate monitoring platform versions 3.5.1 through 3.9.1 allows an authenticated admin or superadmin to freeze the entire Node.js application for all users by supplying a malicious regular expression in an HTTP monitor's expectedValue field. The vulnerable code in AdvancedMatcher.ts evaluates the regex synchronously on the Node.js main event loop against an attacker-supplied HTTP response body with no timeout or worker isolation, causing complete availability loss. Fixed in v3.9.2 by replacing JavaScript's native RegExp with the RE2 library, which guarantees linear-time complexity. No public exploit or CISA KEV listing identified at time of analysis.

CRLF injection in @fastify/busboy's multipart part-header parser allows unauthenticated remote attackers to embed bare carriage return or line feed characters into parsed Content-Disposition filenames and field names, which are then handed to applications as if they were clean values. All versions through 3.2.1 are affected; the fix is in 3.2.2. When applications forward these tainted values to CR/LF-sensitive sinks - HTTP response headers, log systems, or filesystem paths - attackers can achieve log forging, HTTP header injection, or filesystem filename pollution. No public exploit or CISA KEV listing has been identified at time of analysis.

Heap exhaustion denial-of-service in the node-opcua npm library (versions ≤ 2.165.0) allows an unauthenticated remote attacker to crash the server process by repeatedly initiating OPC-UA sessions with unique nonces. The root cause is a process-global nonce cache (`g_alreadyUsedNonce`) that accumulates entries indefinitely with no TTL or eviction, causing unbounded heap growth measurable at approximately 1.23 MB per 5,000 nonces - achievable OOM under default Node.js heap limits. No public exploit code is identified beyond researcher-disclosed proof-of-concept details in GHSA-6wvw-vrw4-363w; exploitation requires only network access and a trivial script.

Arbitrary code execution in @cgauge/yaml (all versions ≤ 0.27.0) is achieved by embedding a custom `!js` YAML tag in a document supplied to the parser; the library's tag handler unconditionally passes the tag's string value to `eval()`, granting attackers the full authority of the Node.js runtime - including filesystem access, environment variable exfiltration, network calls, and subprocess spawning. No safe-mode parsing option or opt-out mechanism exists in the library, meaning every call site that parses attacker-controlled YAML is unconditionally vulnerable. A public proof-of-concept exploit is available via GitHub Gist, and no vendor-released patch has been identified at time of analysis.

Path traversal in @logto/tunnel (versions <= 0.3.8) exposes arbitrary file read to any network peer that can reach the tunnel port when the --experience-path flag is active. The Node.js static file proxy passes request.url directly into path.join(staticPath, request.url) followed by fs.open without URL normalization or containment checks, allowing ../ sequences to escape the configured static directory. A working proof-of-concept is publicly documented in GHSA-rxjr-6c9q-h67x; no active exploitation is confirmed in CISA KEV as of the analysis date, and the vendor-released fix is version 0.3.9.

Hardened-mode SSRF protections in the mcp-searxng Node.js MCP server (npm/mcp-searxng < 1.2.1) can be bypassed via three distinct techniques, allowing `web_url_read` to fetch loopback and internal network resources despite `MCP_HTTP_HARDEN=true` being set. The bypasses exploit: unvalidated HTTP redirect chains to internal addresses, the unblocked `0.0.0.0` special address, and IPv4-mapped IPv6 literals that survive Node's WHATWG URL canonicalization intact but defeat regex-based private-address filters. Publicly available proof-of-concept code demonstrates all three bypass paths returning content from a loopback sentinel service; no KEV listing exists at time of analysis.

Server-Side Request Forgery in @contentful/mcp-tools allows any party who can invoke MCP tools or inject instructions into Contentful content to redirect the server's Contentful Management API Personal Access Token (PAT) to an attacker-controlled endpoint. The export_space and import_space tools spread LLM-controlled arguments - including host, proxy, rawProxy, and insecure - directly into the options object alongside the server-side PAT, causing the Contentful Management SDK to build its baseURL from attacker input and attach Authorization: Bearer <PAT> to all outgoing requests. A confirmed working proof-of-concept exists demonstrating both host-redirect and proxy-redirect vectors; no CISA KEV listing was identified at time of analysis, but the prompt injection path requires zero MCP privileges and represents a high-severity real-world risk for any AI agent reading untrusted Contentful content.

Command injection in Renovate's npm manager (versions 35.63.0 through 40.33.0) allows attackers with repository write access to execute arbitrary commands on the CI/CD host running Renovate by supplying malicious `packageName` values via a crafted `renovate.json5` configuration file. The root cause is in `lib/modules/manager/npm/post-update/npm.ts`, where user-controlled package names and workspace keys are interpolated directly into shell commands during lock file maintenance without shell escaping via `shlex.quote()`. A working proof of concept is publicly available in the official GitHub Security Advisory (GHSA-fr4j-65pv-gjjj), and a vendor-released patch exists in version 40.33.0; no confirmed active exploitation has been reported at time of analysis.

Environment variable exposure in Renovate (versions 42.68.1 through 42.96.3 and 43.0.0 through 43.4.4) leaks the full process environment - including privileged credentials - into every child process spawned during dependency update operations. The regression was introduced inadvertently on 2025-12-30 when Renovate migrated to the `execa` library, whose default behavior extends rather than replaces environment variables, silently bypassing Renovate's intended allowlist filtering. Both insider attackers (with repository write access) and outsider attackers (via supply-chain compromise of a processed dependency) can embed credential-harvesting code in scripts that Renovate executes, exfiltrating GitHub tokens, registry credentials, and cloud IAM keys accessible to the deployment. No public exploit has been identified at time of analysis, but the vendor explicitly recommends rotating all credentials that affected Renovate instances had access to.

Schema validation bypass in fastify before version 5.12.1 allows authenticated network attackers to submit request bodies that circumvent type enforcement when schemas target root-level primitive values. When Ajv coerces a submitted JSON string to match an expected integer or other primitive type during validation, fastify fails to propagate the coerced value back to the route handler, which instead receives the original unvalidated string. No public exploit code has been identified at time of analysis, but the flaw directly undermines integrity and access-control logic in any application that relies on schema-validated primitive types for authorization or business-rule decisions.

Header spoofing in fastify 5.8.3 through 5.12.0 persists despite the prior CVE-2026-3635 patch because the numeric trustProxy form compiles to a hop-count predicate that structurally ignores the connecting address, rendering the guard introduced by the earlier fix completely ineffective for this configuration. An attacker who can reach the Fastify origin server directly - bypassing the front-facing reverse proxy - can forge X-Forwarded-For, X-Forwarded-Host, and related fields that fastify uses to derive request.ip, request.hostname, request.host, and request.protocol, enabling host injection in generated URLs, HTTPS-enforcement bypass, secure-cookie and CSRF-origin spoofing, and host-based routing and cache poisoning. No public exploit has been identified at time of analysis; the vendor-released fix is fastify 5.12.1, which disables the numeric trustProxy form entirely.

Cross-dataset authorization bypass in GeoLens prior to 1.2.3 allows unauthenticated network callers and low-privileged authenticated users to read private dataset content - including vector tile geometries, raster pixels, backing-table rows, column schemas, and sampled values - that they have no access to. The root flaw is a consistent pattern across six distinct endpoints: the API authorizes the resource named in the URL but fails to re-authorize a second, caller-influenced dataset reached through a relationship, layer reference, VRT mosaic, or request body. No public exploit has been identified at time of analysis, but the most severe findings require zero authentication, making them trivially exploitable by any network-reachable caller.

Arbitrary command execution in Hugo 0.162.0 through 0.164.x occurs when the static site generator builds a project whose Tailwind configuration is supplied by an attacker-controlled theme, module, or starter template. Because these releases added tailwindcss to the AllowChildProcess default, Hugo launches the tool with --allow-child-process, and any top-level JavaScript in tailwind.config.js (loaded via require at startup) can spawn a non-Node shell that inherits none of the Node.js permission restrictions and runs with the full privileges of the build account. This is a build-time supply-chain execution flaw with no public exploit identified at time of analysis; it was reported by VulnCheck and fixed in Hugo 0.165.0.

Environment variable inheritance in CodeWhale's js_execution tool prior to version 0.8.64 allows crafted JavaScript payloads to read the full parent process environment via process.env, exposing API keys, cloud credentials, and authentication tokens to the model context. The affected codebase is a Rust TUI AI coding assistant whose Node.js child process spawning failed to sanitize the environment before execution. No public exploit code or CISA KEV listing has been identified at time of analysis; a vendor patch is available via GitHub advisory GHSA-h539-c7r8-3xq4.

Prototype pollution in ApostropheCMS 4.32.0 and earlier enables an authenticated editor to trigger a persistent, process-wide denial of service via a single PATCH REST API request. By sending `{ "toString.call": "x" }` to `PATCH /api/v1/article/:id`, the attacker walks the JavaScript prototype chain through `apos.util.set()` into the shared `Object.prototype.toString` function object and shadows its `call` method, breaking every subsequent `Object.prototype.toString.call()` invocation in Node.js - including those inside the MongoDB driver - until the server process is manually restarted. No separate proof-of-concept repository has been published, but the exact attack payload is fully disclosed in the public GitHub security advisory GHSA-vmg4-6gfg-83qx and the upstream commit diff, and active exploitation has not been confirmed by CISA KEV.

Path traversal in ApostropheCMS's import-export module (versions prior to 3.6.2) allows an authenticated contributor to exfiltrate host files and expose them publicly via the CMS uploads URL. By importing a crafted `.tar.gz` archive with `../` sequences embedded in the `_id`, `name`, or `extension` fields of `aposAttachments.json`, an attacker causes the module to reconstruct a source path that escapes the extraction directory, reading any host file whose name ends with an allow-listed extension and copying it to a publicly accessible, unauthenticated uploads endpoint. No public exploit is identified at time of analysis; vendor-released patch is available in version 3.6.2.

Stored cross-site scripting in ApostropheCMS prior to 2.17.6 enables execution of arbitrary JavaScript in victim browsers through a parser-differential bypass in the bundled sanitize-html library. When `textarea` or `xmp` is included in a site's `allowedTags` configuration, a payload using a trailing solidus on the closing tag - such as `</textarea/>` - is treated as text by htmlparser2 10.x but as a valid close by spec-compliant browsers, causing injected markup like `<img onerror=...>` to execute as live HTML on page load. No public exploit repository has been identified and the vulnerability is not listed in the CISA KEV catalog, but a functional proof-of-concept payload is fully described in the upstream security advisory GHSA-jxwj-j7wr-gfrw; the fix ships in version 2.17.6.

Integrity bypass in ApostropheCMS page management allows authenticated low-privileged editors to move pages into restricted subtrees they have no create rights over, and indirectly re-rank admin-only sibling pages via an unchecked database updateMany call. All deployments running ApostropheCMS prior to 4.32.0 are affected; the flaw exists in the REST page update endpoint and requires no special configuration to reach. No public exploit code exists and the vulnerability is not listed in CISA KEV, but the attack path through documented REST parameters is straightforward for any CMS insider.

Sandbox escape to remote code execution in the vm2 Node.js sandbox library (versions <= 3.11.5) arises because handleException() in lib/setup-sandbox.js sanitizes SuppressedError and AggregateError sub-errors but never inspects the ES2022 Error.cause property. Untrusted code running inside the sandbox that catches a host-thrown error carrying a .cause (or other own property) pointing at a host object such as process can dereference it to reach child_process and run arbitrary host commands. A working proof-of-concept demonstrating full RCE is published in the GitHub advisory, and the flaw is fixed in vm2 3.11.6; there is no CISA KEV listing indicating active exploitation.

Arbitrary command execution in the conflibot GitHub Action (versions before 1.2.1) lets any user who opens a pull request run shell commands on the workflow runner. conflibot builds git commands via string interpolation and executes them through a shell, and one interpolated value is the attacker-controlled PR head branch name (head.ref); a branch name containing shell metacharacters is executed as code. Under the documented pull_request_target configuration the runner holds a write-scoped GITHUB_TOKEN and repository secrets, so this is a critical CI/CD supply-chain exposure (CVSS 9.1). There is no public exploit identified at time of analysis, but the technique is well understood and the trigger is trivial.

Stack exhaustion denial-of-service in deepmerge-ts crashes Node.js processes when attacker-controlled recursive object graphs are passed to `deepmerge()`, `deepmergeInto()`, `deepmergeCustom()()`, or `deepmergeIntoCustom()()`. All versions prior to 8.0.0 lack cycle detection in the recursive record-merge routine, allowing two self-referencing objects sharing a key path to drive the process into infinite recursion until the Node.js runtime throws `RangeError: Maximum call stack size exceeded`. A public proof-of-concept is included in the GitHub security advisory; no CISA KEV listing exists at time of analysis.

Stored cross-site scripting leading to remote code execution in SiYuan (a self-hosted personal knowledge-management notebook) before v3.7.4 lets an attacker with write access poison PDF annotation fields via the setFileAnnotation endpoint; because SiYuan is an Electron application, the injected markup runs as JavaScript in the PDF renderer with full Node.js privileges when a victim opens the annotated PDF, escalating a web injection into host-level code execution. No public exploit has been identified at time of analysis and it is not listed in CISA KEV, but the CWE-79 root cause combined with Node.js integration makes this a full-compromise primitive rather than a benign script injection.

Unauthenticated path traversal in the token-optimizer-mcp dashboard server (npm package @ooples/token-optimizer-mcp v5.0.1) allows any network-accessible attacker to read arbitrary .jsonl files from the server's filesystem by supplying a crafted sessionId parameter to /api/session-summary or /api/session-events. The CVSS vector (PR:N, AV:N, AC:L, UI:N) confirms zero authentication or user interaction is required, and a working proof-of-concept demonstrating successful out-of-bounds file exfiltration has been publicly disclosed in GHSA-76pc-mqxp-3rq5. No active exploitation has been confirmed by CISA KEV, but the trivial exploitation complexity and public PoC make this an immediate priority for any internet-exposed deployment.

OS command injection in @ooples/token-optimizer-mcp v5.0.1 and earlier allows any MCP client that can call the smart_user tool to execute arbitrary shell commands with the privileges of the MCP server process. The get-user-info operation interpolates the caller-controlled username argument directly into a shell command string passed to Node.js execAsync(), and the double-quoting applied by the developer does not prevent POSIX shell command substitution via $(...) or backtick syntax. A complete, working proof-of-concept is publicly available via GHSA-49mq-fc6q-3h46; no public exploit identified at time of analysis as actively exploited per CISA KEV, though the low exploitation complexity makes this a high-priority patching target.

Exponential parsing time in js-yaml 5.0.0 through 5.2.1 enables unauthenticated remote denial of service via a crafted YAML payload under 200 bytes. The parser's flow-collection logic re-parses nested flow-sequence keys rather than caching results, producing O(2^n) work per nesting level - approximately 30 levels suffices to stall a Node.js process for over two minutes on a single CPU. A functional proof-of-concept is published in the GHSA advisory; no special YAML features or non-default configuration options are required to trigger the flaw.

Template-literal code injection in TypeORM's migration:generate command allows an attacker with database schema write access to achieve arbitrary JavaScript execution on any host that loads the generated migration file. Affected are TypeORM npm versions prior to 0.3.31 (0.x branch) and versions 1.0.0 through 1.0.x (fixed in 1.1.0), spanning PostgreSQL, MySQL, MariaDB, and CockroachDB drivers. No active exploitation has been confirmed (not in CISA KEV) and no public exploit code has been identified at time of analysis; however, the GHSA advisory provides sufficient technical detail to reproduce the attack.

Cross-site scripting in SVGO's script-removal plugin exposes web applications that process untrusted SVG uploads to stored XSS attacks across all major version lines from 1.0.0 through 4.0.1. The removeScripts plugin (called removeScriptElement in v1-3) silently passes through namespace-prefixed script elements such as `<svg:script>` and performs case-sensitive JavaScript URI matching that attackers trivially bypass with mixed-case variants like `JavaScript:`. Applications serving SVGO-optimized SVGs to end users face cookie and session token theft; patches are available in versions 2.8.3, 3.3.4, and 4.0.2, with a public proof-of-concept included in the GitHub security advisory GHSA-2p49-hgcm-8545.

Predictable SM2 private-key and signing-nonce generation in the sm-crypto npm library (versions prior to 0.5.0) lets an attacker recover keys generated in Node.js. Because jsbn's SecureRandom checks window.crypto rather than Node's globalThis.crypto, the default sm2.generateKeyPairHex() falls back to seeding an ARC4 stream from Math.random() and the wall clock, so an adversary who observes a few Math.random() outputs and estimates the generation time can reconstruct private keys and forge signatures. Publicly available exploit code exists (reproduced end-to-end against the real npm packages), but no public exploit is identified as being used in active attacks and there is no CISA KEV listing.

Stack-exhaustion denial-of-service in node-tar (npm package `tar`) versions up to and including 7.5.20 allows unauthenticated remote attackers to terminate any Node.js process that lists or extracts selected members from an attacker-controlled archive. The vulnerable `mapHas` recursion in `filesFilter` overflows the call stack before any depth guard can execute, and the resulting `RangeError` is uncatchable by standard `try/catch` on async and streaming consumers - the dominant server-side usage pattern. A publicly available proof-of-concept demonstrates the crash using a payload of approximately 188 bytes gzipped; no active exploitation confirmed in CISA KEV at time of analysis.

Unbounded memory growth in @hono/node-server 2.0.0-2.0.9 allows unauthenticated remote attackers to exhaust server memory and cause denial of service by flooding any public WebSocket upgrade route with requests bearing a missing or malformed Sec-WebSocket-Key header. The root cause is a missing cleanup path in src/websocket.ts: when ws.handleUpgrade rejects the handshake, no connection event fires, leaving the IncomingMessage permanently retained in waiterMap and the waitForWebSocket promise perpetually pending. No public exploit or active exploitation (CISA KEV) has been identified at time of analysis; the fix is available in v2.0.10.

Resource exhaustion DoS in @anephenix/hub (npm) before 0.2.16 allows any unauthenticated remote client to exhaust server CPU and memory by opening WebSocket connections and ignoring all server RPC messages. Each connection triggers a 10ms setInterval polling loop and a heap entry in the RPC request queue; because the socket close handler never cancels these allocations, they accumulate without bound until the process becomes unresponsive. No active exploitation is confirmed (not in CISA KEV); vendor-released patch is available in v0.2.16.

Predictable temporary file paths in Etherpad's import and export handlers expose multi-tenant deployments to a symlink-based file overwrite attack. All ep_etherpad-lite versions through v3.0.0 are affected; exploitation requires local host access, an unprivileged OS account, and - for high-impact scenarios - the Etherpad process running as root, a common default in many Docker base images. A proof-of-concept sketch is included in the vendor advisory GHSA-2jwf-f4xq-f24h; no public weaponized exploit code beyond that sketch exists and this vulnerability is not listed in the CISA KEV catalog.

CPU exhaustion in @fastify/busboy 3.1.0-3.2.0 allows a remote unauthenticated attacker to stall the Node.js event loop by sending a single crafted multipart request. The parser's vendored streaming search algorithm stores its Boyer-Moore-style skip table in a fixed 256-entry byte array; supplying a boundary of exactly 252 bytes causes the computed search needle to reach 256 bytes, collapsing the skip distance to zero and converting an O(n) search into an unbounded CPU-bound loop. Because Node.js is single-threaded and event-driven, one stalled core prevents all other requests from being processed by the same worker, achieving denial of service with minimal bandwidth. No public exploit has been identified at time of analysis, but the attack primitive is trivially reproducible from the advisory.

Unauthenticated denial of service in @fastify/busboy versions 1.0.0 through 3.2.0 allows any network attacker to crash the Node.js process by submitting a multipart form with a header whose name collides with a prototype-inherited JavaScript property such as __proto__ or constructor. The internal header store uses a plain object inheriting from Object.prototype, so the inherited property resolves to a truthy non-array value that triggers a synchronous TypeError when array methods are invoked on it; in direct write/end usage paths this exception propagates uncaught and terminates the process. No public exploit code has been identified at time of analysis, but the attack is trivially constructable given the detailed advisory.

Server-side template injection leading to remote code execution in Microsoft's @prompty/core npm package (TypeScript runtime) allows an attacker who controls a .prompty template body to execute arbitrary JavaScript in the host Node.js process. The flaw affects @prompty/core versions <= 0.1.4 and the 2.0.0-alpha.1 through 2.0.0-beta.4 pre-releases, where the Nunjucks renderer permitted unrestricted member access, letting a malicious template walk constructor/prototype chains to reach a JavaScript execution primitive. No public exploit identified at time of analysis and it is not listed in CISA KEV, but the maximum CVSS of 10.0 and CWE-94 code-injection root cause make this a critical-priority patch for any app that renders untrusted, community-supplied, cloned, or LLM-generated .prompty files.

Arbitrary JavaScript code execution in Faker.js prior to 10.5.0 is achievable when attacker-controlled strings reach the `faker.helpers.fake` template engine. The vulnerability resides in `fakeEval.resolveProperty` in `src/modules/helpers/eval.ts`, where direct property access on a function return value (`entrypoint?.[key]`) allows traversal to the `Function` constructor via `constructor.constructor`, a classic sandbox escape. Applications that pass any user-supplied input to `faker.helpers.fake` on the server side are directly exposed to remote code execution; in local/development contexts, exploitation requires low-privileged access to control template strings. No public exploit identified at time of analysis, and the fix is available in version 10.5.0.

Unauthenticated OS command injection in Claude Code Templates before 1.29.4 allows arbitrary shell command execution with the developer's privileges when the --studio flag is active. The vulnerable sandbox server (cli-tool/src/sandbox-server.js) bound to all network interfaces on port 3444, emitted Access-Control-Allow-Origin: *, and passed HTTP request-body fields - the prompt parameter to /api/execute and the agentName parameter to /api/install-agent - directly into child_process.spawn() with shell:true enabled, causing the shell to interpret attacker-controlled metacharacters. This vulnerability is not listed in CISA KEV; no confirmed public exploit code has been identified at time of analysis, but the detailed commit diff and security advisory provide sufficient technical disclosure for trivial reproduction.

Unbounded in-memory caches in Browserslist prior to 4.28.7 allow unauthenticated remote denial-of-service via Node.js out-of-memory crash when an attacker can influence repeated query values passed to browserslist() at runtime. Both the query-result cache and the parseQuery AST cache grew as plain JavaScript objects with no size cap, TTL, or eviction - the `since <year>-<month>-<day>` syntax provides a practically infinite key space ideal for flooding. The caller-controlled BROWSERSLIST_DISABLE_CACHE environment variable is ineffective as a compensating control because it only suppresses the result cache, not parseCache. No public exploit code has been identified and the vulnerability is not in CISA KEV; the vendor-released fix is version 4.28.7.

Prototype pollution and denial-of-service in Browserslist prior to 4.28.7 enable attackers to crash Node.js processes or corrupt object prototypes by supplying crafted stats data to the unconditionally-called `normalizeStats()` function. Any application that invokes `browserslist()` with attacker-influenced `browserslist-stats.json`, `opts.stats`, or CLI `--stats` input is at risk of an uncaught TypeError or object prototype modification. The vendor-released patch is available in version 4.28.7, and no public exploit has been identified at time of analysis.

Sandbox escape in Activepieces prior to version 0.80.0 allows authenticated users with Code step creation rights to execute arbitrary Node.js code in the host engine process, bypassing the V8 isolate entirely. The flaw exists because the engine calls importFresh() - a wrapper around Node.js require() - to load user-supplied compiled modules before the V8 sandbox is instantiated, meaning top-level module code runs unrestricted in the host process. An attacker exploiting this can exfiltrate platform-critical environment secrets (AP_ENCRYPTION_KEY, AP_JWT_SECRET), read or write arbitrary files on the host, and reach internal services; no public exploit has been identified at time of analysis, but key compromise would have platform-wide cascading consequences.

Prototype pollution in n8n's Edit Fields (Set) node allows any authenticated user with workflow execution permissions to corrupt a shared global in the main Node.js process, triggering an instance-wide denial of service that locks out all users until a manual process restart. Affected are all n8n releases before 1.123.67, 2.31.5, and 2.32.1 across the 1.x and 2.x branches. The attack requires only a low-privilege authenticated account and no special configuration, making this a high operational priority for any multi-user or shared n8n deployment; no public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.

Software supply-chain compromise of react18-use, a small React 19 `use`-hook shim maintained by dai-shi, in which malicious commits pushed to the GitHub default branch between 2026-05-19 01:07:01 and 15:20:43 UTC added a `postinstall` script (`src/install.js`) that runs attacker-controlled remote code on developer machines during `npm install`. The malicious commits were later removed by force-push and the package was never published to npm, but local clones, forks, and direct-SHA URLs still carry them, so any `npm install` against an affected checkout still executes the payload today. There is no public exploit identified at time of analysis and it is not on CISA KEV, but the embedded code itself constitutes working malware (CWE-506); anyone who ran `npm install` on a developer workstation on or after 2026-05-19 01:07:01 should assume full host compromise.

Malicious code injection in the react-tracked source repository (GitHub dai-shi/react-tracked) allowed attacker-controlled remote code execution on developer machines during dependency installation. Between 2026-05-18 19:26:36 and 2026-05-19 15:22:45 UTC the default branch carried booby-trapped commits (6978272 through 949f1a3) that added a postinstall hook fetching and evaluating a second-stage payload from an attacker HTTPS endpoint. The malicious commits were force-pushed away and the package was never published to npm, so npm registry consumers are unaffected, but anyone who ran `npm install` against a poisoned checkout, fork, or direct-SHA clone still executes the code today. No public exploit identified at time of analysis and the flaw is not on CISA KEV, though the incident is a confirmed real compromise rather than a theoretical bug.

Terminal escape sequence injection in npm-check-updates through 23.0.2 enables a supply-chain attacker who controls a malicious npm package's metadata to embed arbitrary VT100/OSC control sequences in the `homepage` or `repository` URL fields of `package.json`. When developers run `ncu --format homepage` or `--format repo`, these unfiltered sequences are written directly to the terminal, allowing output overwriting via bare carriage returns, terminal title hijacking via OSC sequences, and other display manipulation on developer workstations or CI runners. No public exploit has been identified at time of analysis and no CISA KEV listing exists, but the fix PR's test suite demonstrates the exact attack pattern using OSC title-setting sequences and CR overwrites.

Stored XSS in FlyEnv before 4.18.0 allows remote attackers to execute arbitrary JavaScript in the Electron renderer process by injecting unsanitized HTML through markdown sources or AI chat messages rendered via Vue v-html directives. Because FlyEnv's Electron renderer operates with Node.js API integration active, exploitation escalates beyond conventional XSS to effective local code execution with unrestricted filesystem access on the developer's machine. A publicly available exploit exists at GitHub issue #809, and vendor-released patch v4.18.0 addresses the flaw.

OS command injection in Dokploy (self-hosted PaaS) before 0.29.13 lets an authenticated user with the backup:restore permission run arbitrary commands on the Docker-privileged host. The backup.restoreBackupWithLogs tRPC subscription forwards an attacker-controlled databaseName into shell strings that Node.js exec passes to /bin/sh before docker exec, so the outer host shell expands injected metacharacters. Rated CVSS 9.9 with a scope change to the host; no public exploit identified at time of analysis, though the upstream fix PR ships regression tests containing working injection payloads.

Malicious code injection into the use-reducer-async GitHub repository (a small React useReducer-with-async-actions helper by dai-shi) turned developer workstations into remote-code-execution targets during npm install. Between 2026-05-18 16:29:52 and 2026-05-19 15:26:07 UTC the default branch carried attacker-planted commits (da72edb through df07d57) that added src/install.js, wired it into the postinstall hook, fetched an attacker-hosted second-stage payload over TLS-verification-disabled HTTPS, and eval'd it with require available. The malicious version was never published to npm and the commits were force-pushed away, but any local clone, fork, or direct-SHA checkout still triggers the payload on install; there is no CISA KEV listing and no public exploit identified at time of analysis for the reconstructable payload itself.

Supply-chain compromise of the use-context-selector React library (npm package dai-shi/use-context-selector) planted attacker-controlled malicious code that runs during `npm install`. Between 2026-05-18 15:57:18 and 2026-05-19 15:24:34 UTC the GitHub default branch carried malicious commits (9d8481a through 6f2dae0) that added `src/install.js`, wired it into the `postinstall` hook, fetched a second-stage JavaScript payload from an attacker HTTPS endpoint with TLS verification disabled, and evaluated it with `require` available - but only on developer workstations (execution was deliberately skipped on CI and cloud/serverless). The commits were force-pushed out and the package was never published to npm, so there is no public exploit or CISA KEV entry, but any local clone, fork, or direct-SHA checkout retaining those commits will still execute the code on `npm install` today.

Insufficient-entropy secret generation in the crypto-js npm library (all 3.x releases except 3.2.0/3.2.1, i.e. versions < 4.0.0) collapses CryptoJS.lib.WordArray.random() to effective search spaces of only ~2^39 (128-bit request) and ~2^47 (256-bit request), letting attackers brute-force any long-term secret produced by it. Downstream cryptocurrency wallets used this function as the entropy source for BIP39 recovery phrases; Coinspect's 'Ill Bloom' investigation reproduced full key recovery and documented coordinated drain waves that stole a lower-bound of ~$5M in assets as of 13 July 2026. This is not in CISA KEV, but a proof of concept exists and real-world theft has been documented by the researchers.

Process-terminating denial of service in node-re2 (npm package `re2`) up to and including v1.25.0 allows an attacker to kill the entire Node.js process or worker thread with a single crafted request. The native add-on's `WrappedRE2::Replace` calls `.ToLocalChecked()` on a V8 `MaybeLocal` without first verifying it is non-empty; when a global replace uses the `$'` (post-match) or `` $` `` (pre-match) template on ~40,000+ matching characters, the O(input²) output exceeds V8's 536,870,888-character limit, the `MaybeLocal` is empty, and the unchecked call triggers `v8::Utils::ReportApiFailure` → native `abort()` (SIGABRT, exit 134). Unlike the built-in regex engine, which raises a catchable `RangeError`, this crash cannot be intercepted by JavaScript `try/catch`, domains, or `uncaughtException` handlers, making a single malformed request capable of taking down the entire service. A public proof-of-concept is included in the GitHub Security Advisory; no CISA KEV listing was present at time of analysis.

Cross-user HTTP response poisoning in Traefik's default reverse proxy allows an unauthenticated remote attacker using HTTP/2 or HTTP/3 to smuggle responses into other clients' backend connections, potentially delivering authenticated or private content from one user to another. All supported Traefik branches through v2.11.52, v3.6.23, and v3.7.8 are affected in default configuration when fronting Go net/http or gunicorn/Flask backends, which are confirmed 'armed' (respond to CONNECT with keep-alive non-2xx without draining the body). A proof-of-concept is publicly available demonstrating reliable cross-user poisoning including a cascade scenario where 8 of 8 sequential victims read responses that were not their own; no CISA KEV listing was present at time of analysis.

Unauthenticated remote code execution in OpenChamber 1.11.7 lets remote attackers run arbitrary OS commands by POSTing to the /api/fs/exec endpoint, which hands input directly to Node.js spawn() with no allowlist, blocklist, or argument sanitization. Because the authentication middleware silently no-ops when UI_PASSWORD is unset - the state of the default Docker deployment - the endpoint is reachable without credentials and returns full stdout, stderr, and exit code to the attacker. Reported by VulnCheck; there is no public exploit identified at time of analysis and it is not listed in CISA KEV, though the flaw is trivially exploitable.

Command injection in MissionSquad mcp-api through version 1.11.8 enables remote authenticated users to execute arbitrary OS-level commands on the host by supplying a crafted version string to the NPM package installation endpoint. The root cause is string interpolation of unvalidated user input into a Node.js `exec()` call, which passes the resulting string through a shell interpreter - making shell metacharacters in the version parameter an effective injection vector. Proof-of-concept exploit code exists (CVSS 4.0 E:P); no active exploitation has been confirmed by CISA KEV. A patched release (v1.11.9) is available.

Code injection in Electron's DevTools API permits arbitrary script execution in the DevTools context via an unsanitized `mode` parameter supplied to `webContents.openDevTools()`. Unsandboxed Electron applications where untrusted input reaches the `mode` argument - or where untrusted content embedded in a `<webview>` element can invoke `openDevTools()` - are exposed to full Node.js-level code execution on the host operating system. No public exploit has been identified at time of analysis, but Electron's own GitHub Security Advisory (GHSA-4f78-qhmw-8j8m) confirms the flaw and vendor-released patches are available across all active release tracks.

Context isolation bypass in Electron allows untrusted web content loaded by an Electron app to escape the contextBridge security boundary and access the isolated preload world - and potentially Node.js - by hijacking Function.prototype.bind on exposed Promise-returning functions. The vulnerability (CVSS 7.5, S:C) affects the standard pattern developers use to wrap ipcRenderer.invoke calls, meaning a wide class of real-world apps is susceptible if they load any untrusted content. No vendor-side workarounds exist; patched releases are available across all active Electron version lines. No public exploit code or CISA KEV listing has been identified at time of analysis.

Remote code execution and arbitrary file deletion in Zigbee2MQTT stem from an unsanitized path.join() call in ExternalJSExtension.getFilePath() (lib/extension/externalJS.ts), allowing any MQTT client with publish access to escape the extensions directory via traversal sequences and write arbitrary files to the host filesystem. Once the malicious .js file is written, Zigbee2MQTT immediately imports it via Node.js import(), executing attacker-controlled code in the application process context. The same vulnerable code path also backs the extension-removal handler, yielding a second primitive for arbitrary file deletion. No public exploit or KEV listing was identified at time of analysis, but the exploitation path is mechanically straightforward given the detailed description.

OS command injection in the backmeup npm package allows any attacker who can supply input to the package's name, source, destination, or filter options to execute arbitrary shell commands on the backup host or, when SSH mode is configured, on the remote SSH target. The flaw stems from direct string concatenation of option values into shell command strings executed via child_process or ssh2-exec, with no neutralization of metacharacters beyond path.normalize() and path.join(). No public exploit has been identified at time of analysis, but the CVSS vector (PR:L, AV:N, AC:L) indicates this is straightforwardly exploitable by any low-privilege application user whose input reaches the vulnerable call sites.

OS command injection in HashBrown CMS through version 1.4.6 enables any authenticated user holding media resource scope to execute arbitrary shell commands on the server by exploiting a discrepancy between two filename-parsing functions. The MIME-type filter in getMIMEType() truncates filenames at the first '?' character - accepting 'x.jpg?$(command)' as a valid image - while Node.js Path.extname() does not truncate at '?', allowing the full malicious suffix to flow unescaped into a shell exec() call inside the thumbnail generation routine. No public exploit code or CISA KEV listing has been identified at time of analysis, but the technique is well-understood and requires only low-privilege access, making it a meaningful risk for any internet-accessible deployment.

Blind password hash disclosure in Ghost Admin API versions prior to 6.54.1 allows any authenticated staff-level user to retrieve hashed passwords of other staff accounts by crafting filtered API queries against the posts or pages browse endpoints. The root cause is insufficient field-level access control in MongoDB filter queries, exposing internal authentication fields (CWE-200). No active exploitation is confirmed (not in CISA KEV), and downstream account takeover is partially mitigated by Ghost's Device Verification and email MFA features, though the hash disclosure itself is confirmed and unambiguously fixed in 6.54.1.

Cross-site scripting in Ghost CMS (versions 5.26.0 through 6.54.0) allows a high-privileged administrator to plant arbitrary JavaScript via the Universal Import feature, which fails to sanitize the `feature_image_caption` field and link card URLs before storing and rendering them. The fix in v6.54.1 introduces DOMPurify sanitization across both the Ember-based admin post history modal and the Node.js frontend rendering pipeline, alongside a strict URL protocol allowlist in the JSON-to-HTML importer. No active exploitation is confirmed (not in CISA KEV) and no public proof-of-concept is known; the high-privilege prerequisite substantially limits the realistic attacker pool.

Remote code execution in Flowise (npm flowise / flowise-components <= 3.1.2) lets an unauthenticated attacker who can query a chatflow built on the CSV Agent node coerce the backing LLM, via prompt injection, into returning a Python payload that slips past the regex blocklist validator and runs in an unsandboxed pyodide runtime, yielding arbitrary code execution as the Flowise service account. Trend Micro ZDI (Dre Cura, TrendAI Research) demonstrated eight distinct validator-bypass techniques and shipped a working proof of concept; this is scored CVSS 4.0 9.5 (CWE-94). Publicly available exploit code exists, but there is no CISA KEV listing or evidence of active exploitation at time of analysis.

Remote code execution in FlowiseAI Flowise before 3.1.3 lets an attacker execute arbitrary OS commands as the Flowise process by abusing the CSVAgent node, which interpolates an attacker-controlled base64 segment of the csvFile data URI directly into a Python template run by Pyodide. Because Pyodide's default js bridge exposes globalThis (including eval and dynamic import on Node.js), the injected code can break out of the Python string, call js.eval, import fs and child_process, and run host commands; the surrounding validators are never applied to this bootstrap template. A low-privileged workspace user plants the malicious node, after which any unauthenticated request to the public POST /api/v1/prediction/:id endpoint triggers the RCE. No public exploit is identified at time of analysis (no KEV, no POC signal in the provided data), but the fix is confirmed in version 3.1.3.

Flowise's patch for CVE-2025-8943 is fully bypassed in versions up to and including 3.1.2, allowing unauthenticated remote code execution on default deployments via the npm_config_yes environment variable. The prior mitigation blocked the -y and --yes flags on npx and denied four specific environment variable names by exact string match, but npm natively reads its configuration from any npm_config_* prefixed variable, making npm_config_yes=true semantically equivalent to --yes. Any attacker who can submit a Custom MCP stdio server configuration - which requires no authentication on default Flowise deployments - can force npx to auto-install and execute an arbitrary package as the Flowise server process. No public exploit code has been identified at time of analysis, though the bypass technique is fully documented in the public GHSA advisory GHSA-xc48-889x-5qmw, making independent weaponization trivial.

SSRF protection bypass in Flowise (npm/flowise ≤ v3.1.2) allows complete circumvention of all IPv4 CIDR deny rules via IPv4-mapped IPv6 addresses, rendering the SSRF fix introduced in v3.0.13 for CVE-2026-31829 entirely ineffective. An attacker who controls DNS for a hostname referenced in a Flowise chatflow HTTP component can set a AAAA record to `::ffff:169.254.169.254` or any RFC1918 target; Flowise resolves the address, the `isDeniedIP()` kind mismatch silently skips all IPv4 CIDR checks, and the request reaches cloud IMDS endpoints or internal services. A publicly available proof-of-concept script (poc_ssrf_bypass.js) confirms the bypass against ipaddr.js@2.2.0; no CISA KEV listing has been identified at time of analysis.

Remote code execution in FlowiseAI Flowise (npm packages flowise and flowise-components) versions 3.1.2 and earlier lets an authenticated user achieve root command execution on the host by injecting Python into the CSV Agent's Pyodide sandbox, which bridges back to the host Node.js process. Attackers reach OS command execution, credential theft, arbitrary file read, and server crash. A working Metasploit module and root Meterpreter session are documented, so publicly available exploit code exists, though the flaw is not listed in CISA KEV.

Remote code execution as root in Flowise (npm packages flowise and flowise-components, versions 3.0.5 through 3.1.2) lets any authenticated user with a valid API key escape the NodeVM sandbox used by the custom-function feature and run arbitrary OS commands. The flaw stems from executeJavaScriptCode() merging caller-supplied nodeVMOptions over its secure defaults with a JavaScript spread, so an attacker can re-enable blocked builtins (child_process, fs) via require.builtin:["*"]. A detailed working exploit is published in the vendor's GHSA advisory, so publicly available exploit code exists; there is no CISA KEV listing, meaning no confirmed active exploitation at time of analysis.

Authenticated remote code execution in FlowiseAI Flowise (versions ≤ 3.1.2, npm packages flowise and flowise-components) arises from a vm2 JavaScript sandbox escape reachable through the AgentAsTool, ChatflowTool, and ExecuteFlow nodes, which still run untrusted code in the deprecated in-process vm2 sandbox (useSandbox: false). An attacker who can edit a chatflow injects code via an unvalidated baseURL URL-hash fragment and abuses moment's CVE-2022-24785 path-traversal (whose fix is bypassable inside the sandbox) to break out of vm2 and run arbitrary commands as the Flowise service account, fully compromising the host. A complete working exploit is published in the elttam/GitHub advisory, but the flaw is not in CISA KEV.

SQL injection in the Sequelize Node.js ORM (versions prior to 6.37.4) allows remote attackers to inject arbitrary SQL through application values that reach the string-escaping routine, but only when the ORM is configured with the Oracle dialect. The escape() function in sql-string.js returns any string beginning with TO_TIMESTAMP or TO_DATE verbatim without doubling single quotes, letting a crafted value break out of the intended literal. Publicly available exploit code exists in the GitHub Security Advisory (GHSA-v8fg-2rw7-q452); there is no CISA KEV listing and no EPSS score was provided.

Trust-boundary bypass in the ip-address npm library (all versions through 10.3.0) enables SSRF filter evasion in Node.js applications that use Address4 classification methods to block internal destinations. The library decodes leading-zero octets as decimal (e.g., '012' → 12) while system resolvers interpret the same notation as octal (e.g., '012' → 10), causing Address4.isPrivate() and related methods to return false for RFC 1918 addresses expressed in octal shorthand, while the underlying fetch connects to the private host. A functional proof-of-concept is included in the vendor advisory; no CISA KEV listing is present at time of analysis, but exploitation requires no special configuration and rides the ordinary URL-parsing code path.

SSRF classification bypass in the ip-address npm library (versions 10.1.1-10.2.1) allows network-accessible applications to be deceived into treating internal IP addresses as external. When a caller-supplied CIDR suffix such as /0 is retained during parsing, the isInSubnet() guard short-circuits before any bit comparison, causing every special-use classifier - isLoopback(), isPrivate(), isLinkLocal(), isCGNAT(), isMulticast(), and others - to return false for internal addresses, while correctForm() still resolves to the real internal target. A publicly available proof-of-concept is included in the GHSA advisory; no CISA KEV listing exists at time of analysis, so active exploitation is not confirmed.