Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify app on Bun/Deno with no password-length cap
-
DeliverySubmit request with multi-megabyte password
-
ExploitPBKDF2 fallback re-hashes long key each iteration
-
ExecutionEvent loop blocked processing single request
-
ImpactConcurrent requests stalled (DoS)
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V2 - Validation and Business Logic Resource consumption limits
MITRE ATT&CK
1 technique across 1 tactic: Impact The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires ALL of: (1) the application runs on a runtime that uses the JS fallback - Node.js before 0.12, Bun 1.0.0-1.1.34 or 1.2.6 and later, Deno 2.9.0 and later, or code that imports lib/sync.js directly (native pbkdf2Sync on Node.js 0.12+ and browser builds via lib/sync-browser.js are NOT affected); (2) the application passes attacker-controlled data as the PBKDF2 password/key; and (3) the application does NOT enforce a reasonable maximum password length. The limiting factors are the non-default/niche runtimes and the fact that any password-length cap neutralizes the flaw; no authentication or user interaction is needed once these conditions hold. |
| Impact | This is a genuine but modest-severity denial-of-service issue, correctly rated around CVSS 6.3 (4.0) / ~5.3 (3.1). The provided CVSS 4.0 vector (AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L) shows a network-reachable, unauthenticated, low-complexity flaw with only LOW availability impact and no confidentiality or integrity impact - consistent with an event-loop stall rather than a crash or code execution. The AT:P (attack requirement present) metric is the key limiter: the vulnerable code path only runs on specific runtimes (Node.js before 0.12, Bun 1.0.0-1.1.34 and 1.2.6+, Deno 2.9.0+, or when lib/sync.js is imported directly) AND only matters if the application accepts overly long, user-controlled passwords without a maximum-length check. Modern Node.js and browser builds are entirely unaffected. There is NO EPSS score, NO CISA KEV listing, and NO standalone public exploit - only a regression/timing test shipped with the fix commit, which is not weaponized exploit code. The impact is a recoverable performance degradation (blocked event loop), not a persistent outage. Net: this is a real, patchable hygiene fix for a hot dependency, but it is a low-real-risk issue for most deployments because default modern runtimes are unaffected and any application enforcing a sane password length is not meaningfully exposed. Priority should be driven by whether you actually run Bun/Deno/legacy-Node and lack input-length validation. |
| Exploit ScenarioDerived | An application running on Bun or Deno uses pbkdf2Sync to hash user-supplied passwords and imposes no maximum length. An attacker submits a login or registration request containing a multi-megabyte 'password'; the JS fallback re-hashes that oversized key on every one of the thousands of PBKDF2 iterations, pinning the single-threaded event loop and stalling all concurrent requests. No public exploit code exists, but the fix commit includes a timing test that demonstrates the O(iterations × password length) cost with a 1 MiB password. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Sep 29, 2026
The pbkdf2 npm library through version 3.1.6 lets a long password drive an event-loop-blocking denial of service in its pure-JavaScript fallback (lib/sync.js), because passwords longer than the digest block size are re-hashed by HMAC on every PBKDF2 iteration. Applications are affected only when running on a runtime that actually uses that fallback - Node.js before 0.12, Bun 1.0.0-1.1.34 or 1.2.6 and later, Deno 2.9.0 and later, or code importing lib/sync.js directly - and only when attacker-controlled data is passed as the PBKDF2 password with no reasonable maximum length enforced. No public exploit code was identified at time of analysis; an upstream fix (commit 493d8d8) pre-hashes over-length keys once instead of per iteration, and the issue is a modest-severity availability bug (CVSS 4.0 6.3; independent assessment ~CVSS 3.1 5.3).
RemediationAI
Apply the upstream fix, commit 493d8d8 (https://github.com/browserify/pbkdf2/commit/493d8d8), which condenses any password longer than the digest block size a single time rather than on each iteration; note that no tagged patched release version was confirmed from the available data, so verify the release channel or pin the commit. The most effective compensating control, and the one named in the advisory, is to enforce a reasonable maximum password length before calling pbkdf2/pbkdf2Sync - a cap at or below the block size (64 bytes for MD5/SHA-1/SHA-224/SHA-256/RIPEMD-160, 128 bytes for SHA-384/SHA-512/SHA-512-256) fully neutralizes the flaw, at the trade-off of rejecting unusually long passphrases at input validation. Alternatively, pre-hash long passwords to a digest-length buffer before passing them in, which preserves the derived-key output while eliminating the per-iteration cost. Where possible, run on Node.js 0.12 or later (or a browser build) so the native pbkdf2Sync path is used instead of the vulnerable fallback, and avoid importing lib/sync.js directly; upgrading the runtime is a broader change but removes the affected code path entirely. Consult GHSA-477h-4r7f-fvrx for the vendor's authoritative guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
PBKDF2 derives keys by applying an HMAC-based pseudorandom function repeatedly. Per RFC 2104, HMAC keys longer than the hash block size (64 bytes for MD5/SHA-1/SHA-224/SHA-256/RIPEMD-160, 128 bytes for SHA-384/SHA-512/SHA-512-256) are first condensed to a digest-length key - but only if the implementation does that condensation once. In the browserify/pbkdf2 JavaScript fallback (lib/sync.js), a password exceeding the block size was passed to the HMAC as the key on every iteration, and because HMAC hashes over-length keys in full each time, total work became O(iterations × password length). This is a classic CWE-400 uncontrolled resource consumption pattern: an input-proportional cost multiplier inside a loop. The diff for commit 493d8d8 adds a one-time createHash(mappedDigest).update(password).digest() whenever password.length exceeds the digest block size, and its tests confirm that e.g. a 1 MiB password now matches the result of its SHA-256 pre-hash and finishes within roughly 10x of the pre-hashed timing instead of ballooning. The vulnerable path is the fallback used by pbkdf2Sync and pbkdf2 when the runtime's native pbkdf2Sync fails the library's feature check; Node.js 0.12+ and lib/sync-browser.js (browser builds) are unaffected. CPE data identifies the affected package as cpe:2.3:a:browserify:pbkdf2:*:*:*:*:*:*:*:* - i.e. all released versions through 3.1.6.
Know when Pbkdf2 gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
AC:H because exploitation depends on a specific non-default runtime and absence of length validation; PR:N as the oversized password is unauthenticated input; only A:L (recoverable event-loop stall), no C/I impact.
Primary rating from Vendor (harborist).
CVSS VectorVendor: harborist
DescriptionCVE.org
pbkdf2 through 3.1.6 re-hashes passwords longer than the digest's block size on every iteration in its JavaScript fallback (lib/sync.js). A password longer than the block size (64 bytes, or 128 bytes for sha384 and sha512) is passed to HMAC as the key on every iteration, and HMAC hashes such keys in full each time. Cost is therefore O(iterations × password length), and a long password can block the event loop. The fallback is used by pbkdf2Sync and pbkdf2 on Node.js before 0.12, on Bun (1.0.0 through 1.1.34, and 1.2.6 and later), and on Deno 2.9.0 and later, because their native pbkdf2Sync fails the library's feature check. It is also used when lib/sync.js is imported directly. Node.js 0.12 and later, and browser builds (which use lib/sync-browser.js), are not affected. Applications that enforce a reasonable maximum password length are not meaningfully affected.
Blast Radius
ecosystem impact- 108,075 npm packages depend on pbkdf2 (2,046 direct, 106,104 indirect)
Ecosystem-wide dependent count for version 3.1.7.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
EUVD-2026-88626
GHSA-477h-4r7f-fvrx
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB