/

CVE-2026-60104

Severity:

HIGH RISK

(8.7)

Improper Access Control (CWE-639) in Bitwarden Server

CVE-2026-60104

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-639

Impact:

Account Takeover and Vault Key Disclosure

Severity:

HIGH RISK

(8.7)

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

Bitwarden Server fails to verify that the email in the /auth-requests/admin-request body matches the authenticated caller, enabling a low-privileged member to initiate a Trusted Device Encryption request for another user.

Once this request is approved, the attacker can retrieve a victim-scoped access token and vault key from an unauthenticated endpoint, leading to potential account takeover and vault compromise.

Affected context

This vulnerability occurs in Bitwarden Server deployments where the /auth-requests/admin-request endpoint is exposed and used for Trusted Device Encryption workflows.

It manifests when server-side logic relies on request body fields (such as email) rather than the authenticated session identity to bind an authentication request to a user.

Environments with delegated administration or low-privileged organizational members that can initiate admin-style authentication requests are particularly exposed.

Exploit preconditions

  • Attack surface: HTTP API endpoint POST /auth-requests/admin-request
  • Required access: Authenticated low-privileged membership in the organization; ability to submit admin-request payloads
  • Trigger point: Creation of a Trusted Device Encryption authentication request using another user's email and an attacker-controlled public key
  • Why exploitation is possible: The server does not enforce that the email in the request body belongs to the authenticated caller, allowing cross-user binding of authentication requests and exposure of victim-scoped artifacts via an unauthenticated endpoint once approved

Why this happens

The underlying issue is an authorization design flaw where identity binding is based on user-supplied data rather than the authenticated principal.

In terms of CWE-639: Authorization Bypass Through User-Controlled Key, the application trusts a user-provided identifier (email) to determine which account an authentication request is associated with, without verifying that the requester is the rightful owner of that identifier.

This mismatch between authentication (who is logged in) and authorization (which account is being operated on) allows a low-privileged user to orchestrate actions on behalf of another account.

Potential impact

  • Disclosure of a victim's vault encryption key
  • Acquisition of a victim-scoped access token
  • Full account takeover of the targeted Bitwarden user
  • Unauthorized decryption and access to stored vault secrets
  • Potential lateral movement to other services where credentials were reused

General mitigation guidance

Effective mitigation focuses on strict server-side authorization and identity binding for all account-specific operations.

Common defensive patterns include:

  • Deriving the target user identity from the authenticated session or token, not from client-supplied email or IDs
  • Enforcing that any operation which creates or binds authentication or encryption artifacts is scoped to the logged-in principal by default
  • Applying explicit authorization checks for cross-account or administrative actions, with well-defined roles and permissions
  • Minimizing unauthenticated exposure of sensitive artifacts, even after approval, by requiring proof of ownership or strong authentication
  • Designing APIs to avoid user-controlled keys as the sole basis for access control decisions

How teams detect issues like this

Organizations can detect similar authorization issues through:

  • Static analysis rules that flag use of user-controlled identifiers (emails, IDs) as access control keys without cross-checking against the authenticated principal
  • Code reviews that scrutinize API endpoints handling account selection, admin-style requests, or authentication workflows for cross-user access patterns
  • Security-focused integration tests that attempt to perform actions on one account while logged in as a different low-privileged user
  • Policy enforcement in CI pipelines that requires explicit authorization checks for endpoints returning sensitive tokens, keys, or device-binding artifacts

Sources

SourceLink
github.comgithub.com/bitwarden/server/commit/dcf4c486b2b5bedecc03a48b427243328cc74a9a
github.comgithub.com/bitwarden/server/pull/7615
github.comgithub.com/bitwarden/server/releases#release-v2026.6.0
sanjokkarki.com.npsanjokkarki.com.np/blog/bitwarden-vault-key-heist
vulncheck.comvulncheck.com/advisories/bitwarden-server-authorization-bypass-via-admin-auth-request

Frequently asked

questions

Exploitation is limited to environments where an attacker has a low-privileged organizational account and can submit admin-request payloads. Within that scope, they may target other users in the same organization, assuming the workflow is used and approvals occur.

The attacker must be an authenticated member of the Bitwarden organization with sufficient rights to create Trusted Device Encryption authentication requests. They do not need direct administrative privileges on the victim account, and retrieval of the resulting artifacts occurs via an unauthenticated endpoint.

The most robust fix is to bind all account operations, including authentication and device-enrollment requests, to the authenticated principal as determined by the server, ignoring or strictly validating any client-provided identifiers. Cross-account operations should require explicit, role-based authorization.

Preventing these issues requires consistent application of secure-by-default access control patterns: avoid user-controlled keys in authorization logic, always derive identity from trusted authentication mechanisms, add negative tests for cross-account actions, and incorporate access control reviews and automated checks into the development lifecycle.

Find out what's already
exploitable in your codebase.