fast-jwt
Affected
- introduced
0.0.1, fixed6.2.0(semver)
Fixed versions
6.2.0
Fix
- Fixed version
6.2.0npm install [email protected]
Advisory
Also known as: CVE-2026-35039
fast-jwt: Cache Confusion via cacheKeyBuilder Collisions Can Return Claims From a Different Token (Identity/Authorization Mixup)
_NOTE_: While the library exposes a mechanism which could introduce the vulnerability, this issue is created by developer-supplied code and not by the library itself. We will add a warning and some education for users around the possible issues however since the defaults work we will not be updating the library beyond that for this advisory.
Impact
Setting up a custom cacheKeyBuilder method which does not properly create unique keys for different tokens can lead to cache collisions. This could cause tokens to be mis-identified during the verification process leading to:
This could result in:
Affected Configurations
This vulnerability ONLY affects applications that BOTH:
VULNERABLE examples:
// Collision-prone: same audience = same cache key
cacheKeyBuilder: (token) => {
const { aud } = parseToken(token)
return `aud=${aud}`
}
// Collision-prone: grouping by user type
cacheKeyBuilder: (token) => {
const { aud } = parseToken(token)
return aud.includes('admin') ? 'admin-users' : 'regular-users'
}
// Collision-prone: tenant + service grouping
cacheKeyBuilder: (token) => {
const { iss, aud } = parseToken(token)
return `${iss}-${aud}`
}
SAFE examples:
// Default hash-based (recommended)
createVerifier({ cache: true }) // Uses secure default
// Include unique user identifier
cacheKeyBuilder: (token) => {
const { sub, aud, iat } = parseToken(token)
return `${sub}-${aud}-${iat}`
}
// No caching (always safe)
createVerifier({ cache: false })
Not Affected
Assessment Guide
To determine if you're affected:
Mitigations
Mitigations include:
---
fast-jwt allows enabling a verification cache through the cache option.
The cache key is derived from the token via cacheKeyBuilder.
When a custom cacheKeyBuilder produces collisions between different tokens, the verifier may return the cached payload of a previous token instead of validating and returning the payload of the current token.
This results in cross-token payload reuse and identity confusion.
Two distinct valid JWTs can be verified successfully but mapped to the same cached entry, causing the verifier to return claims belonging to a different token.
This affects authentication and authorization decisions when applications trust the returned payload.
Affected component
src/verifier.js
Relevant logic:
cache enabled via createCache
cache population via cacheSet
lookup based on cacheKeyBuilder(token)
cached payload returned without re-verification
Impact
Identity / authorization confusion via cache collision.
If two tokens generate the same cache key:
token A is verified → payload stored in cache
token B is verified → cache hit occurs
verifier returns payload from token A instead of B
Observed effect:
subject mismatch
claim mismatch
authorization decision performed on wrong identity
Potential real-world consequences:
user impersonation (logical)
privilege confusion
incorrect RBAC evaluation
gateway / middleware auth inconsistencies
This is especially dangerous when:
cache is enabled (recommended for performance)
custom cacheKeyBuilder is used
identity claims (sub / aud / iss) drive authorization
Root cause
The verifier assumes the cache key uniquely identifies the token and its claims.
However:
cacheKeyBuilder is user-controlled
collisions are not detected
cache entries store decoded payload
cached payload is returned without binding validation
This creates a trust boundary break between:
token → cache key → cached payload
Proof of concept
Environment:
fast-jwt: 6.1.0
Node.js: v24.13.1
PoC:
const { createSigner, createVerifier } = require('fast-jwt')
const sign = createSigner({ key: 'secret' })
// Two distinct tokens
const t1 = sign({ sub: 'userA', aud: 'admin' })
const t2 = sign({ sub: 'userB', aud: 'admin' })
// Deliberately unsafe cache key builder (collision)
const verify = createVerifier({
key: 'secret',
cache: true,
cacheKeyBuilder: () => 'static-key'
})
console.log('verify t1')
const p1 = verify(t1)
console.log('t1 PASS sub=', p1.sub)
console.log('verify t2')
const p2 = verify(t2)
console.log('t2 PASS sub=', p2.sub)
console.log('verify t2 again')
const p3 = verify(t2)
console.log('t2-again PASS sub=', p3.sub)
console.log('verify t1 again')
const p4 = verify(t1)
console.log('t1-again PASS sub=', p4.sub)
Observed output:
verify t1
t1 PASS sub= userA
verify t2
t2 PASS sub= userA
verify t2 again
t2-again PASS sub= userA
verify t1 again
t1-again PASS sub= userA
The verifier returns payload from userA when verifying userB.
Expected behavior
Cache must not allow returning claims from a different token.
Verification must remain bound to the actual token being validated.
Even if cache collisions occur, the verifier should:
revalidate signature
re-decode payload
or invalidate cache entry
Why this is not “just misuse”
This is not merely a user mistake.
Reasons:
fast-jwt explicitly exposes cacheKeyBuilder as an extension point.
The documentation suggests performance tuning via custom key builders.
No safeguards exist against collisions.
No verification binding is performed between:
cached payload
original token
The verifier trusts cache output as authoritative identity.
This creates a security-sensitive invariant:
"cache key uniqueness"
which is neither enforced nor validated.
Security-critical libraries must assume extension hooks can be misused and implement defensive checks, especially when identity decisions are derived from cached values.
Security classification
logical authorization flaw
cache confusion vulnerability
identity boundary break
Closest CWE:
CWE-440 — Expected Behavior Violation
Suggested fix (minimal and safe)
Bind cache entries to token integrity.
Option A — safest:
Store token hash along with payload and verify match before returning cache.
Conceptual patch:
const tokenHash = hashToken(token)
Critical Basis: The source's own band: CRITICAL
0.0.1, fixed 6.2.0 (semver)6.2.0
6.2.0npm install [email protected]Fix commands are the export's own generic commands. Ojuju never runs them. Check them against your setup first.
Check your own computer: guard packages check
Source: GitHub Advisory Database (reviewed advisories) · CC BY 4.0