Skip to main content

fast-jwt EUVDEUVD-2026-95344

| CVE-2026-107720 HIGH
Improper Input Validation (CWE-20)
2026-10-08 GitHub_M GHSA-8wpc-h4q6-8fxv
7.4
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Forge unsigned JWT with empty signature
  2. Exploit
    Set header alg to an allowlisted algorithm
  3. Execution
    Submit token to misconfigured fast-jwt verifier
  4. Impact
    Bypass signature check and authenticate as arbitrary identity

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
Exploitation Conditions

Exploitable ONLY when the application instantiates fast-jwt's createVerifier with a falsy SYNCHRONOUS key - an empty string '' or null - AND simultaneously supplies a non-empty algorithms allowlist (e.g. algorithms: ['HS256']). Under that specific combination, prepareKeyOrSecret is skipped, hasKey is false, and an unsigned token's empty signature bypasses the verifySignature gate. Exploitation is explicitly BLOCKED in these cases (per the advisory): any non-empty/real key, a falsy key with NO algorithms option set, and the asynchronous key-resolver path (key provided as a function/promise) - all of which are unaffected. Claim validators still execute, so time/audience/issuer constraints configured on the verifier continue to apply and can limit a forged token. The required configuration is non-default and developer-introduced, which is the primary real-world limiting factor; no authentication, privileges, or user interaction are needed by the attacker once such a verifier exists.

Impact

CVSS 3.1 base score is 7.4 (High) with vector AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N - network-reachable and requiring no privileges or user interaction, which maps directly to the described authentication/authorization bypass via a forged unsigned JWT. The AC:H rating is the single most important real-risk modifier: the flaw only manifests when an application built createVerifier with a falsy synchronous key ('' or null) AND an explicit non-empty algorithms allowlist. This is a non-default, developer-introduced misconfiguration, not a condition any arbitrary deployment meets, so the pool of actually-exploitable instances is far smaller than the 7.4 score alone implies. No EPSS probability is provided in the input, there is no CISA KEV listing, and no standalone public exploit tool is referenced - so exploitation status is 'no public exploit identified at time of analysis.' However, the nearform GHSA advisory and the merged regression tests document the exact forging technique (forgeUnsignedToken producing a header.payload. token with an empty signature), lowering the skill barrier considerably. Net: this is a genuinely serious bug (trivial to exploit where present, full identity forgery) but its blast radius is bounded by whether a given service uses the vulnerable configuration, not by attacker capability. Treat as high priority for teams that can confirm they use fast-jwt ≤6.3.0 with a falsy key plus an explicit allowlist; lower urgency otherwise. SSVC-style read: exploitation is 'none' observed, automatable is plausible once a vulnerable endpoint is found (token submission is scriptable), technical impact is total for the affected trust boundary.

Exploit ScenarioDerived

An attacker targets a Node.js/Fastify service using fast-jwt ≤6.3.0 whose createVerifier was configured with key '' or null and an explicit algorithms allowlist such as ['HS256']. They craft a JWT with a header matching an allowed algorithm and a payload containing arbitrary claims (e.g. {"sub":"admin","admin":true}) followed by an empty signature segment, then submit it to the application. No standalone public exploit is referenced, but the GHSA advisory and merged tests publish the exact unsigned-token forging method; the AV:N/AC:H/PR:N vector means the only real barrier is finding a service running the vulnerable configuration.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
1 public PoC 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 – Oct 08, 2026

Authentication and authorization bypass in fast-jwt 6.3.0 and earlier lets a remote, unauthenticated attacker submit a forged unsigned JWT containing arbitrary claims and have it accepted without possessing any signing key. The defect is reachable only when an application instantiates createVerifier with a falsy synchronous key (an empty string '' or null) while also supplying a non-empty algorithms allowlist such as ['HS256']; that combination causes prepareKeyOrSecret to be skipped, hasKey to evaluate false, and the empty signature segment of an unsigned token to bypass the verifySignature gate entirely. The issue is fixed in 6.3.1, and no public exploit code was identified at time of analysis - the primary real-world limiter is that the vulnerable configuration is non-default and developer-introduced, though once such a verifier exists no privileges or user interaction are required of the attacker.

RemediationAI

