/

CVE-2026-53981

Severity:

HIGH RISK

(7.6)

Missing Re-Authentication (CWE-306) in Cap-go Email Change

CVE-2026-53981

Deferred

Vulnerability type

Category:

Authentication and Session Management

CWE:

CWE-306

Impact:

Account Takeover

Severity:

HIGH RISK

(7.6)

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

Cap-go contains an account takeover vulnerability in its email change workflow where users can change the registered email address without re-authenticating.

An attacker with temporary access to an authenticated session can redirect verification to their own email and then reset the password, leading to permanent account compromise.

Affected context

This vulnerability arises in Cap-go's account management and profile settings flows, specifically the email change mechanism.

It is relevant when an attacker gains temporary, legitimate access to a user's authenticated session (for example, via shared devices, stolen sessions, or unattended logged-in browsers).

In such situations, the system allows the registered email address to be modified without requiring the user to re-enter their password, provide MFA, or perform any strong re-authentication step.

Exploit preconditions

  • Attack surface: Web or mobile account settings interface where users update their email address.
  • Required access: A valid, active authenticated session for the victim's account (e.g., hijacked session, physical access to logged-in device, or shared device).
  • Trigger point: Initiating the email change action and providing an attacker-controlled email as the new address.
  • Why exploitation is possible: The system does not enforce re-authentication (password, MFA, or equivalent verification) before applying the email change, treating a previously authenticated session as sufficiently trusted for high-impact account changes.

Why this happens

The core issue is the absence of enforced re-authentication for sensitive operations, mapped to CWE-306: Missing Authentication for Critical Function.

Changing a primary email address is a high-value action because the email often acts as an identity anchor and recovery channel; however, Cap-go's workflow treats it like a routine profile update.

By not requiring the user to reconfirm credentials or step-up authentication, the application assumes that possession of an active session is equivalent to ongoing user consent, enabling privilege-sensitive state changes without adequate verification.

Potential impact

  • An attacker with temporary session access may permanently take over the victim's account.
  • The attacker could redirect all account recovery communications (such as password reset emails) to their own email address.
  • The legitimate user can be locked out of their account or have great difficulty regaining control.
  • Compromise of any data, features, or connected services accessible through the Cap-go account.

General mitigation guidance

Mitigation typically focuses on enforcing strong authentication boundaries for sensitive profile and security operations.

Recommended control patterns include:

  • Requiring step-up authentication (password re-entry, WebAuthn, or MFA) before email changes, password changes, and other critical account modifications.
  • Treating the primary email address as a security-sensitive attribute, not just profile metadata, and applying stricter update policies.
  • Implementing short-lived session elevation tokens that are required to perform high-risk actions and expire quickly.
  • Sending out-of-band notifications to the old email address when changes occur, with a protected channel to report or revert unauthorized modifications.
  • Applying the principle of least privilege to session scopes, limiting what a long-lived or low-assurance session is allowed to modify.

How teams detect issues like this

Detection revolves around identifying weak or missing authentication checks around sensitive operations.

Common approaches include:

  • Static analysis and code review: Search for account update endpoints (e.g., email or password changes) that do not invoke authentication or authorization middleware beyond generic session checks.
  • Security requirements tracing: Ensure that all flows tagged as "security-sensitive" (account recovery, credential changes, MFA management) explicitly reference a re-authentication or step-up control in design documents and tests.
  • Behavioral and audit logging: Log all email changes along with session identifiers, IP addresses, device fingerprints, and whether step-up authentication was performed; monitor for patterns such as many email changes without corresponding verification events.
  • Automated test policies: Implement security test cases that simulate actions from a stale but valid session and confirm that high-impact account operations require additional verification.

Sources

SourceLink
github.comgithub.com/Cap-go/capgo/commit/6685e5f11adef257bf3d085e481f4d8ebcec602e
github.comgithub.com/Cap-go/capgo/security/advisories/GHSA-w56g-jv78-hf79
vulncheck.comvulncheck.com/advisories/cap-go-account-takeover-via-unauthenticated-email-change-mechanism

Frequently asked

questions

Yes. An attacker who can obtain or hijack a valid authenticated session (for example, via phishing, stolen tokens, or physical access to a logged-in device) can exploit this issue remotely through the normal application interface.

The attacker needs an active authenticated session for the victim's account. They do not need the victim's password or MFA secrets if the session is already established and the email change operation does not require re-authentication.

The most robust fix is to mandate step-up authentication for all critical account operations, especially changes to the primary email address, password, and MFA settings. This typically means prompting for a password, strong second factor, or WebAuthn assertion right before applying these changes.

Define a clear catalog of sensitive operations in your application and enforce a consistent re-authentication policy around them. Combine this with threat modeling during design, security requirements in user story definitions, and automated tests that verify high-risk actions cannot be performed using only a long-lived or low-assurance session.

Find out what's already
exploitable in your codebase.