/

CVE-2026-33175

Severity:

HIGH RISK

(8.8)

Authentication Bypass in OAuthenticator for JupyterHub

CVE-2026-33175

Analyzed

Vulnerability type

Category:

Authentication Bypass

CWE:

CWE-287, CWE-290

Impact:

Account Takeover / Unauthorized JupyterHub Access

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

An authentication bypass in OAuthenticator allows users with unverified email addresses in an Auth0 tenant to log in to JupyterHub when email is configured as the username claim.

Because the email claim is not properly constrained or verified, attackers may gain control over JupyterHub usernames and potentially take over existing accounts under certain configurations.

Affected context

This vulnerability affects JupyterHub deployments that integrate with OAuth2 identity providers via OAuthenticator and specifically:

  • Use Auth0 as an identity provider (or similar behavior with username derived from email),
  • Configure email as the username_claim,
  • Rely on the username derived from the IdP claim for account binding and authorization.

In such setups, email verification state is not adequately enforced in the authentication flow, making it possible for accounts with unverified emails to gain access and potentially map to existing JupyterHub usernames.

Exploit preconditions

  • Attack surface: JupyterHub login endpoint exposed via OAuthenticator using Auth0 (or a compatible IdP configuration).
  • Required access: Ability to create or control an Auth0 user account with an unverified email address on the relevant tenant.
  • Trigger point: Initiating an OAuth2 login flow to JupyterHub where the email claim is used as username_claim.
  • Why exploitation is possible: OAuthenticator trusts the email claim for username derivation without ensuring that the email address is verified and appropriately constrained, allowing an attacker to influence or collide with existing usernames.

Why this happens

The underlying issue is improper authentication and identity binding logic, aligned with:

  • CWE-287: Improper Authentication – The system accepts authentication assertions (email-based usernames) without sufficiently validating the associated identity (email verification status).
  • CWE-290: Authentication Bypass by Spoofing – By controlling an unverified email claim, an attacker can effectively spoof the username identity used by JupyterHub.

Conceptually, the design couples JupyterHub account identity directly to a claim from the OAuth2 IdP while failing to enforce that this claim represents a verified, trusted identifier. This weak binding allows unverified or attacker-controlled claims to be treated as valid usernames.

Potential impact

  • Unauthorized login to JupyterHub using accounts with unverified email addresses.
  • Potential takeover of existing JupyterHub user accounts if an attacker can choose an email matching an existing username, depending on configuration.
  • Escalation to access notebooks, data, and computational resources associated with compromised JupyterHub users.
  • Indirect access to connected data stores, APIs, or infrastructure reachable from the compromised JupyterHub environment.

General mitigation guidance

Effective mitigation focuses on strengthening identity binding and minimizing trust in unverified claims:

  • Prefer stable, non-user-controlled identifiers (e.g., subject/sub or a unique user ID) as the primary username_claim instead of email.
  • Ensure that only verified email addresses are considered for authentication and mapping to local usernames when email must be used.
  • Implement configuration and policy that explicitly rejects authentication attempts where the relevant claim is unverified or missing.
  • Avoid allowing users to influence their identities in ways that can collide with existing accounts (e.g., self-selected emails or aliases used as usernames).
  • Enforce least-privilege in JupyterHub roles and resource access so that compromise of a single account has limited blast radius.

How teams detect issues like this

High-level detection approaches include:

  • Configuration review: Examine OAuthenticator and IdP (Auth0) settings to identify use of email as the username_claim and determine whether verification checks are enforced.
  • Code review signals: Look for authentication flows that:
  • Directly map usernames from IdP email claims without verifying verification status,
  • Do not distinguish between verified and unverified claims in authorization logic.
  • Static analysis/policy checks: Use automated checks or policy-as-code to flag:
  • Any configuration that treats email as the primary identity key without verification requirements,
  • Authentication code paths that accept unverified claims.
  • Runtime monitoring: Monitor authentication logs for:
  • Logins from accounts with unverified emails (as indicated by IdP claims),
  • Sudden creation or takeover of usernames that previously belonged to other users.

Sources

SourceLink
github.comgithub.com/jupyterhub/oauthenticator/commit/f0c7002dc36e41efae0f674033cf7888a21d96f9
github.comgithub.com/jupyterhub/oauthenticator/releases/tag/17.4.0
github.comgithub.com/jupyterhub/oauthenticator/security/advisories/GHSA-rrvg-cxh4-qhrv

Frequently asked

questions

Yes. An attacker can exploit it remotely by interacting with the JupyterHub login endpoint, provided they can create or control an Auth0 account on the relevant tenant with an unverified email.

The attacker needs the ability to register or manage a user account on the affected Auth0 tenant and reach the JupyterHub instance's OAuth2 login. No prior access to JupyterHub itself is required.

The most robust fix is to bind JupyterHub identities to stable, provider-assigned identifiers (such as sub or a unique user ID) and enforce that any email-based claims used in authorization are verified and non-spoofable.

Treat identity provider claims as untrusted until explicitly validated. Use verification flags (e.g., email verified), avoid user-controllable claims as primary keys, enforce strict identity-binding policies in configuration and code review, and incorporate these checks into automated security testing pipelines.

Find out what's already
exploitable in your codebase.