Vendor-released patch: upgrade fast-jwt to 6.3.1 (npm: fast-jwt@6.3.1), which adds a construction-time check that throws FAST_JWT_INVALID_KEY ('The key option is required unless the only allowed algorithm is "none"') whenever a falsy key is supplied without an allowlist restricted solely to 'none'. Apply the release at https://github.com/nearform/fast-jwt/releases/tag/v6.3.1, referencing the fix commit e22a151e83bf6d5e54e281216982d204d5665534 and PR https://github.com/nearform/fast-jwt/pull/649, and consult the advisory at https://github.com/nearform/fast-jwt/security/advisories/GHSA-8wpc-h4q6-8fxv. Where upgrading is not immediately possible, the most direct compensating control is configuration-level and side-effect-free: ensure every createVerifier call supplies a real, non-empty key (or omits the algorithms allowlist so that autodetection applies), since a non-empty key, a falsy key with no algorithms option, and the async key-resolver path are all unaffected - audit code and shared middleware libraries for literal key: '' / key: null combined with an algorithms array, and fail startup if found. If unsigned tokens must genuinely be supported, restrict the verifier to algorithms: ['none'] and be aware that this intentionally accepts unauthenticated claims and therefore must never back an authorization decision. On the library side, the patched release itself is the only reliable block; downgrading or pinning below 6.3.1 retains the bypass. Finally, note that claim validators (exp, nbf, aud, iss) still run on forged tokens, so tightening those constraints reduces but does not eliminate exposure, and any token already accepted prior to patching should be treated as potentially forged for session and authorization purposes.

Affected VersionsENISA

fast-jwt < 6.3.1

Affected Packages

npm fast-jwt fix: 6.3.1

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

fast-jwt is a Node.js JSON Web Token library from nearform; the affected artefact maps to cpe:2.3:a:nearform:fast-jwt:*:*:*:*:*:*:*:*. JWT verification normally requires a key (a shared secret for HS* algorithms, or a PEM-encoded public key for RS*/PS*/ES*/EdDSA) against which the token's signature is cryptographically validated. This issue falls under CWE-20 (Improper Input Validation) because the verifier fails to validate the key/algorithms configuration combination before trusting a token. Four cooperating code paths produce the bypass: (A) the type check in createVerifier accepts a string or object key, but the subsequent if (key && keyType !== 'function') guard never calls prepareKeyOrSecret when key is '' or null, so the empty-secret rejection inside that helper is unreachable for synchronous keys; (B) with a falsy key, algorithm autodetection is skipped and the caller-supplied algorithms list remains active in allowedAlgorithms, so a token header matching that list is accepted; (C) hasKey is computed as a truthiness test, so both the 'missing signature' and 'missing key' branches are skipped when neither key nor signature is present; and (D) the signature check is gated on signature being truthy, so an unsigned token (header.payload.) with an empty signature never reaches verifySignature. Per the GHSA, the behaviour is explicitly absent for non-empty keys, for falsy keys with no algorithms option, and for the asynchronous key-resolver (function/promise) path, and createSigner already rejects the same falsy keys - an asymmetry the 6.3.1 patch corrects by rejecting '' or null at construction time unless 'none' is the only allowed algorithm.

Know when Fast Jwt 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 (GitHub_M) PRIMARY 7.4 HIGH
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N
vuln.today AI 7.4 HIGH

AC:H because the flaw only triggers under a specific non-default verifier config (falsy key plus explicit algorithms allowlist); PR:N/UI:N since an attacker forges an unsigned token with no credentials, yielding full confidentiality and integrity bypass with no availability impact.

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

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
High
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
None

Lifecycle Timeline

2
Patch available
Oct 08, 2026 - 23:02 EUVD
CVE Published
Oct 08, 2026 - 21:44 cve.org
HIGH 7.4

DescriptionCVE.org

fast-jwt provides fast JSON Web Token (JWT) implementation. Prior to 6.3.1, fast-jwt createVerifier accepts an unsigned JWT when key is an empty string or null and algorithms is a non-empty allowlist. Falsy synchronous keys bypass prepareKeyOrSecret, allowedAlgorithms remains active, hasKey is false, and the empty signature avoids the verifySignature gate. An attacker can therefore submit a token containing arbitrary claims without possessing a signing key, resulting in authentication or authorization bypass. Claim validators still run, and non-empty keys, an empty key without algorithms, and the async key resolver path do not have this behavior. This issue is fixed in version 6.3.1.

Technical POC Analysis

CWE-20 (Improper Input Validation), with the advisory also listing CWE-347 (Improper Verification of Cryptographic Signature).

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Latest POC

1 public PoC link from github

Sign in to open the public PoC links collected for this CVE.

Executive ViewAI

Why It Matters

Applications built on the fast-jwt library version 6.3.0 and earlier can be made to accept forged, unsigned JSON Web Tokens, letting an attacker mint tokens with arbitrary identities and claims without holding any signing key. The flaw only manifests where developers constructed a verifier with an empty or null key alongside a non-empty algorithm allowlist, so exposure is confined to services carrying that specific non-default configuration, but any such service has its authentication and authorization trust model effectively nullified. Leadership should care because affected systems are the front door for user and service access, and the fix requires both a library upgrade and confirmation that no vulnerable verifier configuration remains in production.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 84% exploitable
Prevalence
Medium
popular Node.js JWT library (backs @fastify/jwt), not universally deployed
Threat Intel
1
1 sources
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA GitHub VulDB

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 HIGH
CISA KEV No
Public POC Yes
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

Attack Technique

Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.

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