/

CVE-2026-46414

Severity:

HIGH RISK

(8.8)

Authentication and Authorization Bypass in Microsoft UFO

CVE-2026-46414

Deferred

Vulnerability type

Category:

Authentication and Authorization Bypass

CWE:

CWE-290, CWE-639, CWE-862

Impact:

Authenticated Role Escalation and Cross-Device Task Hijacking

Severity:

HIGH RISK

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

Microsoft UFO's WebSocket control plane incorrectly trusts identity and role fields supplied inside task messages instead of enforcing the role bound to the underlying WebSocket session.

Any client holding the shared server token can spoof a higher-privilege constellation role, overwrite another client's registration, and dispatch attacker-controlled tasks to victim devices.

Affected context

This vulnerability affects deployments of the Microsoft UFO open-source framework where devices and controller components connect to a central WebSocket control plane using a shared server token.

The issue occurs in UFO versions around 3.0.1-4-ge2626659 when:

  • WebSocket clients self-identify their role (e.g., device vs. constellation) via message fields, and
  • The server accepts those in-message identity/role claims for authorization decisions instead of relying solely on the connection's established role and identity.

Environments with multiple devices and higher-privilege "constellation" orchestrators are most exposed, as any authenticated client can impersonate those orchestrators toward other devices.

Exploit preconditions

  • Attack surface: WebSocket control plane endpoint used by UFO devices and constellation nodes.
  • Required access:
  • Ability to establish an authenticated WebSocket connection using the shared server token.
  • Ability to send crafted TASK and registration messages over that connection.
  • Trigger points:
  • Sending a TASK message that claims client_type="constellation" and sets target_id to another active device's identifier.
  • Registering using a client_id that is already in use, causing the registry to overwrite the existing client's stored WebSocket, role, and task protocol.
  • Why exploitation is possible:
  • The server trusts identity and role fields from each wire message, rather than binding authorization decisions to the authenticated WebSocket session state.
  • The client registry does not prevent duplicate client_id registrations or treat them as suspicious, allowing one client to take over another client's logical identity.

Why this happens

The core issue is a mismatch between authentication and authorization boundaries.

Instead of treating the WebSocket connection as the authoritative identity/role anchor, the control plane reads client_type, target_id, and related identity fields from every incoming task message and uses them directly for authorization and routing.

This pattern aligns with CWE-290 (Authentication Bypass by Spoofing) and CWE-639 (Authorization Bypass Through User-Controlled Key): security-critical attributes (role, target identity) are accepted from untrusted client input without binding them to the authenticated context.

Additionally, the ability to re-register an existing client_id without conflict checks reflects missing authorization and state integrity controls, consistent with CWE-862 (Missing Authorization) when mutating registry entries that represent other live clients.

Abstractly, the bug is "trusting client-supplied identity/role metadata per message instead of enforcing a server-side session model and uniqueness constraints for identities."

Potential impact

  • An authenticated but low-privilege device client may spoof the high-privilege constellation role.
  • Attackers can dispatch arbitrary tasks or workflows to other connected devices by setting target_id to a victim's identifier.
  • Existing active clients can have their registry entries overwritten, causing their WebSocket, role, and task protocol to be hijacked.
  • Compromised or malicious clients can orchestrate cross-device abuse, such as coordinated misconfiguration, data manipulation, or denial of service actions.
  • Downstream automation flows that trust constellation-issued tasks may execute attacker-controlled actions on edge devices or services.

General mitigation guidance

Administrators and developers can reduce risk by restructuring trust boundaries and authorization flows:

  • Bind identity and role to the WebSocket session: Treat authentication as establishing a fixed identity/role for the lifetime of the connection; do not accept role changes or identity claims from normal task messages.
  • Ignore client-supplied role fields for authorization: Server-side logic should compute the effective role from the authenticated connection context, not from wire-level client_type or similar fields.
  • Enforce strict identity uniqueness and ownership: Ensure client_id values are unique per active session; prevent one client from overwriting another's registry entry without explicit, authenticated ownership checks.
  • Introduce explicit re-authentication for role changes: If role upgrades or mode changes are required, gate them behind dedicated, strongly authenticated flows and additional policy checks rather than ad-hoc message fields.
  • Apply least-privilege design to control-plane tokens: Avoid shared tokens where possible; use per-device or per-role credentials to limit blast radius if a client is compromised.
  • Harden protocol semantics: Design task and control messages so that sensitive routing attributes (e.g., source role, allowed targets) are derived server-side and minimally influenced by client-controlled data.

How teams detect issues like this

Teams can look for this vulnerability pattern and its symptoms through a mix of code- and behavior-based approaches:

  • Code review and design inspection:
  • Identify places where authorization decisions depend on message fields like client_type, role, target_id, or client_id instead of authenticated session state.
  • Flag registry operations that update or replace client entries without verifying ownership or connection identity.
  • Static analysis rules:
  • Create rules that detect uses of user-controlled identity or role parameters in authorization checks or routing logic.
  • Scan for control-plane handlers that accept arbitrary client_id rebinding without corresponding authorization checks.
  • Runtime monitoring and logging:
  • Log role claims and target identifiers from TASK messages, correlating them with the authenticated connection's known role and identity.
  • Alert on inconsistencies, such as a device-registered connection sending messages marked as constellation, or frequent re-registrations of the same client_id from different origins.
  • Security testing and fuzzing:
  • Exercise the WebSocket control plane with crafted messages that manipulate identity and role fields to validate that the server rejects unauthorized role escalation and client identity collisions.
  • Automated policy enforcement:
  • Integrate CI/CD checks that require explicit mapping from authentication layer (tokens, certificates) to authorization decisions, and block changes that reintroduce message-level trust in identity fields.

Sources

SourceLink
github.comgithub.com/microsoft/UFO/security/advisories/GHSA-qgx6-cvhg-jw7p

Frequently asked

questions

Yes, but only by clients that can successfully authenticate to the WebSocket control plane. Once a client has the shared server token and can open a WebSocket connection, they can exploit the role spoofing and identity overwriting behavior remotely.

The attacker needs the same level of access as a normal UFO device or client: the ability to authenticate using the shared server token and maintain a WebSocket connection to the control plane. No additional special privileges are required to attempt role spoofing or client hijacking.

The most robust fix is to bind identity and role to the authenticated WebSocket session and derive all authorization decisions from that server-managed state. Role and identity fields in individual messages should be treated as untrusted hints at most and never used as the source of truth. Additionally, enforce unique client identities and proper authorization when modifying the client registry.

Future designs should follow a few principles:

  • Use the authentication layer (tokens, certificates, or other credentials) as the sole authority for identity and role, not message payloads.
  • Ensure that any lookup keys or identifiers supplied by clients (such as client_id or target_id) are validated against the authenticated identity and relevant authorization rules.
  • Incorporate security-focused design reviews and automated checks to catch patterns where user-controlled fields influence authorization logic or session ownership.
  • Prefer per-entity credentials and least-privilege roles to minimize the fallout from a single client compromise.
Find out what's already
exploitable in your codebase.