Skip to main content

pbkdf2 (npm) EUVDEUVD-2026-88626

| CVE-2026-102414 MEDIUM
Uncontrolled Resource Consumption (CWE-400)
2026-09-29 harborist GHSA-477h-4r7f-fvrx
6.3
CVSS 4.0 · Vendor: harborist
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify app on Bun/Deno with no password-length cap
  2. Delivery
    Submit request with multi-megabyte password
  3. Exploit
    PBKDF2 fallback re-hashes long key each iteration
  4. Execution
    Event loop blocked processing single request
  5. Impact
    Concurrent 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.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

pbkdf2 0 ≤3.1.6

Affected Packages

npm pbkdf2 fix: 3.1.7

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

Vendor (harborist) PRIMARY 6.3 MEDIUM
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
vuln.today AI 3.7 LOW

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:L
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N

Primary rating from Vendor (harborist).

CVSS VectorVendor: harborist

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 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

EPSS Score
0.3%
Top 81% exploitable
Prevalence
High
extremely popular npm crypto library, transitive dependency of many packages
Threat Intel
1
1 source
Social Media
1
Sightings
Data Quality
6 sources
Confidence: High

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.

SignalValue
Severity MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact· derived
High
Technical Impact
Partial

Priority Score

32
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +32
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy