/

CVE-2026-43912

Severity:

HIGH RISK

(8.7)

Improper Authorization in Vaultwarden Organization Group

CVE-2026-43912

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-285

Impact:

Cross-Organization Access Control Bypass and Data Compromise

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

Vaultwarden's organization group-management logic fails to verify that group membership and collection relationships belong to the same organization, allowing cross-organization reference abuse.

An attacker who is an admin in one organization and a low-privileged member in another can bind foreign membership and collection IDs into a privileged group and thereby read and modify vault data from the other organization.

Affected context

This vulnerability affects Vaultwarden instances that host multiple organizations where users can be members of more than one organization with different roles.

It arises in the server-side logic that manages:

  • Relationships between groups and users (groups_users.users_organizations_uuid)
  • Relationships between groups and collections (collections_groups.collections_uuid)

The issue manifests when API endpoints accept arbitrary MembershipId and CollectionId values and persist them without verifying that:

  • The membership belongs to the same organization as the target group, and
  • The collection belongs to the same organization as the target group.

Environments with cross-organization membership and at least one highly privileged group (e.g., accessAll=true) are particularly exposed.

Exploit preconditions

  • Attack surface: Vaultwarden HTTP API, specifically organization group-management endpoints that accept MembershipId and CollectionId parameters.
  • Required access:
  • Valid authenticated account on the instance.
  • Admin (or similarly privileged) role in Organization A, with ability to manage groups.
  • Any membership (even low-privileged) in Organization B on the same instance.
  • Trigger point:
  • Attacker submits group-management requests that bind:
  • A users_organizations_uuid from Org B into a group belonging to Org A, or
  • A collection UUID from Org B into a group belonging to Org A.
  • The server stores these relationships without verifying that the organizations match.
  • Why exploitation is possible:
  • The backend relies on client-supplied MembershipId and CollectionId values.
  • There is no server-side enforcement that the referenced membership and collection resources reside in the same organization as the group.
  • Group permissions (e.g., accessAll=true) are then evaluated over these inconsistent relationships, effectively extending Org A group rights into Org B.

Why this happens

The root cause is an authorization design flaw where relationship integrity between organization-scoped entities is not enforced by the server.

Group-management endpoints accept identifiers for memberships (users_organizations_uuid) and collections and directly persist these references without verifying:

  • That the membership's organization UUID equals the group's organization UUID.
  • That the collection's organization UUID equals the group's organization UUID.

This maps to CWE-285: Improper Authorization, where access control decisions are made on incomplete or inconsistent context, allowing a user to leverage permissions granted in one scope (Organization A admin) to influence resources in another scope (Organization B membership and collections).

Conceptually, the API trusts the caller to only reference IDs within the same organization, instead of deriving valid targets from the caller's actual organization context on the server.

Potential impact

  • Unauthorized enumeration of vault ciphers belonging to another organization.
  • Cross-organization read access to sensitive secrets, including passwords, keys, and secure notes.
  • Elevation of privileges within the second organization via manipulated group/collection relationships.
  • Unauthorized write access to another organization's items, enabling tampering, data deletion, or injection of malicious secrets.
  • Loss of data separation guarantees between organizations hosted on the same Vaultwarden instance.
  • Potential compliance and privacy violations due to cross-tenant data exposure.

General mitigation guidance

Effective mitigation centers on enforcing strict organization scoping and server-side authorization checks for all relationship updates:

  • Enforce organization consistency on the server:
  • When binding memberships to groups, derive the organization from the group and verify that the membership belongs to that same organization before persisting.
  • When binding collections to groups, ensure that the collection's organization matches the group's organization.
  • Treat identifiers as untrusted input:
  • Do not rely on client-supplied MembershipId or CollectionId alone; validate them against the authenticated user's accessible organizations and roles.
  • Reject any request that references resources outside the caller's organization scope.
  • Centralize authorization and scoping logic:
  • Implement reusable helpers or middleware to apply organization checks consistently across all group, membership, and collection APIs.
  • Base authorization decisions on server-side derived context (current user, organization, and role) instead of trusting cross-organization IDs.
  • Harden multi-tenant separation:
  • Model organizations as strict isolation boundaries in the data layer and API design.
  • Avoid patterns where a single identifier can be meaningfully reused across organizations without explicit scope validation.
  • Apply least privilege within organizations:
  • Limit group capabilities like accessAll to only necessary admin groups.
  • Use more granular collection-based permissions to reduce the impact if a single group is misconfigured.

How teams detect issues like this

Detecting and monitoring this class of issue generally involves a combination of code-level and runtime checks:

  • Static analysis and code review:
  • Look for handlers where:
  • Group, membership, and collection IDs are accepted from the client.
  • Relationships between organization-scoped entities are created or updated.
  • Flag any path where the organization of the membership or collection is not explicitly checked against the organization of the group or against the caller's current organization context.
  • Ensure that helper functions enforcing organization consistency are used in all relevant endpoints.
  • Authorization policy validation:
  • Define explicit security requirements (e.g., "any cross-entity association must verify matching organization IDs") and encode these as unit and integration tests.
  • Use regression tests that simulate multi-organization scenarios with shared users and verify that no cross-org binding is accepted.
  • Runtime monitoring and logging:
  • Log all group-management operations with:
  • Calling user, their organizations and roles.
  • Target group organization.
  • Target membership and collection organizations.
  • Alert on suspicious patterns, such as:
  • A single user frequently binding memberships or collections from multiple organizations.
  • Group updates that associate resources with differing organization IDs.
  • Automated security tooling:
  • Incorporate application security testing tools (SAST/DAST) into CI pipelines to flag missing authorization checks and cross-tenant ID usage patterns.
  • Periodically run multi-tenant security tests that attempt to cross-bind IDs between organizations.

Sources

SourceLink
github.comgithub.com/dani-garcia/vaultwarden/security/advisories/GHSA-569v-845w-g82p

Frequently asked

questions

Exploitation requires a user account that participates in at least two organizations on the same instance, with admin-level rights in one organization and any membership in another.

Within such a configuration, the attacker can abuse the flawed group-management APIs to cross-link memberships and collections and gain unauthorized access.

The attacker needs sufficient privileges to manage groups in at least one organization (e.g., an admin role in Organization A).

In the target organization (Organization B), only a low-privileged membership is required; the flaw then lets the attacker extend their higher privileges into Org B's data.

Implement strict server-side checks that:

  • Derive the organization from the group being modified.
  • Validate that any referenced membership or collection belongs to the same organization.
  • Reject any operation where organization IDs do not match, regardless of what the client sends.

Centralizing this logic in shared authorization helpers helps ensure consistency.

Design organization and tenant boundaries as first-class security constraints:

  • Treat all client-supplied identifiers as untrusted and always scope them by the authenticated user's organization.
  • Enforce organization consistency when linking entities, preferably via shared abstractions and tests.
  • Add multi-tenant security tests and code review checklists that explicitly examine cross-organization relationships and access control decisions.
Find out what's already
exploitable in your codebase.