Skip to the stories
AI & ML

Node.js October 2026 Fixes Cover Brotli, DNS and TLS Flaws Across Three Release Lines

  • Saeed Abbasi
  • 757 reads

Node.js fixed 10 runtime flaws, including a Brotli memory write issue. Teams must upgrade supported versions and locate runtimes embedded in apps and containers.

Node.js October 2026 Fixes Cover Brotli, DNS and TLS Flaws Across Three Release Lines

Node.js’ October 21, 2026 security update addresses a runtime-level flaw that can turn crafted Brotli data into a remote code execution path, alongside weaknesses in DNS and TLS checks. The practical challenge is finding every affected runtime: package dependency audits won’t catch copies bundled into containers, single-executable applications or application directories.

The update covers 10 vulnerabilities across Node.js 22.x, 24.x and 26.x. Four are rated High by Node.js; the Brotli issue, CVE-2026-111497, has a CVSS 4.0 score of 9.2, classified as Critical. Fixed versions are 22.23.4, 24.22.1 and 26.12.1. Older, unsupported lines have no fix and need to move to a supported branch.

That scope makes this a runtime inventory and deployment problem as much as a patching task. A team can update its application packages and still leave the vulnerable Node.js binary running. Long-lived processes also continue using the runtime already loaded in memory until they restart.

The exposure is in the runtime

The most severe issue affects the bundled Brotli decoder. A crafted compressed stream can make the decoder write beyond its allocated memory. Node.js describes the result as a remote code execution vulnerability. Services that decompress data they did not create deserve particular attention, including HTTP clients or proxies accepting Content-Encoding: br and applications that process uploaded compressed files.

Three other High-severity flaws involve name resolution and certificate identity checks.

In CVE-2026-105482, DNS functions that use c-ares pass names as C strings. An embedded NUL character truncates the name, creating a gap between a hostname an application validates against an allowlist and the name actually queried. The affected interfaces are dns.resolve*, dns.reverse and the Resolver class. Node.js says dns.lookup is not affected.

CVE-2026-106069 concerns tls.checkServerIdentity. Noncanonical IP forms, including shortened or octal representations, can be checked against a certificate for one address even when the connection goes to another. CVE-2026-105483 involves Unicode fullwidth digits in hostnames: normalization can produce an IP address that matches a certificate issued for that address. This last issue affects 24.x and 26.x, not 22.x.

These bugs are distinct, but their operational relevance overlaps. Teams that accept user-supplied destinations, resolve user-provided hostnames or establish outbound TLS connections should review how their applications validate and normalize those inputs. Updating Node.js closes the runtime flaws; application-level input handling remains relevant to the wider design.

All 10 vulnerabilities in the update

The remaining findings affect HTTP keep-alive handling, certificate validation, random values, ZIP parsing and the Permission Model. Their severity ratings are lower, but the exact exposure depends on which runtime features an application uses.

CVESeverityAreaIssue and affected lines
CVE-2026-111497Highzlib / BrotliDecoder out-of-bounds write; potential remote code execution. 22.x, 24.x, 26.x.
CVE-2026-105482HighDNSEmbedded NUL truncates DNS names. 22.x, 24.x, 26.x.
CVE-2026-105483HighTLSHostname validation bypass involving fullwidth IP digits. 24.x, 26.x.
CVE-2026-106069HighTLSHostname validation bypass involving noncanonical IP addresses. 22.x, 24.x, 26.x.
CVE-2026-105481MediumHTTPA response sent through an idle reused keep-alive socket can be treated as the response to a later request. 22.x, 24.x, 26.x.
CVE-2026-106072MediumTLSCertificate validation issue involving unusual IPv4 representations. 22.x, 24.x, 26.x.
CVE-2026-106074MediumcryptoStartup snapshots can preserve cached random values, making initial values identical across processes using the same snapshot. 22.x, 24.x, 26.x.
CVE-2026-106070Lowzlib / ZipFileThe experimental zlib.ZipFile API can return bytes from the wrong file position after a failed header check. 26.x.
CVE-2026-106071LowPermission ModelWildcard paths in --allow-fs-read or --allow-fs-write can grant access to more files than intended. 26.x.
CVE-2026-106073Lowfs / Permission Modelfs.realpathSync can bypass a Permission Model check. 22.x, 24.x, 26.x.

