CVE-2026-48933

What it actually does

This is an availability vulnerability in the Node.js WebCrypto implementation. When an application calls `crypto.webcrypto.subtle.encrypt()` with input whose size is an exact multiple of 2 GiB, the Node.js process can crash. The issue affects supported Node.js release lines 22, 24, and 26. The flaw does not directly expose data or allow data modification, but it can terminate the application process handling the encryption operation, causing denial of service. Exploitability depends on whether an application allows remote or untrusted users to supply large data that is passed into `subtle.encrypt()` without size limits.

Why it matters to the business

A vulnerable service can be made unavailable if an attacker can cause it to encrypt very large attacker-controlled input. For internet-facing APIs, file-processing services, upload pipelines, encryption gateways, or backend services that use Node.js WebCrypto, this can translate into service outages, failed jobs, degraded customer experience, and potential incident response costs. The CVSS score indicates high availability impact, but the currently reported EPSS is relatively low, the vulnerability is not listed in CISA KEV, and no mature public exploitation is indicated, so prioritization should focus first on exposed Node.js services that accept large uploads or process untrusted encrypted/encryptable content.

How an attack unfolds

An attacker first identifies a Node.js service that accepts large input, such as a file upload, message body, stream, blob, or API payload. The attacker then determines whether that input is passed into a WebCrypto encryption path using `subtle.encrypt()`. If the service lacks strict request-size, object-size, or stream-size limits, the attacker submits data whose size is an exact multiple of 2 GiB, such as 2,147,483,648 bytes or 4,294,967,296 bytes. When the vulnerable Node.js runtime processes that input through `subtle.encrypt()`, the process can crash. If the application is supervised by a process manager or orchestrator, the process may restart, but repeated requests can cause crash loops, capacity loss, failed transactions, and sustained denial of service.

How to fix it

Upgrade Node.js to a vendor-fixed release as soon as fixed versions are published for the affected supported lines. Because no fixed versions are provided in the input, organizations should monitor official Node.js security releases for Node.js 22, 24, and 26 and apply the first release that includes the WebCrypto crash fix. Until patched, enforce strict maximum input sizes well below 2 GiB on every path that can reach `crypto.webcrypto.subtle.encrypt()`. Apply limits at multiple layers: edge proxy, load balancer, API gateway, application framework body parser, file-upload middleware, message queue consumers, and encryption helper functions. Reject or chunk large inputs before passing them to WebCrypto, and avoid allowing a single `subtle.encrypt()` call to operate on multi-gigabyte attacker-controlled buffers. Where large-object encryption is required, use a streaming or chunked encryption design with bounded chunk sizes and explicit validation. Ensure process supervisors restart crashed Node.js workers, but do not rely on restarts as the primary mitigation because repeated requests can still create a denial-of-service condition.

How to confirm the fix worked

Inventory all production and build/runtime images using Node.js 22, 24, or 26 and confirm whether they use `crypto.webcrypto.subtle.encrypt()` or libraries that wrap WebCrypto encryption. Verify the deployed Node.js version against official fixed releases once available. Confirm that request, upload, queue message, and object-processing size limits are set below 2 GiB and are enforced before data reaches encryption code. Review application tests for large-input handling and add regression tests that assert oversized input is rejected before encryption. In staging or an isolated test environment only, validate that payloads near and above configured size limits are rejected cleanly and do not terminate the Node.js process. Avoid testing the crash condition in production because the expected failure mode is process termination.

Typical attack path

1. Identify a Node.js application or API that accepts large user-controlled input.
2. Find functionality likely to encrypt submitted content, such as upload encryption, secure storage, message encryption, backup encryption, or token/package processing.
3. Send a payload whose size is an exact multiple of 2 GiB to the vulnerable code path.
4. Trigger `crypto.webcrypto.subtle.encrypt()` on that payload.
5. Cause the Node.js process to crash, interrupting active requests and background work.
6. Repeat the request to create recurring crashes or sustained service degradation.

How to detect it

Look for evidence of large inbound requests or objects immediately followed by Node.js worker exits, container restarts, process-manager restarts, core dumps, or availability alerts. Relevant log sources include reverse proxy and load balancer access logs, API gateway logs, WAF logs, application logs, Node.js stderr/stdout, process manager logs such as PM2 or systemd, Kubernetes pod events, container runtime logs, crash dump directories, and host telemetry. Focus on requests with `Content-Length` values that are exact multiples of 2 GiB, especially 2147483648 or 4294967296 bytes, and correlate them with crashes in services that perform WebCrypto encryption. Review application traces for code paths invoking `crypto.webcrypto.subtle.encrypt()` shortly before process termination. Investigate repeated restarts, exit signals, `Segmentation fault`, `Aborted`, fatal runtime errors, or core dump creation after large uploads. Since there are no known unique public exploit artifacts for this issue, detection should rely on behavioral correlation: oversized input plus WebCrypto encryption path plus Node.js process crash.

• Content-Length: 2147483648
• Content-Length: 4294967296
• Content-Length: 6442450944
• crypto.webcrypto.subtle.encrypt
• subtle.encrypt
• SubtleCrypto.encrypt
• Segmentation fault
• Aborted (core dumped)
• core dumped
• FATAL ERROR
• pm2: App crashed
• PM2 | App [
• systemd-coredump
• Back-off restarting failed container
• CrashLoopBackOff
• OOMKilled

What your security team should do

• Prioritize internet-facing Node.js 22, 24, and 26 services that accept large uploads, large request bodies, file processing, or user-controlled content that may be encrypted.
• Add or verify hard input-size limits below 2 GiB at the edge, gateway, application, and encryption-helper layers.
• Monitor official Node.js security advisories and patch immediately when fixed versions for the affected release lines are available.
• Search code and dependencies for direct or indirect use of `crypto.webcrypto.subtle.encrypt()` and review whether untrusted data can reach it.
• Add alerting for repeated Node.js process crashes, container restarts, worker exits, and unusually large inbound requests.
• Review WAF, proxy, and object-storage ingestion rules to block or quarantine multi-gigabyte requests unless explicitly required.
• For services that must handle large objects, redesign encryption to use bounded chunks or streaming encryption rather than a single WebCrypto call over multi-gigabyte input.
• Because the issue is not currently in KEV and has no reported mature exploitation, align urgency with exposure, but treat externally reachable large-input encryption paths as high priority due to the simple denial-of-service condition.