/

CVE-2026-54460

Severity:

CRITICAL RISK

(9.8)

Missing Authentication (CWE-306) in OpenReception Passkeys

CVE-2026-54460

Deferred

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Account Takeover and Privilege Escalation

Severity:

CRITICAL RISK

(9.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

OpenReception's passkey enrollment endpoint accepts a user identifier and attacker-controlled credential without requiring an authenticated session or verifying that enrollment belongs to the current user. An unauthenticated attacker who can identify a tenant and target staff account may inject a passkey, authenticate as that account, and gain access to tenant-scoped administrative capabilities.

Affected context

The issue affects OpenReception deployments using the vulnerable passkey enrollment flow before the security fix. Risk exists when the public booking bootstrap and staff-related public key information expose enough tenant and user identifiers for an unauthenticated party to target accounts, while the enrollment endpoint accepts credentials without session binding or WebAuthn registration verification.

Exploit preconditions

  • Attack surface: Public HTTP authentication, passkey enrollment, and tenant booking endpoints
  • Required access: No authenticated session; knowledge of a public tenant identifier and a target staff email may be sufficient
  • Trigger point: Submission of a passkey enrollment request followed by the normal passkey login flow
  • Why exploitation is possible: The enrollment operation accepts attacker-controlled credentials for a supplied user identifier without authenticating the requester or binding enrollment to the current user
  • Scope limitation: The described tenant-scoped path can reach staff and tenant-administrator accounts, while global-administrator accounts are not necessarily exposed through the same route

Why this happens

The underlying flaw is an authentication-boundary failure mapped to CWE-306: Missing Authentication for Critical Function. A sensitive passkey enrollment operation trusts a request-body user identifier and stores a credential without requiring an authenticated session, performing registration verification, or confirming that the identifier belongs to the authenticated principal. This insecure pattern permits an unauthenticated party to create an authentication factor for another account and subsequently use the normal login process as that account.

Potential impact

  • An attacker may obtain a valid staff session
  • Tenant data may be exposed or modified
  • Tenant-administrator accounts may be targeted for further takeover
  • Appointment resources and key shares could be altered or deleted
  • Encrypted appointment data could become permanently undecryptable
  • Booking services may be disrupted or taken offline
  • Additional tenant compromise or lateral movement could occur within the application's authorization scope

General mitigation guidance

Mitigation generally requires treating passkey enrollment as a privileged, authenticated account-management operation.

Common defensive patterns include:

  • Require an authenticated session before adding or replacing a passkey
  • Bind the enrollment target to the authenticated session identity rather than trusting a request-body user identifier
  • Invoke complete WebAuthn registration verification, including challenge, origin, RP ID, and attestation-policy checks as appropriate
  • Require explicit user presence or a separate verified recovery workflow for additional credentials
  • Apply authorization checks before any credential is stored
  • Minimize disclosure of user identifiers and public account metadata through unauthenticated endpoints
  • Enforce least privilege for staff and tenant-administrator sessions
  • Use secure recovery and credential-revocation procedures for suspected account compromise

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis and code review rules that flag credential-enrollment handlers accepting user IDs from request bodies
  • Checks that passkey registration invokes WebAuthn verification before persistence
  • Review signals showing account-management actions without authentication or authorization middleware
  • Tests attempting credential enrollment while unauthenticated or while targeting another account
  • Monitoring for unexpected passkey additions, repeated enrollment attempts, and immediate login from newly registered credentials
  • API policy enforcement requiring authenticated identity binding for credential-management endpoints
  • Automated security review tools that identify missing authentication checks and confused-deputy patterns

Sources

SourceLink
github.comgithub.com/open-reception/appointment-booking-software/commit/5d29d9c1964ef7541a6e96d04d946c22f76eea00
github.comgithub.com/open-reception/appointment-booking-software/commit/93040884b783573dbf161723e508676327fdf0bf
github.comgithub.com/open-reception/appointment-booking-software/releases/tag/v1.1.1
github.comgithub.com/open-reception/appointment-booking-software/security/advisories/GHSA-g233-m625-m3pc
github.comgithub.com/user-attachments/files/28600800/MS-OPENRECEPTION-cc76da-poc.zip

Frequently asked

questions

Yes. The described attack uses publicly reachable HTTP endpoints and does not require an authenticated session, although the attacker must know or discover suitable tenant and account identifiers.

The attacker generally needs a public tenant ID, a target staff email, and access to the exposed booking and authentication endpoints. Server, database, or administrative access is not required for the initial attack path.

Require authentication and authorization for passkey enrollment, bind the target account to the authenticated session, and complete WebAuthn registration verification before storing any credential.

Treat credential enrollment and recovery as sensitive account-management functions, test them across identity boundaries, minimize public identifier disclosure, and monitor for unexpected credential changes.

Find out what's already
exploitable in your codebase.