Node.js security vulnerabilities: what the runtime fixes, what npm brings in, and how to triage both
A Node.js application takes on flaws from the runtime release it runs on, from the npm packages it installs and from its own code.
This guide shows which release lines receive security fixes, what the Node.js threat model leaves to you, and how to triage install scripts, lockfile drift, native modules and provenance changes, with a worksheet and an offline lab you can run.
In this guide
Node.js runtime and dependency triage worksheet with an offline lab
A six-section worksheet that keeps Node.js release support, package advisories, lockfile drift, install scripts, native modules and provenance changes apart, names the Node.js or npm source for each line that relies on one, and gives every finding an owner. A worked example for an invented application follows, then an offline lab whose four files and outputs were copied in from a real run.
nodejs.txt
Introduction15 lines
Part A. The worksheet69 lines
Part B. Worked example (invented application, real release data)41 lines
Part C. The offline lab399 lines
Whole template533 lines
NODE.JS RUNTIME AND DEPENDENCY TRIAGE WORKSHEET, WORKED EXAMPLE AND OFFLINE LAB
ILLUSTRATION AND TEMPLATE. Part A is a blank worksheet to copy into a ticket or a spreadsheet. Part B fills it in for an invented application, lab-invented-app, using the Node.js release schedule and the Node.js security release post of 11 November 2026 as read on 14 November 2026, and the output of the lab in Part C. The environments, people, roles and dates in Part B are invented. Part C is an offline lab that installs invented packages from local files and contacts no registry.
Every check in Part A is read-only and is run by the application's owner or their developer on systems they control. Nothing in it asks you to change a setting, install or upgrade anything, rotate or reveal a secret, or send traffic to a service you do not own. Where a source describes a step that changes your system, such as npm rebuild, the worksheet names it and leaves it for a separate, planned change. Record the names of environment variables and secrets, never their values.
HOW TO FILL IT
- Use one copy per application. Fill section 1 once for each environment the application runs in: each developer machine image, each CI or build image, and production. Environments drift apart, so one reading does not speak for another.
- Where you cannot answer a line, write "unknown". It goes on the findings log as something to find out.
- Each finding gets one line in the findings log at the end, with an owner. The owner is the person who can make the change, who may not be the person who found it.
- "Source" names the page that says where to look or what a value means. "This page's advice" marks a practice this guide recommends, not a rule from Node.js or npm.
Application:
Commit or build checked:
Completed by (name and role): Date:
PART A. THE WORKSHEET
SECTION 1. NODE.JS RELEASE SUPPORT (one block per environment)
1.1 Environment: production, a CI or build image, or a developer machine image. Name it.
1.2 Node.js version: the output of node --version run in that environment, or process.version written to the application's log at start-up.
Source: Node.js command-line documentation (-v, --version prints node's version); Node.js process documentation (process.version contains the Node.js version string).
1.3 Release line, its status and its end-of-life date, with the date you read them. Find the line on the Node.js Releases page (nodejs.org/en/about/previous-releases) and on the release schedule the Node.js Release working group keeps on GitHub (github.com/nodejs/Release). Copy the status as the page prints it, such as Active LTS, Maintenance LTS, Alpha or EOL.
Source: Node.js Releases page, which says production applications should only use Active LTS or Maintenance LTS releases; the release schedule, which says its dates are subject to change.
1.4 LTS label: the output of node -p "process.release.lts" in that environment. Write the codename it prints, or undefined.
Source: Node.js process documentation (the lts property exists only for LTS releases and is undefined for all other release types, including Current releases).
1.5 Security releases for this line since the version in 1.2: open the Node.js blog's Vulnerabilities category (nodejs.org/en/blog/vulnerability). For each security release post dated after your version was released, write the post's date and the release it lists for your line under "Downloads and release details".
Source: Node.js security reporting page and the Node.js security policy (security notifications go to the nodejs-sec Google Group and the Node.js blog).
1.6 Bundled components: when a post names a dependency update, such as llhttp, undici or sqlite in the post of 11 November 2026, run node -p "process.versions" and write down the versions of the components it names.
Source: Node.js process documentation (process.versions lists the version strings of Node.js and its dependencies).
1.7 What package.json says about Node.js: the engines.node range, any devEngines runtime entry, and whether engine-strict is set where installs run.
Source: npm package.json documentation (unless the user has set the engine-strict config flag, engines is advisory only and will only produce warnings when the package is installed as a dependency; devEngines runs before install, ci and run commands); npm config documentation (engine-strict defaults to false). Part C steps 17 and 18 show both behaviours.
1.8 Start-up flags and environment: the command that starts the application, and whether NODE_OPTIONS and NODE_TLS_REJECT_UNAUTHORIZED are set in that environment, with their values only if they hold no secret. Note any --inspect flag and the host it binds to, any flag that starts with --experimental, any --insecure-http-parser, and any --permission or --allow flag.
Source: Node.js command-line documentation (NODE_OPTIONS is interpreted before command-line options; binding the inspector to a public IP, including 0.0.0.0, with an open port is insecure; NODE_TLS_REJECT_UNAUTHORIZED set to 0 disables certificate validation for TLS connections).
Findings to log from section 1, as this page's advice: a line the schedule lists as EOL; a version earlier than the release a security post lists for its line; an Alpha release outside development; an inspector bound to anything but 127.0.0.1; NODE_TLS_REJECT_UNAUTHORIZED set to 0; an experimental flag in production; a line whose end-of-life date falls inside the application's planned life with no upgrade planned.
SECTION 2. PACKAGE ADVISORIES
2.1 The audit you are reading: the date, the command and the npm version. npm audit without the fix argument reports; with fix, its documentation says remediations are applied to the package tree. For its bulk advisory request, npm sends the name and the list of versions of each package in the tree to the default configured registry.
Source: npm audit documentation.
2.2 One line per advisory and installed copy: the advisory ID, the package, the installed version, the fixed version from the advisory's version fields, and the decision. Work each one through the dependency security guide's triage worksheet and record only the decision and a link to it here.
2.3 Advisories against Node.js itself belong in section 1. This page's reading: npm audit describes the dependencies configured in your project, and the runtime that runs them is not one of those packages.
Findings to log from section 2: each advisory whose decision is not yet made, with the developer who owns that dependency.
SECTION 3. LOCKFILE DRIFT
3.1 Is package-lock.json committed? Its lockfileVersion:
3.2 Every install command your builds and deployments run, and the file it is written in (workflow file, Dockerfile, deploy script): npm ci, npm install or other.
Source: npm ci documentation (npm ci exits with an error instead of updating the lockfile when it and package.json disagree, and never writes to either file); npm install documentation (run without arguments, npm install resolves new versions and updates the lockfile when the ranges no longer match).
3.3 The reviewed lockfile: the commit whose lockfile someone last read in full, and who read it.
3.4 Drift report: run lockfile-drift.mjs from Part C with the reviewed lockfile and the lockfile of the commit being deployed, and paste its output. It reads the two files and nothing else.
Source: npm package-lock.json documentation (a package entry records version, resolved and integrity, and can carry hasInstallScript, the engines field from the package's package.json, and os and cpu where the package specifies those restrictions).
3.5 For each FLAG line in the report, what explains it: a release note, a planned upgrade, or nothing yet.
Findings to log from section 3, as this page's advice: an install command that can rewrite the lockfile in a build; an integrity value that changed while the version did not; a new install script; any FLAG with no explanation.
SECTION 4. INSTALL SCRIPTS
4.1 Every package the lockfile flags with hasInstallScript. Part C's install-report.mjs lists them.
Source: npm package-lock.json documentation (hasInstallScript means the package has a preinstall, install or postinstall script).
4.2 For each, the script as written in that package's package.json under node_modules, and what it does, in one line.
4.3 Native build or not: does the package folder hold a binding.gyp file? install-report.mjs shows this too.
4.4 The npm version on each machine that installs, and the install-script settings in force there: ignore-scripts, any allowScripts entries in package.json, and strict-allow-scripts.
Source: npm config documentation for npm 11 and npm 12. Their defaults for dependency install scripts differ, and the supply chain attacks guide sets out how.
4.5 The secrets present where installs run: the names, never the values, of the environment variables and files an install on that machine or runner could read. Part C step 14 shows an invented variable visible to two install scripts.
Findings to log from section 4: each script nobody has read, each new script since the reviewed lockfile, and each secret an install step can read that it does not need.
SECTION 5. NATIVE MODULES
5.1 Packages with compiled code: those from 4.3; any package whose folder holds a .node file after install; and any lockfile entry restricted by os or cpu. Asking about the last group is this page's advice: a platform restriction is a reason to check for compiled code, not proof of it.
5.2 How each one gets its binary: built at install time, or shipped prebuilt in the package. npm's documentation says that when a package has a binding.gyp file and defines no install or preinstall script of its own, npm runs node-gyp rebuild as its install script.
Source: npm scripts documentation; npm rebuild documentation (the default is also suppressed by "gypfile": false).
5.3 Node-API or not: from the package's own documentation or source.
Source: Node-API documentation (Node-API is ABI stable across Node.js versions; for an addon to stay ABI-compatible across major versions, it must use Node-API exclusively and check that each external library it uses offers ABI stability similar to that of Node-API).
5.4 The ABI number in each environment: node -p "process.versions.modules". Write down every environment's value, including the machine that compiled the module.
Source: Node.js process documentation (process.versions.modules is the ABI version, and Node.js refuses to load modules compiled against a different module ABI version).
5.5 What a Node.js major upgrade would need. npm's rebuild documentation names installing a new version of Node.js, where C++ add-ons need recompiling, as a use of npm rebuild. npm rebuild runs lifecycle scripts and links bins, so plan it as part of the upgrade build. It is not part of this check.
5.6 If the application runs with --permission: is --allow-addons granted?
Source: Node.js permissions documentation (native addons are restricted under the permission model unless --allow-addons is given).
Findings to log from section 5: a native module that is not Node-API ahead of a major upgrade; an ABI number that differs between the build machine and production; a compiler or header download in a build that is meant to be offline.
SECTION 6. PROVENANCE CHANGES
6.1 The date and the result of npm audit signatures on the installed tree.
Source: npm documentation on viewing package provenance (the command checks registry signatures and provenance attestations, and returns an error if a package has missing or invalid ones).
6.2 For each package in 4.1 and 5.1, and each package that handles sign-in, payments or uploads: does the locked version show provenance on its npm package page, and did the version before it?
Source: npm documentation on viewing package provenance (a green check mark in the Version field means the package was published with provenance).
6.3 Any package that had provenance and lost it, or whose provenance names a different source repository or build file from the version before. The supply chain attacks guide explains what provenance shows and what it does not.
Findings to log from section 6: each signature error, and each lost or changed provenance record.
FINDINGS LOG
One line per finding:
ID | Section | Finding | Evidence (command output, or the page and the date read) | Owner | Decision | Review by | Closed (date and evidence)
PART B. WORKED EXAMPLE (INVENTED APPLICATION, REAL RELEASE DATA)
lab-invented-app runs in three invented environments. The versions in production and CI are invented. The developer machine is the machine Part C ran on, and its values come from Part C's output. Release statuses and dates come from the Node.js Releases page and the GitHub release schedule, read on 14 November 2026. Release numbers for each line come from the Node.js post "Wednesday, November 11, 2026 Security Releases", read the same day.
SECTION 1, PRODUCTION CONTAINER
1.2 v24.22.2 (invented).
1.3 24.x (Krypton): Maintenance LTS on the release schedule, end-of-life 2028-04-30. Read 14 November 2026.
1.4 Krypton (invented reading).
1.5 The post of 11 November 2026 lists Node.js v24.22.3 for the 24.x line. v24.22.2 is earlier.
1.6 Not read yet: unknown.
1.7 engines.node not set; engine-strict not set (invented).
1.8 Started with node server.js. NODE_OPTIONS and NODE_TLS_REJECT_UNAUTHORIZED not set. No --inspect flag (invented).
SECTION 1, CI IMAGE
1.2 v26.13.1 (invented).
1.3 26.x (Lithium): Active LTS on the release schedule, end-of-life 2029-04-30. Read 14 November 2026.
1.5 The post of 11 November 2026 lists Node.js v26.13.1 for the 26.x line, the same release as 1.2.
SECTION 1, DEVELOPER MACHINE (PART C STEPS 1 TO 4)
1.2 v26.0.0.
1.3 26.x (Lithium): Active LTS on the release schedule. The schedule gives the line's initial release as 2026-05-05 and its Active LTS start as 2026-10-28.
1.4 undefined (step 3).
1.5 The post of 11 November 2026 lists Node.js v26.13.1 for the 26.x line. v26.0.0 is earlier.
5.4 ABI number 147 (step 4).
SECTIONS 3 TO 5, A DEPENDENCY UPDATE (PART C STEPS 10 TO 18)
3.4 The drift report raised two flags (step 12). lab-invented-widget moved from 1.0.0 to 1.1.0 and the new version adds an install script. lab-invented-native is new at 2.0.0, has an install script, and brings an engines range of >=24.0.0 and a cpu list of arm64 and x64.
4.1 Both packages are flagged hasInstallScript (step 11).
4.2 lab-invented-widget runs node mark-install.js at postinstall; lab-invented-native runs the same file at install. Each writes a marker file into its own folder.
4.3 lab-invented-native holds a binding.gyp; lab-invented-widget does not.
4.4 npm 11.12.1 (step 2). With no install-script settings, npm ci ran both scripts (step 13, with the report at step 14). With --ignore-scripts, neither ran (the reports at steps 11 and 16).
4.5 The invented variable LAB_INVENTED_TOKEN, set on the npm ci command line, was visible to both scripts (step 14).
5.1 lab-invented-native: binding.gyp present, no .node file after install, cpu restricted to arm64 and x64.
5.4 Developer machine 147 (step 4). Production: unknown.
1.7 Engines, from steps 17 and 18: npm warned about lab-invented-future's engines range and installed it anyway; with --engine-strict it refused with EBADENGINE.
FINDINGS LOG (INVENTED OWNERS AND DATES)
F1 | 1 | Production runs v24.22.2, earlier than Node.js v24.22.3, which the 11 November 2026 post lists for 24.x. | node --version in the container; post read 14 November 2026. | Hosting lead | Rebuild the image on a 24.x release no earlier than the one that post lists, as a planned change. | 2026-11-21 | Open
F2 | 1 | Developer machine runs v26.0.0, earlier than Node.js v26.13.1, which the same post lists for 26.x; process.release.lts prints undefined. | Part C steps 1 and 3. | Lead developer | Update the machine image. | 2026-11-21 | Open
F3 | 3 | Two drift flags: an install script added in lab-invented-widget 1.1.0, and a new package with an install script. | Part C step 12. | Lead developer | Hold the update until 4.2 and 5.2 are complete. | 2026-11-18 | Open
F4 | 4 | Both install scripts ran under npm ci and could read a variable set for the install. | Part C step 14. | Build owner | List the secrets the CI install step can read; propose an install-script policy as a separate change. | 2026-11-25 | Open
F5 | 5 | lab-invented-native ships a binding.gyp, its Node-API status is unknown, and production's ABI number is unknown. | Part C steps 4 and 11. | Lead developer | Read the package's documentation; read process.versions.modules in the production container. | 2026-11-25 | Open
F6 | 6 | npm audit signatures has not been run for this application. | Not run: the lab's packages are invented and come from no registry. | Lead developer | Run it on the next build and record the result. | 2026-11-25 | Open
PART C. THE OFFLINE LAB
WHAT IT IS
An illustration. Four versions of three invented packages are packed into tarballs on your own machine and installed into an invented app from those local files. One package gains an install script in a new version, one stands in for a native module, and one asks for a Node.js version that does not exist. The lab shows an install script running and not running, a drift report between two lockfiles that npm itself wrote, and what npm does with the engines field. Every package name is invented, and no step contacts a registry.
WHAT IT NEEDS
Node.js and npm, with nothing to download. The four scripts import only node:fs and node:path. The outputs below were recorded on Node.js v26.0.0 and npm 11.12.1 on macOS (arm64), the versions installed on the machine that ran it. They are facts about this run, not a recommendation. npm documents different defaults for dependency install scripts in npm 11 and npm 12, so steps 13 and 14 can print a different result on another npm version.
WHAT IT TOUCHES
make-lab.mjs replaces the packages, tarballs and app folders next to it on every run, and writes two empty npm configuration files. Every npm command from step 6 on ran with offline=true (from app/.npmrc, or --offline for npm pack), with the two empty files as its user and global configuration, and with a cache folder inside the lab, so no setting from the machine's user or global npm configuration applied to them. Step 2 only prints npm's version. The invented install scripts write one file, install-marker.txt, inside their own package folder, and record whether a variable named LAB_INVENTED_TOKEN was visible to them, never its value. The binding.gyp in lab-invented-native is never compiled: npm's documentation says the node-gyp default applies only when a package defines no install or preinstall script, and this package defines its own.
HOW THE OUTPUT WAS CAPTURED
The steps below were run in order by a small shell script that saved each command, its output and its exit code to a file, and the text below was copied from those files by a second script. Lines that showed a local folder path were cut, as were npm pack's notice lines, and each cut is marked where it was made. The two scripts are not part of the lab. The times npm prints at the end of each install differ from run to run.
SET-UP
Make an empty folder, save the four files below into it under the names shown, then run the steps under RUN IT. Steps 1 to 6 run in that folder and steps 7 to 18 in the app folder that step 5 creates. Steps 8, 13 and 15 use the syntax of macOS and Linux shells; on Windows, copy the file and set the variable the way your shell does.
==== File 1 of 4: make-lab.mjs ====
// make-lab.mjs: writes the invented packages and the invented app this lab
// installs. Every name here is invented. Nothing is downloaded: the app depends
// on local tarballs that npm pack builds from the folders written below.
import fs from 'node:fs'
import path from 'node:path'
function writeText(relativePath, text) {
fs.mkdirSync(path.dirname(relativePath), { recursive: true })
fs.writeFileSync(relativePath, text)
}
function writeJson(relativePath, value) {
writeText(relativePath, JSON.stringify(value, null, 2) + '\n')
}
// The install-time script both invented packages share. It writes one file
// inside its own package folder and records whether an invented variable was
// visible to it, never the value.
const MARK_INSTALL = [
'// INVENTED FOR THIS PAGE. A stand-in for an install script.',
"const fs = require('node:fs')",
'const lines = [',
" 'package: ' + process.env.npm_package_name + ' ' + process.env.npm_package_version,",
" 'lifecycle event: ' + process.env.npm_lifecycle_event,",
" 'node version running the script: ' + process.version,",
" 'LAB_INVENTED_TOKEN visible to the script: ' + (process.env.LAB_INVENTED_TOKEN ? 'yes' : 'no'),",
']',
"fs.writeFileSync('install-marker.txt', lines.join('\\n') + '\\n')",
'',
].join('\n')
const INDEX = "module.exports = function hello() { return 'hello from an invented package' }\n"
function writeWidget(version, withScript) {
const folder = 'packages/lab-invented-widget-' + version
const manifest = { name: 'lab-invented-widget', version: version, main: 'index.js', license: 'UNLICENSED' }
if (withScript) manifest.scripts = { postinstall: 'node mark-install.js' }
writeJson(folder + '/package.json', manifest)
writeText(folder + '/index.js', INDEX)
if (withScript) writeText(folder + '/mark-install.js', MARK_INSTALL)
}
// A stand-in for a package with compiled code. It ships a binding.gyp but
// defines its own install script, so npm does not run node-gyp for it, and
// nothing is ever compiled.
function writeNative() {
const folder = 'packages/lab-invented-native-2.0.0'
writeJson(folder + '/package.json', {
name: 'lab-invented-native',
version: '2.0.0',
main: 'index.js',
license: 'UNLICENSED',
engines: { node: '>=24.0.0' },
cpu: ['arm64', 'x64'],
scripts: { install: 'node mark-install.js' },
})
writeJson(folder + '/binding.gyp', { targets: [{ target_name: 'lab_invented_native', sources: ['src/never-built.c'] }] })
writeText(folder + '/index.js', INDEX)
writeText(folder + '/mark-install.js', MARK_INSTALL)
}
// A package that says it needs a Node.js major version that does not exist,
// to show what npm does with the engines field.
function writeFuture() {
const folder = 'packages/lab-invented-future-1.0.0'
writeJson(folder + '/package.json', {
name: 'lab-invented-future',
version: '1.0.0',
main: 'index.js',
license: 'UNLICENSED',
engines: { node: '>=99.0.0' },
})
writeText(folder + '/index.js', INDEX)
}
fs.rmSync('packages', { recursive: true, force: true })
fs.rmSync('tarballs', { recursive: true, force: true })
fs.rmSync('app', { recursive: true, force: true })
writeWidget('1.0.0', false)
writeWidget('1.1.0', true)
writeNative()
writeFuture()
fs.mkdirSync('tarballs')
writeText('empty-user-npmrc', '')
writeText('empty-global-npmrc', '')
writeText('app/.npmrc', 'offline=true\naudit=false\nfund=false\nupdate-notifier=false\n')
writeJson('app/package.json', {
name: 'lab-invented-app',
version: '1.0.0',
private: true,
dependencies: { 'lab-invented-widget': 'file:../tarballs/lab-invented-widget-1.0.0.tgz' },
})
console.log('written: ' + ['packages', 'tarballs', 'app', 'empty-user-npmrc', 'empty-global-npmrc'].join(', '))
==== File 2 of 4: set-dependencies.mjs ====
// set-dependencies.mjs: moves the invented app from its reviewed dependency set
// to the candidate set a dependency update would bring. Run from the app folder.
import fs from 'node:fs'
const SETS = {
reviewed: {
'lab-invented-widget': 'file:../tarballs/lab-invented-widget-1.0.0.tgz',
},
candidate: {
'lab-invented-widget': 'file:../tarballs/lab-invented-widget-1.1.0.tgz',
'lab-invented-native': 'file:../tarballs/lab-invented-native-2.0.0.tgz',
},
}
const setName = process.argv[2]
if (!SETS[setName]) {
console.error('usage: node set-dependencies.mjs reviewed|candidate')
process.exit(1)
}
const manifest = JSON.parse(fs.readFileSync('package.json', 'utf8'))
manifest.dependencies = SETS[setName]
fs.writeFileSync('package.json', JSON.stringify(manifest, null, 2) + '\n')
console.log('dependencies set to the ' + setName + ' set: ' + Object.keys(SETS[setName]).join(', '))
==== File 3 of 4: install-report.mjs ====
// install-report.mjs: reads package-lock.json and the installed node_modules
// folder, and reports, for each installed package, whether the lockfile flags an
// install script, whether a native build file or compiled .node file is
// present, and whether an install script left a marker. It reads files only.
// Run from the app folder.
import fs from 'node:fs'
import path from 'node:path'
function listCompiledFiles(folder) {
const found = []
const entries = fs.readdirSync(folder, { withFileTypes: true })
for (const entry of entries) {
if (entry.name === 'node_modules') continue
const fullPath = path.join(folder, entry.name)
if (entry.isDirectory()) {
for (const nested of listCompiledFiles(fullPath)) found.push(nested)
} else if (entry.name.endsWith('.node')) {
found.push(path.relative(folder, fullPath))
}
}
return found
}
function describePackage(location, entry) {
const lines = [location + ' ' + entry.version]
lines.push(' lockfile hasInstallScript: ' + (entry.hasInstallScript ? 'yes' : 'no'))
if (!fs.existsSync(location)) {
lines.push(' installed folder: missing')
return lines
}
lines.push(' binding.gyp present: ' + (fs.existsSync(path.join(location, 'binding.gyp')) ? 'yes' : 'no'))
const compiled = listCompiledFiles(location)
lines.push(' compiled .node files: ' + (compiled.length ? compiled.join(', ') : 'none'))
const markerPath = path.join(location, 'install-marker.txt')
if (!fs.existsSync(markerPath)) {
lines.push(' install-marker.txt: absent')
return lines
}
lines.push(' install-marker.txt: present')
for (const markerLine of fs.readFileSync(markerPath, 'utf8').trim().split('\n')) {
lines.push(' ' + markerLine)
}
return lines
}
const lockfile = JSON.parse(fs.readFileSync('package-lock.json', 'utf8'))
console.log('node ' + process.version + ', lockfileVersion ' + lockfile.lockfileVersion)
for (const location of Object.keys(lockfile.packages)) {
if (location === '') continue
for (const line of describePackage(location, lockfile.packages[location])) console.log(line)
}
==== File 4 of 4: lockfile-drift.mjs ====
// lockfile-drift.mjs: compares a reviewed package-lock.json with a candidate
// one and lists the changes the triage worksheet asks about. It reads both
// files as JSON and contacts nothing. It exits with code 1 when it raises a
// flag, so a build step can stop for a person to look.
// node lockfile-drift.mjs reviewed-lock.json candidate-lock.json
import fs from 'node:fs'
function readPackages(filePath) {
const lockfile = JSON.parse(fs.readFileSync(filePath, 'utf8'))
return lockfile.packages || {}
}
function show(value) {
if (value === undefined) return '(none)'
return JSON.stringify(value)
}
function compareEntry(location, before, after) {
const notes = []
const flags = []
if (!before) {
notes.push('added at ' + after.version)
if (after.hasInstallScript) flags.push('new package with an install script')
} else if (!after) {
notes.push('removed (was ' + before.version + ')')
return { notes: notes, flags: flags }
} else {
if (before.version !== after.version) notes.push('version ' + before.version + ' -> ' + after.version)
if (before.integrity !== after.integrity && before.version === after.version) {
flags.push('integrity changed but the version did not')
}
if (before.resolved !== after.resolved) notes.push('resolved address changed')
if (!before.hasInstallScript && after.hasInstallScript) flags.push('install script added in this version')
}
const fields = ['engines', 'os', 'cpu']
for (const field of fields) {
const was = before ? before[field] : undefined
if (show(was) !== show(after[field])) notes.push(field + ' ' + show(was) + ' -> ' + show(after[field]))
}
return { notes: notes, flags: flags }
}
const reviewed = readPackages(process.argv[2])
const candidate = readPackages(process.argv[3])
const locations = Array.from(new Set(Object.keys(reviewed).concat(Object.keys(candidate)))).sort()
let flagCount = 0
for (const location of locations) {
if (location === '') continue
const result = compareEntry(location, reviewed[location], candidate[location])
if (result.notes.length === 0 && result.flags.length === 0) continue
console.log(location)
for (const note of result.notes) console.log(' change: ' + note)
for (const flag of result.flags) console.log(' FLAG: ' + flag)
flagCount += result.flags.length
}
console.log(flagCount + ' flag(s) raised')
if (flagCount > 0) process.exitCode = 1
RUN IT, WITH WHAT EACH STEP PRINTED
STEP 1 (in the lab folder): node --version
v26.0.0
(exit code 0)
STEP 2 (in the lab folder): npm --version
11.12.1
(exit code 0)
STEP 3 (in the lab folder): node -p "process.release.lts"
undefined
(exit code 0)
STEP 4 (in the lab folder): node -p "process.versions.modules"
147
(exit code 0)
STEP 5 (in the lab folder): node make-lab.mjs
written: packages, tarballs, app, empty-user-npmrc, empty-global-npmrc
(exit code 0)
STEP 6 (in the lab folder): npm pack ./packages/lab-invented-widget-1.0.0 ./packages/lab-invented-widget-1.1.0 ./packages/lab-invented-native-2.0.0 ./packages/lab-invented-future-1.0.0 --pack-destination tarballs --offline --userconfig empty-user-npmrc --globalconfig empty-global-npmrc --cache npm-cache
(15 npm notice lines cut here)
lab-invented-widget-1.0.0.tgz
(11 npm notice lines cut here)
lab-invented-widget-1.1.0.tgz
(13 npm notice lines cut here)
lab-invented-native-2.0.0.tgz
(9 npm notice lines cut here)
lab-invented-future-1.0.0.tgz
(exit code 0)
STEP 7 (in app): npm install --userconfig ../empty-user-npmrc --globalconfig ../empty-global-npmrc --cache ../npm-cache
added 1 package in 148ms
(exit code 0)
STEP 8 (in app): cp package-lock.json ../reviewed-lock.json
(exit code 0)
STEP 9 (in app): node ../set-dependencies.mjs candidate
dependencies set to the candidate set: lab-invented-widget, lab-invented-native
(exit code 0)
STEP 10 (in app): npm install --ignore-scripts --userconfig ../empty-user-npmrc --globalconfig ../empty-global-npmrc --cache ../npm-cache
added 1 package, and changed 1 package in 178ms
(exit code 0)
STEP 11 (in app): node ../install-report.mjs
node v26.0.0, lockfileVersion 3
node_modules/lab-invented-native 2.0.0
lockfile hasInstallScript: yes
binding.gyp present: yes
compiled .node files: none
install-marker.txt: absent
node_modules/lab-invented-widget 1.1.0
lockfile hasInstallScript: yes
binding.gyp present: no
compiled .node files: none
install-marker.txt: absent
(exit code 0)
STEP 12 (in app): node ../lockfile-drift.mjs ../reviewed-lock.json package-lock.json
node_modules/lab-invented-native
change: added at 2.0.0
change: engines (none) -> {"node":">=24.0.0"}
change: cpu (none) -> ["arm64","x64"]
FLAG: new package with an install script
node_modules/lab-invented-widget
change: version 1.0.0 -> 1.1.0
change: resolved address changed
FLAG: install script added in this version
2 flag(s) raised
(exit code 1)
STEP 13 (in app): LAB_INVENTED_TOKEN=invented-not-a-secret npm ci --userconfig ../empty-user-npmrc --globalconfig ../empty-global-npmrc --cache ../npm-cache
added 2 packages in 316ms
(exit code 0)
STEP 14 (in app): node ../install-report.mjs
node v26.0.0, lockfileVersion 3
node_modules/lab-invented-native 2.0.0
lockfile hasInstallScript: yes
binding.gyp present: yes
compiled .node files: none
install-marker.txt: present
package: lab-invented-native 2.0.0
lifecycle event: install
node version running the script: v26.0.0
LAB_INVENTED_TOKEN visible to the script: yes
node_modules/lab-invented-widget 1.1.0
lockfile hasInstallScript: yes
binding.gyp present: no
compiled .node files: none
install-marker.txt: present
package: lab-invented-widget 1.1.0
lifecycle event: postinstall
node version running the script: v26.0.0
LAB_INVENTED_TOKEN visible to the script: yes
(exit code 0)
STEP 15 (in app): LAB_INVENTED_TOKEN=invented-not-a-secret npm ci --ignore-scripts --userconfig ../empty-user-npmrc --globalconfig ../empty-global-npmrc --cache ../npm-cache
added 2 packages in 156ms
(exit code 0)
STEP 16 (in app): node ../install-report.mjs
node v26.0.0, lockfileVersion 3
node_modules/lab-invented-native 2.0.0
lockfile hasInstallScript: yes
binding.gyp present: yes
compiled .node files: none
install-marker.txt: absent
node_modules/lab-invented-widget 1.1.0
lockfile hasInstallScript: yes
binding.gyp present: no
compiled .node files: none
install-marker.txt: absent
(exit code 0)
STEP 17 (in app): npm install ../tarballs/lab-invented-future-1.0.0.tgz --no-save --ignore-scripts --userconfig ../empty-user-npmrc --globalconfig ../empty-global-npmrc --cache ../npm-cache
npm warn EBADENGINE Unsupported engine {
npm warn EBADENGINE package: 'lab-invented-future@1.0.0',
npm warn EBADENGINE required: { node: '>=99.0.0' },
npm warn EBADENGINE current: { node: 'v26.0.0', npm: '11.12.1' }
npm warn EBADENGINE }
added 1 package in 160ms
(exit code 0)
STEP 18 (in app): npm install ../tarballs/lab-invented-future-1.0.0.tgz --no-save --ignore-scripts --engine-strict --userconfig ../empty-user-npmrc --globalconfig ../empty-global-npmrc --cache ../npm-cache
npm error code EBADENGINE
npm error engine Unsupported engine
npm error engine Not compatible with your version of node/npm: lab-invented-future@1.0.0
npm error notsup Not compatible with your version of node/npm: lab-invented-future@1.0.0
npm error notsup Required: {"node":">=99.0.0"}
npm error notsup Actual: {"node":"v26.0.0","npm":"11.12.1"}
(one line showing a local path cut here)
(exit code 1)
WHAT THE LAB SHOWED
- With --ignore-scripts, neither install script ran (the reports at steps 11 and 16).
- npm ci on npm 11.12.1, with no install-script settings, ran both scripts, and both could see a variable set on the npm command line (steps 13 and 14).
- npm ci removed the earlier node_modules folder: after step 15 no marker from step 13 was left.
- lockfile-drift.mjs read two lockfiles npm wrote and raised two flags: an install script added in a new version, and a new package with one (step 12). It exited with code 1, so a build step that runs it stops for a person to look, which is this page's advice for using it.
- npm warned about an engines range the running Node.js did not meet and installed the package anyway; with --engine-strict it refused (steps 17 and 18).
WHAT THE LAB DOES NOT SHOW
- npm 12. Its documentation says dependency install scripts are blocked by default unless allowScripts covers them. The lab ran on npm 11.12.1 only.
- A real compile. Nothing is built, so node-gyp, compiler toolchains and header downloads are not exercised.
- Anything from a registry. npm audit, npm audit signatures and provenance need registry data that invented local packages do not have.
- Every form of compiled code. install-report.mjs looks for binding.gyp and .node files inside each package folder. It would not see a binary that an install script fetches or writes somewhere else.
- What a package does when it is imported. Skipping install scripts does not stop a package's own code running when your application loads it.Node.js security vulnerabilities: the runtime, or the code it runs
Node.js is the runtime under a JavaScript server application.
It parses the requests your server receives, runs your code and the framework it is built on, and loads the npm packages your code imports. A Node.js security vulnerability can mean two different things: a flaw in the runtime itself, which the Node.js project fixes in a security release, or a flaw in your own code or in a package you installed, which upgrading Node.js does not touch.
The project's security policy draws the line between the two in its threat model, and it is worth knowing where the line falls before reading any advisory.
The threat model lists what Node.js does not trust. First on the list is data from the remote end of inbound network connections that are accepted through Node.js APIs and transformed or validated by Node.js before being passed to your application, which includes the HTTP server APIs.
The policy says that if data passing through Node.js to or from the application can trigger actions other than those documented for the APIs, there is likely a security vulnerability. On the other side, Node.js trusts the code it is asked to run: JavaScript, WASM and native code, including every dependency installed from the npm registry, and that code inherits all the privileges of the user running it. It also treats the operating system and the file system it can reach as trusted.
The policy spells out what follows. A scenario that needs a malicious third-party module cannot be a Node.js vulnerability. Prototype pollution that depends on control over user input is not one either, because Node.js trusts the inputs application code gives it. Exposing child_process.exec() to untrusted users without input validation, and letting untrusted users control file paths passed to file system APIs without validation, are listed as application-level issues, and a crash caused by a missing 'error' handler is not a denial-of-service vulnerability in Node.js.
This page's reading of that list: upgrading Node.js closes the runtime flaws the new release fixes, and nothing else. The rest sits with the application's owner, in six places the worksheet on this page keeps apart: the release line you run, advisories against your packages, lockfile drift, install scripts, native modules and provenance changes.
Command injection through child processes and path traversal through file APIs each have their own guide, and the Express guide covers middleware order in Express applications.
Which Node.js release lines receive security fixes
Node.js ships in release lines, one per major version.
The Node.js Releases page says a major version spends six months with Current status, which gives library authors time to add support for it. Up to Node.js 26, odd-numbered releases became unsupported after six months and even-numbered ones moved to Active LTS. From Node.js 27 the cycle is annual, and every major version moves to LTS after six months as Alpha and six as Current.
The page describes LTS as long-term support under which critical bugs are typically fixed for a total of 30 months, and it says production applications should only use Active LTS or Maintenance LTS releases.
Statuses move on a schedule, so read them on the day you check. On 14 November 2026, the release schedule the Node.js Release working group keeps on GitHub listed 26.x as Active LTS, 24.x and 22.x as Maintenance LTS, and 27.x in its Alpha phase.
It gave end-of-life dates of 30 April 2029 for 26.x, 30 April 2028 for 24.x and 30 April 2027 for 22.x, and listed 20.x and 25.x as already end-of-life, from 30 April 2026 and 1 June 2026. The schedule notes that its dates are subject to change.
It describes the Maintenance phase, which applies to lines up to Node.js 26, as critical bug fixes and security updates, and says Alpha releases are intended for library authors and CI pipelines, not for production use.
For security, end-of-life is the status to watch. The Node.js end-of-life page says a version that reaches it no longer receives updates, including security patches, and that when a security release fixes a flaw in newer lines, there will be no new release for an end-of-life line even if the same flaw affects it.
The security release post of 11 November 2026 says end-of-life versions are always affected when a security release occurs. This page's advice is to log an end-of-life line in production as a finding in its own right, whether or not an advisory names it.
Two quick reads show where an environment stands. node --version prints the version it runs. node -p "process.release.lts" prints the line's codename on an LTS release, and the Node.js process documentation says the property is undefined for every other release type, including Current releases. In the lab on this page it printed undefined on Node.js v26.0.0, although the schedule gives the 26.x line an Active LTS start of 28 October 2026; the process documentation describes the property as the LTS label for the release itself. package.json can also declare a Node.js range in its engines field. npm's documentation says that, unless the engine-strict config flag is set, the field is advisory only and will only produce warnings when the package is installed as a dependency.
The lab shows npm warning about a range the running Node.js did not meet, installing the package anyway, and refusing it once engine-strict was on.
How Node.js announces a security release, and how to read one
The Node.js security reporting page sets out the disclosure process.
A reported problem is validated against all supported Node.js versions, and fixes are prepared for all supported releases. On the embargo date the announcement goes to the Node.js security mailing list, new builds are deployed to nodejs.org, and a copy of the advisory is published on the Node.js blog within six hours of the mailing list being notified.
The project's security policy names two places to watch: the nodejs-sec Google Group and the Vulnerabilities category of the Node.js blog. It also notes a built-in delay between a security release and the public disclosure of its CVEs.
This page's reading is that a CVE database can trail the release that fixes a flaw, so read the blog post rather than wait for the CVE record.
Take the post of 11 November 2026, read on 14 November 2026, as a worked example. It announced updates for the 26.x, 24.x and 22.x lines and lists Node.js v26.13.1, v24.22.3 and v22.23.5 under its downloads and release details. It also lists dependency updates: llhttp on all three lines, undici on 24.x and 26.x, and sqlite on 22.x and 24.x.
The highest severity it gives for each line is HIGH. It lists no release for 20.x or 25.x, which the schedule already showed as end-of-life.
Three of its entries show how much the detail matters. CVE-2026-123864, rated high, is a flaw in Node.js HTTPS that lets an unauthenticated client read memory belonging to other connections, including TLS private keys and other users' requests. The post says triggering it requires a handler that calls res.flushHeaders() before the request body ends and later calls res.end() with a non-empty chunk, that reading the leaked memory requires any ordinary route that echoes or stores a request body, and that cleartext node:http is not affected.
CVE-2026-123871, rated medium, is Node.js disclosing proxy credentials in ERR_PROXY_INVALID_CONFIG error messages, which the post notes reach a much wider audience than the process environment, such as stderr, container logs, log aggregation and crash reporting services.
CVE-2026-106071, rated low, lets a wildcard --allow-fs-read or --allow-fs-write rule in the permission model match paths it should not, where the wildcard grant sits directly under the root of the permission tree. The post lists all three as affecting 22.x, 24.x and 26.x.
The conditions in an entry help you judge urgency and decide where to look for signs of earlier exposure, which is this page's advice. The fix the post offers is the new release. Record the release each post lists for your line in section 1 of the worksheet, and compare it with what each environment runs.
This account is as of 14 November 2026. Newer posts appear in the Vulnerabilities category of the Node.js blog and on the nodejs-sec mailing list.
When a post names a dependency update, node -p "process.versions" lists the versions of Node.js and its dependencies in the environment you run it in.
Start-up flags and environment variables that change the runtime's exposure
An exposed inspector can let someone run code inside your process.
The Node.js command-line documentation gives --inspect a default of 127.0.0.1:9229 and warns that binding it to a public IP, including 0.0.0.0, with an open port is insecure, because it allows external hosts to connect and perform a remote code execution attack.
The debugging guide adds that even on 127.0.0.1, any application running locally has unrestricted access, by design. The security best practices page lists not running the inspector protocol in production among its mitigations for DNS rebinding.
Flags do not always appear in the start command. The command-line documentation describes NODE_OPTIONS as a space-separated list of options that are interpreted before the command-line options. This page's advice follows from that: read NODE_OPTIONS in each environment as well as the start command.
The same documentation says that setting NODE_TLS_REJECT_UNAUTHORIZED to 0 disables certificate validation for TLS connections, and it strongly discourages using the variable. The HTTP request smuggling guide covers --insecure-http-parser.
Experimental flags carry a different promise. The security best practices page says using experimental features in production isn't recommended, because they can suffer breaking changes and their functionality isn't securely stable. The security policy adds that a flaw affecting only an experimental feature at stability 1.0 or 1.1, gated behind an --experimental- runtime flag, will not be accepted as a valid security issue unless it can be exploited in a way that affects the security of a stable feature when the flag is not enabled.
One hardening flag the best practices page suggests sits in this group: --frozen-intrinsics, against monkey patching, which the command-line documentation marks Stability 1, Experimental.
The permission model is the runtime's own restriction feature, and its documentation marks it Stable from Node.js 23.5.0 and 22.13.0. Started with --permission, a process is restricted in its access to the file system through the fs module, the network, child processes, worker threads and native addons, among other things, until each is granted back with an --allow flag.
The documentation calls it a seat belt that prevents trusted code from unintentionally using resources it was not granted, and says it does not protect against malicious code.
The security policy says it is designed to reduce the blast radius of mistakes in trusted application code, not to act as a security boundary against intentional misuse. Two fixes in the November 2026 post, CVE-2026-106071 and CVE-2026-123829, were in the permission model itself, so this page treats it like the rest of the runtime: it is only as current as the release you run. The remote code execution guide shows the model at work in a lab.
Where npm brings risk into a Node.js application
The threat model gives every package npm installs the same trust as your own code.
Four parts of the npm workflow decide what reaches the application and what runs on the machines that install it, and each has its own section in the worksheet.
Package advisories
npm audit submits a description of the project's dependencies to the default registry and asks for a report of known vulnerabilities; given the fix argument, it also applies remediations to the package tree. The dependency security guide covers reading each advisory against your own code and deciding what to update first, and the SBOM guide covers recording what each release contains.
Lockfile drift
Run without arguments, npm install keeps the lockfile's versions while they satisfy the ranges in package.json, and when they do not, it resolves new versions and updates the lockfile. npm ci exits with an error instead of updating the lockfile when the two disagree, and never writes to either file.
A lockfile entry records the version, the address it was resolved from and an integrity value. It can also carry a hasInstallScript flag, the engines field from the package's own package.json, and os and cpu fields where the package specifies those restrictions.
The lab's drift report compares those fields between a lockfile someone reviewed and the one about to be deployed.
Install scripts
A package can declare preinstall, install and postinstall scripts, and the lockfile flags such a package with hasInstallScript. Among the best practices in npm's scripts documentation, compilation which must be done on the target architecture is named as the only valid use of install or preinstall scripts. Whether npm runs a dependency's script by default depends on the npm version, which the supply chain attacks guide sets out.
The lab ran on npm 11.12.1: npm ci ran both invented install scripts, each could read a variable set on the npm command line, and with --ignore-scripts neither ran.
Provenance changes
npm provenance publicly provides a link to a package's source code and build instructions from the build environment, and npm audit signatures checks registry signatures and provenance attestations, returning an error if a package has missing or invalid signatures or attestations.
The supply chain attacks guide explains what provenance proves and what it does not, so the worksheet only records when it changes. The CI/CD security guide covers hardening the runner that performs the install.
Native modules: compiled code tied to a Node.js version
A native module, or addon, is compiled code that Node.js loads like any other module; the addons documentation calls addons dynamically-linked shared objects that can be loaded through require().
When npm installs one, it uses its own bundled copy of node-gyp to compile it for the user's platform on demand, and node-gyp detects the Node.js release and downloads either the full source tarball or just the headers. npm's documentation adds that a package with a binding.gyp file and no install or preinstall script of its own gets node-gyp rebuild as its install script by default.
This page's reading is that a native module is an install script by another route, with a compiler run and a header download on whatever machine installs it.
Compiled code is tied to the runtime that loads it. The process documentation says process.versions.modules gives the ABI version, which increases whenever a C++ API changes, and that Node.js refuses to load modules compiled against a different module ABI version. Node-API, marked Stable, is meant to remove that tie.
Its documentation says it is ABI stable across Node.js versions, intended to let a module compiled for one major version run on later ones without recompilation, and that an addon stays ABI-compatible across major versions only if it uses Node-API exclusively and checks that its external libraries offer similar ABI stability. npm's rebuild documentation names installing a new version of Node.js, where C++ add-ons need recompiling, as one use of npm rebuild.
So the upgrade that keeps an application on a supported line is also a change that can stop a native module loading. This page's advice is to list native modules before the upgrade: which packages carry compiled code, whether each uses Node-API, and the ABI number on the machine that builds and on the machine that runs.
The lab's install report checks each installed package for a binding.gyp and for .node files.
Under the permission model, native addons are restricted unless --allow-addons is given, and the threat model trusts native code it is asked to run just as it trusts JavaScript.
Node.js security best practices the project itself lists
The Node.js project keeps a security best practices page whose threat list mixes runtime and application concerns.
It says some of those topics are not vulnerabilities in Node.js core under the threat model, but are still application-level threats to account for when building and operating Node.js software. The list includes denial of service against the HTTP server, DNS rebinding through the inspector, timing attacks, malicious third-party modules, monkey patching, prototype pollution and uncontrolled search paths.
Four of its points follow, each with some of the mitigations it lists, and one of this page's own at the end.
- HTTP server denial of service: put a reverse proxy in front, configure the server timeouts (the page names headersTimeout, requestTimeout, timeout and keepAliveTimeout), and limit the number of open sockets per host and in total.
- Timing attacks: compare secrets with timingSafeEqual, which the page describes as the crypto API's constant-time comparison for actual and expected sensitive values.
- Prototype pollution: create objects without a prototype using Object.create(null), check that a property is the object's own with Object.hasOwn(), and consider the --disable-proto flag, which the command-line documentation says removes Object.prototype.__proto__ or makes accessing it throw, depending on the mode given.
- Uncontrolled search paths: the page says Node.js assumes the directory in which a module is requested is trusted. This page's reading is that write access to an application's folders amounts to write access to its code.
- Secrets in errors and logs: the proxy-credential fix in the November 2026 post is one example of a secret reaching logs, and the secrets exposure guide covers finding and rotating exposed keys.
How to use the runtime and dependency triage worksheet
The worksheet keeps the six kinds of finding apart because different people fix them.
A Node.js upgrade is a change to a server or container image. A package advisory is a dependency update in the code. An install script or a provenance change is a decision about trust for whoever approves dependencies, and a native module ties the runtime and the packages together.
Every finding goes on one log with an owner, the person who can make the change, so nothing waits on the wrong desk.
- Fill section 1 for every environment the application runs in: production, each CI or build image, and the images developers use. Read each release status from the Node.js pages on the day you fill it in, and write that date beside it.
- Fill sections 2 to 6 once for each commit you review, from that commit's lockfile and installed tree.
- Use the lab's install-report.mjs and lockfile-drift.mjs on your own project if they help. Both read files and change nothing, and they are illustrations rather than maintained tools.
- Every check reads and records. Where a fix needs a change, such as an upgrade or npm rebuild, log it as a decision and make it as its own planned change.
- Record secrets by name and location only. A value never goes into the worksheet.
- Revisit section 1 when the Node.js blog posts a security release, and sections 3 to 6 whenever the lockfile changes.
The offline lab: install scripts, lockfile drift and engines in practice
The asset ends with a lab you can run on your own machine.
It packs four versions of three invented packages into local tarballs and installs them into an invented app, with npm set to offline, empty user and global configuration files and a cache inside the lab, so no step contacts a registry.
It ran on Node.js v26.0.0 and npm 11.12.1 on macOS. Those are the versions on the machine that ran it, not a recommendation, and every result below is an illustration from that run.
- Moving the app to a new dependency set raised two flags in the drift report: a new version that added a postinstall script, and a new package, standing in for a native module, with an install script, a binding.gyp, an engines range and a cpu restriction.
- npm ci ran both install scripts, and each could read a variable set on the npm command line. With --ignore-scripts, neither ran.
- npm warned about a package whose engines range the running Node.js did not meet and installed it anyway. With --engine-strict it refused with EBADENGINE.
- On Node.js v26.0.0, process.release.lts printed undefined and process.versions.modules printed 147.
- Left out: npm 12, whose documentation says dependency install scripts are blocked by default; any real compile; and anything that needs registry data, such as npm audit, npm audit signatures and provenance.
What a review of your own setup cannot show
A completed worksheet records versions, settings and decisions on the day it was filled in.
It shows whether you run a release that fixes a runtime flaw, not whether that flaw is reachable through your traffic. It does not show what a package does once your application imports it: skipping install scripts leaves that code in place, and the threat model trusts it. It cannot read compiled code, and it says nothing about security releases published after the date at the top.
Nor can it tell you whether your own routes check who is asking. Authorisation, input handling and the way the application uses Node.js APIs are application-level questions in the threat model's own terms. Answering them takes reading the code and exercising the running application as its users would, which version numbers cannot do.
Where a Clever Ops review fits
This guide is an informational hardening resource, and nothing on it is a test of Node.js or npm themselves.
Clever Ops does not provide round-the-clock monitoring, so the worksheet and the lab are for your own team to keep and rerun.
Active testing of your own Node.js application sits within a scoped web application penetration test, a signed-in test in which the tester uses test accounts for each role the scope names and works through both the application and its API. In a secure code review, the lockfile is read against the package manifest, new packages and versions are checked against published advisories, and package scripts, CI workflow files and anything else that runs on its own at install, build or deploy time are read too. Each report covers the build that was reviewed, on the dates it was reviewed.
Where Clever Ops built or hosts the application, the report calls the work a security review, not an independent penetration test, and states who built and who hosts it.
Frequently asked questions
Read the status on the Node.js Releases page and the release schedule on GitHub on the day you check. On 14 November 2026 the schedule listed 26.x as Active LTS, 24.x and 22.x as Maintenance LTS and 27.x as Alpha, with 20.x and 25.x already end-of-life. The Node.js end-of-life page says an end-of-life version no longer receives updates, including security patches, and the Releases page says production applications should only use Active LTS or Maintenance LTS releases.
No. The Node.js threat model trusts the code it is asked to run, including every dependency installed from the npm registry, and says a scenario that needs a malicious third-party module cannot be a vulnerability in Node.js. The Node.js security reporting page asks for security bugs in third-party modules to be reported to their maintainers. The fix comes from the package, through an update your team makes.
The Node.js security policy names two places: the Vulnerabilities category of the Node.js blog and the nodejs-sec Google Group. The post of 11 November 2026, read on 14 November 2026, lists Node.js v24.22.3 for the 24.x line under its downloads and release details. The policy also notes a built-in delay before a release's CVEs are publicly disclosed, so the CVE record can appear after the post.
npm's documentation says that with ignore-scripts set, npm does not run scripts specified in package.json files, although commands such as npm start, npm test and npm run still run the script they name. In the lab, npm ci with --ignore-scripts ran neither invented install script. This page's reading is that the setting does not stop a package's own code running when your application imports it. npm's rebuild documentation says npm install usually does the rebuild for you unless those steps were suppressed with --ignore-scripts or --no-bin-links, and describes installing with --ignore-scripts and then choosing which packages to build.
No. Its documentation calls it a seat belt that prevents trusted code from unintentionally using resources it was not granted, and says it does not protect against malicious code. The Node.js security policy says it is designed to reduce the blast radius of mistakes in trusted code, not to act as a security boundary against intentional misuse. It is marked Stable from Node.js 23.5.0 and 22.13.0, and the security release of 11 November 2026 included two fixes to it.
It depends on how they were built. The Node.js process documentation says Node.js refuses to load modules compiled against a different module ABI version, which process.versions.modules reports. Node-API is ABI stable across Node.js versions, so a module that uses it exclusively, with external libraries that offer similar ABI stability, is meant to run on later major versions without recompiling. For the rest, npm's rebuild documentation describes recompiling C++ add-ons after installing a new version of Node.js.
Scope the right test for your application
Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.