The random-value issue has a specific deployment condition: it affects single-executable applications using useSnapshot or user-land snapshots. The ZIP issue concerns an experimental API introduced in 26.8.0. Those details can help teams identify whether the lower-rated findings touch their actual runtime configuration, while the fixed releases address the full set for each supported line.

Patch status and version support

BranchFixed releaseAction
22.x LTS22.23.4Upgrade to this version or a later release in the same line.
24.x LTS24.22.1Upgrade to this version or a later release in the same line.
26.x26.12.1Upgrade to this version or a later release in the same line.
25.x, 23.x, 21.xNo fix listedMove to a supported branch.
20.x and earlierEnd of lifeMove to a supported branch.

Node.js 26 was scheduled to become LTS on October 28, 2026. Teams on 26.x should use 26.12.1 before that transition, according to the update guidance. A fixed release is available for each supported branch, and later releases within that branch also contain the fixes.

There are no Node.js workarounds that fully resolve these issues; upgrading the runtime is the complete fix. Interim steps can reduce exposure while teams prepare that change, but they do not make an affected runtime safe. The distinction is particularly important for end-of-life versions: they cannot receive the fixes, so patch deployment alone is not an option.

Why dependency scans miss runtime copies

Node.js can be installed through version managers such as nvm, kept inside application folders, bundled with a single-executable application or included in a container image. Cloud functions, including AWS Lambda Node.js runtimes, add another place to check. These installations may not appear in the application’s dependency manifest, even though the application runs the affected code.

That makes runtime discovery different from finding a vulnerable library version in a package tree. Teams need to identify the executable actually present across hosts, containers, images and serverless workloads, including nonstandard paths. They also need to distinguish an image that contains an old runtime from a deployed process that is currently using it.

An anonymized analysis by Qualys Threat Research Unit counted 3.3 million Node.js package installations. Fifteen percent were on internet-facing assets. Of the installations, 1.3 million used supported branches with fixes available, while 1.7 million were on end-of-life or unsupported lines, including 25.x, 23.x, 20.x and older. Just 42,000 had been patched at the time of the analysis.

The figures point to two separate work queues: upgrade supported runtimes to their fixed versions, and migrate unsupported runtimes to a supported branch. Internet-facing services that process untrusted Brotli data are a sensible first group to investigate, followed by services making TLS connections to user-supplied hosts. Unsupported installations need a migration plan because there is no branch-level patch to apply.

Finding runtimes across an estate

Qualys describes a workflow that combines inventory, detection, prioritization, patching and follow-up checks. Its InstaScan service matches new vulnerability information against asset and software telemetry already collected by customers. Qualys says it surfaced findings within minutes of the October update becoming public, without waiting for a new scan job. That timing and coverage are vendor claims; teams should validate them against their own inventory and deployment process.

For less conventional installation locations, Qualys Deep Scan can identify runtimes in custom application folders, secondary drives and configured directories. Findings in VMDR include the binary path, installed version and recommended fixed version, details that help operators locate which deployment artifact or service needs attention.

Qualys customers can query their inventory for all Node.js assets, older versions and installations on critical assets. The following examples are from the Qualys CSAM asset inventory interface:

  • All assets with Node.js: (software: ((name: “Node.js”)))
  • Older Node.js installations: ((software: (((name: “Node.js”) AND (version: (*..22.0.0))))))
  • Node.js on critical assets: ((asset.criticalityScore: [4..*)) AND (software: ((name: “Node.js”))))

For cloud workloads, containers and images, Qualys TotalCloud and Container Security support queries against software versions. The query below identifies versions up to the fixed releases shown in the source guidance:

software: (name: "nodejs" and version: [0 ... 22.23.3])
or software: (name: "nodejs" and version: [23.0.0 ... 23.11.1])
or software: (name: "nodejs" and version: [24.0.0 ... 24.22.0])
or software: (name: "nodejs" and version: [25.0.0 ... 25.9.0])
or software: (name: "nodejs" and version: [26.0.0 ... 26.12.0])

