/

CVE-2026-55075

Severity:

HIGH RISK

(7.4)

OIDC Auth Flaws (CWE-287) in Coder Login Flow

CVE-2026-55075

Analyzed

Vulnerability type

Category:

Authentication and Identity Management

CWE:

CWE-287, CWE-289

Impact:

Account Takeover

Severity:

HIGH RISK

(7.4)

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

Coder's OIDC login flow contained two authentication logic flaws that could be chained into full account takeover.

Under certain identity provider configurations, attackers could abuse email-based account linking and misinterpreted email_verified claims to gain access to existing user accounts.

Affected context

This vulnerability affects deployments of Coder that use OpenID Connect (OIDC) for user authentication and account linking.

It is most relevant where:

  • Coder relies on email address matching for linking identities.
  • The IdP allows self-registration or issues tokens without strictly enforced email verification.
  • email_verified claims may be missing, incorrectly typed, or loosely validated.

In such environments, the flawed logic around account linking and email verification can be abused to bind an attacker-controlled identity to an existing Coder account.

Exploit preconditions

  • Attack surface: Coder web application OIDC login and account linking endpoints.
  • Required access: Ability to authenticate via the configured OIDC provider using an email address that matches a target user's email, or to register such an account if self-signup is permitted.
  • Trigger point: Initiation of the OIDC login flow, where Coder processes the IdP token, evaluates email_verified, and performs email-based account matching and linking.
  • Why exploitation is possible: The application:
  • Falls back to linking accounts purely by email without confirming that the existing account is already linked to a different IdP subject.
  • Treats the email_verified claim as verified when it is absent or not a boolean, effectively bypassing email verification checks.

Why this happens

The underlying issue stems from flawed authentication and identity-linking logic, aligning with CWE-287 (Improper Authentication) and CWE-289 (Authentication Bypass by Alternate Name).

Coder's OIDC integration trusted email-based identity matching as a fallback without enforcing uniqueness of the IdP subject for existing accounts, allowing an alternate identity to attach to a known email.

Additionally, the handling of the email_verified claim did not follow a secure default: only an explicit boolean false was treated as unverified, while missing or malformed claims were implicitly treated as verified.

Together, these patterns undermine the assurance that a logged-in OIDC user is the legitimate owner of the corresponding Coder account.

Potential impact

  • Attackers may take over existing Coder user accounts if they control or can register an email matching the victim's address.
  • Compromise of remote development environments, including access to source code, credentials, and infrastructure Terraform templates.
  • Escalation to administrative control within Coder if a privileged account is targeted.
  • Lateral movement into connected systems or CI/CD pipelines configured within compromised environments.

General mitigation guidance

Effective mitigation focuses on hardening identity linking and enforcing strict verification of authentication claims:

  • Avoid using email-only matching as a primary linking mechanism; bind accounts to stable, unique IdP subject identifiers and enforce one-to-one relationships.
  • Apply secure defaults for claims such as email_verified: treat missing, malformed, or unexpected types as unverified and require explicit positive confirmation.
  • Require strong assurance from the OIDC provider, including mandatory email verification before token issuance and disabling anonymous or self-service registration where feasible.
  • Implement defense-in-depth controls such as step-up authentication or secondary confirmation before linking new identities to existing accounts.
  • Limit the privileges granted to newly linked accounts and monitor account-linking operations more tightly than standard logins.

How teams detect issues like this

Detection can rely on a combination of configuration review, code analysis, and runtime monitoring:

  • Use code review or static analysis to locate authentication flows that rely on email-based linking, weak claim validation, or ambiguous handling of email_verified and similar trust signals.
  • Define internal patterns that flag any fallback matching logic that does not check existing IdP subjects or that treats missing claims as implicitly trusted.
  • Review OIDC provider and application configuration to ensure email verification requirements and registration policies conform to organizational security standards.
  • Monitor authentication and account-linking logs for suspicious patterns, such as frequent linking attempts, multiple identities bound to a single email, or new IdP subjects appearing for established accounts.
  • Automated security testing tools can be configured to exercise OIDC flows with malformed or missing claims to catch insecure defaults early in CI pipelines.

Sources

SourceLink
github.comgithub.com/coder/coder/pull/25712
github.comgithub.com/coder/coder/pull/25713
github.comgithub.com/coder/coder/releases/tag/v2.29.17
github.comgithub.com/coder/coder/releases/tag/v2.32.7
github.comgithub.com/coder/coder/releases/tag/v2.33.8
github.comgithub.com/coder/coder/releases/tag/v2.34.2
github.comgithub.com/coder/coder/security/advisories/GHSA-9r87-mvcw-x35f

Frequently asked

questions

Exploitability depends on the OIDC provider and deployment configuration. If attackers can create or control an identity with the same email as a legitimate user and email verification is loosely enforced, they may be able to take over accounts via the flawed linking logic.

An attacker must be able to authenticate against the configured OIDC provider, typically by registering or controlling an account that uses the target user's email address. Direct access to the Coder infrastructure is not required; they only need access to the login flow.

Enforce strict binding between Coder accounts and unique IdP subjects, avoid email-based fallback linking for existing accounts, and treat email_verified and similar claims using secure defaults where missing or malformed values are considered untrusted until explicitly verified.

Adopt a design framework that treats authentication claims as untrusted until validated, uses unique subject identifiers instead of mutable attributes such as email for core linking, and includes security-focused reviews of all federation and SSO logic, backed by tests that cover claim edge cases and alternate identity scenarios.

Find out what's already
exploitable in your codebase.