Introduction
One unauthenticated multipart request can terminate a Node.js process that uses @fastify/busboy to parse uploads. The request only has to go past the parser's parts limit and then stop in the middle of a part. The crash happens inside the parser before any route handler runs, so application-level error handling cannot catch it. The remedy is a dependency upgrade, not a change to your own code.
@fastify/busboy is a streaming parser for HTML form data in Node.js, maintained as an officially supported fork by the Fastify organization. The npm listing we reviewed reported 43,142,994 weekly downloads and 122 dependents, and most services pull it in transitively through @fastify/multipart rather than installing it directly. Fastify itself is an OpenJS Foundation project that describes itself as a low-overhead web framework with an ecosystem of 297 plugins, which puts this parser in the upload path of a broad set of Node.js services.
The CVE record assigns CVSS 3.1 7.5 High with vector AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H: network reachable, no privileges, no user interaction, and high availability impact with no confidentiality or integrity impact. The fixed release is @fastify/busboy 3.2.6.
Technical information
Root cause
Busboy enforces a configurable parts limit on the number of multipart parts in a request (the default is 1000). When a request reaches that limit, busboy sets hitPartsLimit, emits a partsLimit event, and stops handing further parts to the application. A helper called skipPart() in lib/types/multipart.js drains each extra part internally instead.
Before the fix, that helper only resumed the stream to discard its data:
function skipPart (part) { part.resume() }
Nothing ever listened for errors on these skipped part streams. Two behaviours combine badly here:
- Busboy's vendored Dicer parser emits an error,
Part terminated early due to unexpected end of multipart data, on a part stream if the request body ends partway through that part. - In Node.js, an
EventEmitterthat emits'error'with no listener attached throws. Uncaught, this brings down the process.
So when the body ends inside a skipped part, Dicer emits its truncation error on a stream with no consumer and no listener, Node.js raises an unhandled 'error' event, and the process exits. The error originates inside the parser, before application code has any chance to intercept it. The CVE record maps this to CWE-248 (Uncaught Exception) and CWE-754 (Improper Check for Unusual or Exceptional Conditions).
Why @fastify/multipart 10.1.x surfaced it
The advisory describes the bug as latent in the parser on its own. It was first demonstrated through @fastify/multipart versions 10.1.2 through 10.1.4. Unlike the 9.x line, those versions keep feeding the request body to busboy after a limit error, so the parser continues into the skipped-part code path where the missing listener becomes fatal. Fastify multipart issue #643 notes that on 10.1.x, parser limit errors are delivered without tearing down the request pipe, so busboy keeps parsing after the limit.
Preconditions
According to the advisory, a consumer is affected when both of the following are true:
- It sets a finite
partslimit (the default of 1000 counts). - It parses request bodies that can be terminated early.
In practice that describes most Fastify routes that accept uploads.
Attack flow
Based on the advisory and patch description, exploitation proceeds as follows:
- The attacker sends an unauthenticated multipart request to an endpoint whose body is parsed by an affected
@fastify/busboybuild with a finite parts limit. - The body contains more parts than the configured limit. Busboy sets
hitPartsLimit, emitspartsLimit, and routes each additional part throughskipPart(). - The body ends inside one of those skipped parts, with no closing boundary.
- Dicer emits
Part terminated early due to unexpected end of multipart dataon the skipped part stream. - No
'error'listener is attached to that stream, so Node.js throws an unhandled'error'event and the process exits.
One request is enough, and the result is a full process exit, not just a failed request. We found no report of exploitation in the wild or threat actor attribution in the reviewed sources. The advisory's demonstration through @fastify/multipart describes a reproduction path, not observed attacker activity.
Patch information
The maintainers fixed CVE-2026-124724 in @fastify/busboy 3.2.6, released on November 16, 2026. Advisory GHSA-wh8h-qr34-3rj3 lists the vulnerable range as >= 1.0.0, < 3.2.6 and 3.2.6 as the patched version. The fix is commit a5eace6 ("fix: swallow 'error' on skipped multipart parts"), written by Matteo Collina and reviewed by Ulises Gascón. The GitHub compare between v3.2.5 and v3.2.6 confirms the commit ships in the release.
The library change is four lines in lib/types/multipart.js, three of them comments:
function skipPart (part) { + // A skipped part has no consumer. If the request body ends in the middle of + // the part, Dicer emits a "terminated early" error on it. Without a listener + // Node throws an unhandled 'error' event and exits the process. + part.on('error', () => {}) part.resume() }
Before draining a skipped part, the fix gives it an empty 'error' listener. Discarding the error is safe here because the part is already being thrown away, so a truncation error on it carries nothing the application needs. The underlying condition, a body that ended unexpectedly, is still reported separately through Dicer's own 'error' on the main busboy stream, which consumers such as @fastify/multipart already listen for. The patch stops one discarded stream from crashing the process and keeps the error the application should see for the request as a whole.
Regression test
The commit adds a test to the multipart coverage test suite that reproduces the crash:
- It creates a busboy instance with
limits: { parts: 2 }. - It sends a body with two complete fields followed by a third part whose content (
partial) never receives a closing boundary. - It asserts that
partsLimitfires, that the first parts arrive as fields, and that'finish'is reached instead of the process exiting.
The test also attaches a busboy-level 'error' listener, because a well-behaved consumer is expected to handle the separate "unexpected end" error itself.
Other changes in 3.2.6
The v3.2.5...v3.2.6 compare contains four more parser fixes in the same release. The advisory credits only a5eace6 for this CVE, but upgrading picks up all of them:
6a511e9: Dicer no longer hangs when a delimiter cuts off a part's header block.df48e8d: header size and pair counters now reset when that happens.f86488e: urlencodedfieldSizeandfieldNameSizelimits are enforced with>=rather than exact equality.00b74b1: split CRLFCRLF terminator bytes at theheaderSizelimit are handled correctly.
Remediation guidance
- Upgrade
@fastify/busboyto 3.2.6 or later, including transitive copies resolved through@fastify/multipart. - If you set a finite parts limit, also attach an
'error'listener to the parser stream. The advisory presents this as an extra defensive measure, not a replacement for upgrading. - Do not rely on application error handlers as a workaround. The advisory states there is no complete application-level workaround because the crash happens inside the parser before application code runs.
Detection methods
There are no published YARA, Sigma, Snort or Suricata rules for CVE-2026-124724, and no IoCs such as hashes, IPs or domains. That is expected for a parser bug where one malformed request crashes the process. Detection still works well along three lines: exposure through package versions, direct code inspection, and runtime crash signals.
1. Exposure through software composition analysis
- Vulnerable:
pkg:npm/@fastify/busboyfrom>= 1.0.0up to< 3.2.6 - Fixed: 3.2.6
Check npm, Yarn and pnpm lockfiles, SBOMs and container images for any resolved @fastify/busboy in that range, including transitive resolutions. Prioritise services using @fastify/multipart 10.1.2 through 10.1.4. Any SCA tool that reads the GitHub Advisory Database should flag the package once it has synced the GHSA. A vulnerable version alone does not prove a route is exploitable. Use the two preconditions (finite parts limit, bodies that can end early) to rank endpoints.
2. Code inspection
If version data is unreliable because of vendored or bundled copies or patched forks, inspect skipPart() in @fastify/busboy/lib/types/multipart.js. The fixed upstream version reads:
function skipPart (part) { // A skipped part has no consumer. If the request body ends in the middle of // the part, Dicer emits a "terminated early" error on it. Without a listener // Node throws an unhandled 'error' event and exits the process. part.on('error', () => {}) part.resume() }
A file content check across node_modules trees and container layers works. Any copy whose skipPart function lacks the part.on('error', ...) line is vulnerable, whatever its package.json version says.
3. Runtime signals in logs and process behaviour
The advisory names two error strings worth alerting on:
Part terminated early due to unexpected end of multipart data: the error on the skipped part that kills the process. Expect it inside an unhandled'error'event oruncaughtExceptionstack trace immediately before exit.Unexpected end of multipart data: a separate error Dicer emits on the busboy stream itself. Seeing it in handled logs means someone is sending truncated multipart bodies, which is a useful early warning even without a crash.
The first string alone does not prove this CVE. Fastify multipart issue #594, an earlier @fastify/multipart 9.2.1 bug, produced the same message and crash when req.file() was awaited after another async operation. To attribute a crash to CVE-2026-124724, look for a parts limit event just before it. If your application or @fastify/multipart logs the partsLimit event or the parts limit error it produces, a parts limit event followed closely by a "terminated early" crash on the same worker is a strong match.
Correlations to build:
- Process lifecycle: sudden Node.js exits or restarts of upload-handling services, such as supervisor restarts, container restarts, or pods entering crash loops, lined up with the stack trace above. Repeated restarts that coincide with incoming multipart requests suggest a deliberate attempt to keep the service down.
- Edge and reverse proxy telemetry: while the Node process is down, the proxy will see multipart form POSTs whose upstream connection resets or returns 502 or 503. Prioritise requests that contain more multipart boundaries than your configured parts limit (more than 1000 by default) and that end without the closing delimiter. If a WAF or proxy can count parts or verify proper multipart termination, those two traits together describe the trigger.
- Hangs as a related signal: issue #643 describes a separate limit handling bug on
@fastify/multipart10.1.x that made requests hang instead of crash. Upload requests stuck open under limit-heavy traffic point to a related problem and deserve review.
4. What you will not find
The crash happens inside the parser before application code runs, so request handler logging and per-route error handlers will usually record nothing for the triggering request. Rely on process-level crash logs, supervisor events and proxy logs instead of application access logs, and implement these checks as custom search and alerting rules in your SIEM.
Affected systems and versions
@fastify/busboy1.0.0 through 3.2.5 (advisory range>= 1.0.0, < 3.2.6) is vulnerable.@fastify/busboy3.2.6 and later is fixed.@fastify/multipart10.1.2 through 10.1.4 is the path through which the issue was first demonstrated, because these versions keep feeding the request body to busboy after a limit error. Check which busboy version these installs resolve.- Vulnerable configuration: any consumer of an affected busboy build that sets a finite
partslimit (the default is 1000) and parses request bodies that can be terminated early.
Vendor security history
This is not the first @fastify/busboy parser advisory of 2026. Earlier advisories covered a denial of service via an oversized multipart boundary and a denial of service via a prototype-named multipart part header, both fixed in 3.2.1, and a CRLF injection issue via the multipart Content Disposition filename and name, fixed in 3.2.2. Together with the extra parser fixes bundled into 3.2.6, this shows active maintenance of the parser's edge-case handling. On its own, it does not establish whether the project's record is stronger or weaker than comparable parsers.
References
- NVD entry for CVE-2026-124724 (returned "CVE ID Not Found" when checked)
- CVE.org record for CVE-2026-124724
- CVE Services API record
- OpenJS Foundation CNA security advisories
- GitHub advisory GHSA-wh8h-qr34-3rj3
- GitHub API: advisory GHSA-wh8h-qr34-3rj3
- Fix commit a5eace6
- GitHub API: fix commit a5eace6
- GitHub API: busboy releases
- Compare v3.2.5 to v3.2.6
- Current multipart.js source
- Fastify multipart issue #594
- Fastify multipart issue #643
- Advisory: CRLF injection via Content Disposition filename and name
- Advisory: Denial of Service via prototype named part header
- Advisory: Denial of Service via oversized multipart boundary
- busboy security policy
- busboy releases
- fastify/busboy repository
- @fastify/busboy on npm
- Fastify project site