Inventorying an image is only part of the job. Visibility into deployed containers helps show where that image is running, while Qualys says its Runtime Sensor can help distinguish software merely present in an image from packages in use or reachable at runtime. That distinction can guide sequencing, though it does not replace updating and redeploying affected artifacts.

Prioritize by exposure, then verify

Qualys Enterprise TruRisk Management combines findings from Qualys and other sources, removes duplicates and scores the remaining issues using threat intelligence, asset importance and exposure. Qualys’ QVSS adds threat context to CVSS severity. In practice, severity gives teams a view of potential impact; asset and exposure context helps decide which runtime to handle first.

  • Investigate first: Internet-facing services that decompress untrusted Brotli data, because the decoder flaw can permit remote code execution.
  • Next: Services that make TLS connections to user-supplied hosts, where hostname validation flaws could expose traffic to interception.
  • Plan migration: Installations on unsupported branches, which cannot receive the fixes.

A dashboard can help track the footprint by installation path, deployment type, branch, internet exposure and finding status. Qualys says its Node.js dashboard also groups high-risk assets by operating system and tracks whether detections are active, fixed or reopened. After a rescan, the relevant findings are expected to close; that status is useful evidence that a runtime was detected as updated, though teams still need to confirm that production services have restarted onto it.

Qualys lists QIDs 389117, 389119 and 389122 for the findings, with platform coverage including Windows, Windows DeepScan and macOS. The first covers several findings across the supported lines; the second covers the TLS hostname issue limited to 24.x and 26.x; the third covers the two low-severity issues specific to 26.x. Separate detections identify obsolete Node.js versions.

For web application and API checks, Qualys TotalAppSec offers QID 533085 to assess whether the Brotli issue remains present at the application level. Qualys warns that this intrusive check can crash applications running vulnerable Node.js versions. It should be limited to test environments or systems confirmed to be patched, not run against unverified production services. Runtime version checks through VMDR or TotalCloud can complement that application-level assessment.

Patch, restart and rebuild

Qualys says patches for 24.x and 26.x are available through TruRisk Eliminate, while teams on 22.x should upgrade the runtime manually until a patch is available through that product. It rates the fixes as high reliability and says an operating system reboot is not required. Those statements describe the vendor’s patch offering; teams should still follow their own rollout and service validation procedures.

Installing a fixed binary does not replace the runtime inside an already running process. Restart every Node.js service so it loads the updated runtime. Rebuild and redeploy container images and single-executable applications that embed Node.js. For serverless deployments, update the runtime configuration or artifact as applicable, then verify the deployed version.

While preparing upgrades, Qualys Threat Research Unit suggests avoiding decompression of untrusted Brotli input where possible, limiting compressed payload size and decompression ratio at a reverse proxy or WAF, and rejecting names containing NUL characters. For hostname handling, use dns.lookup for user-supplied names and convert IP addresses to canonical form before connecting. The guidance also recommends disabling http.Agent keep-alive for connections to untrusted servers and not relying on the Permission Model as a security boundary on affected versions.

These are temporary exposure controls, not substitutes for the fixed runtime. A practical closure sequence is to upgrade supported installations, migrate unsupported lines, rebuild anything that bundles Node.js, restart long-running services and rescan hosts and containers. Check that the relevant detections have closed and that the running deployment—not just the build artifact—uses the fixed version.

What teams should watch next

The defining detail in this update is where the vulnerable code lives: inside Node.js itself. That shifts the response beyond application dependency files toward binary discovery, artifact rebuilds and process restarts. Teams with mixed branch versions should expect two kinds of remediation work, patching supported lines and moving older installations onto a supported branch.

The immediate priority is to establish where each runtime is deployed and whether it handles untrusted compressed data or user-controlled network destinations. From there, teams can choose the appropriate fixed release, restart or rebuild the affected services, and verify the result in the deployed environment. The remaining uncertainty is operational: how quickly each organization can find every embedded copy and ensure its active workloads have actually loaded the fix.

Source: Saeed Abbasi · blog.qualys.com

From the same set