/

CVE-2026-45108

Severity:

HIGH RISK

(8.4)

Authorization Bypass / Improper Authorization

CVE-2026-45108

Deferred

Vulnerability type

Category:

Authorization Bypass / Improper Authorization

CWE:

CWE-863

Impact:

Unauthorized Account Impersonation Within Domain

Severity:

HIGH RISK

(8.4)

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

Himmelblau's Device Authorization Grant (DAG) flow contained an authorization bypass where only the Entra ID domain was validated, allowing a user to obtain a local Unix session as another user in the same domain using their own valid credentials.

Because the implementation compared only domains and not full usernames, an authenticated user could impersonate another account on the Unix host under specific DAG-based login conditions.

Affected context

This issue affects Himmelblau deployments that:

  • Integrate Microsoft Azure Entra ID and Intune for identity and device management
  • Use the Device Authorization Grant (DAG) flow to provision or log into local Unix sessions
  • Rely on Himmelblau's token_validate logic to map Entra ID user principal names (UPNs) to Unix accounts

The vulnerability manifests in multi-domain or aliased-domain configurations where the system validates that the Entra ID domain is allowed, but does not ensure the full UPN (including the username/local part) matches the Unix account being requested.

Exploit preconditions

  • Attack surface: Authentication and login endpoints that implement the Himmelblau Device Authorization Grant flow.
  • Required access:
  • A valid Azure Entra ID account in the same domain or domain alias as the target user.
  • Ability to initiate a DAG-based login or session request through Himmelblau.
  • Trigger point:
  • The token_validate function during DAG processing, where the token's UPN is checked only for domain equivalence and not full username equality.
  • Why exploitation is possible:
  • Authorization decisions are based on partial identity comparison (domain-only) rather than a strict mapping between the authenticated user's full UPN and the Unix account name being requested, enabling a domain peer to be treated as another user.

Why this happens

The core defect is an improper authorization check in the token_validate logic, aligning with CWE-863.

Instead of verifying that the complete identity of the authenticated principal (full UPN, including the local part/username) matches the Unix account identity being accessed, the code only validated the domain portion to support legitimate multi-domain and alias scenarios.

This creates a flawed trust assumption: any correctly authenticated user from an allowed domain is implicitly authorized for any account in that domain, conflating authentication (who you are) with authorization (what you may access). The missing comparison of the full UPN to the requested Unix username is the abstract insecure pattern.

Potential impact

  • A domain user may obtain a local Unix shell as another user in the same Entra ID domain.
  • Attackers could access files, processes, and resources owned by the impersonated Unix account.
  • Lateral movement within servers or applications that rely on Unix user separation for security.
  • Potential exposure of sensitive configuration, credentials, or data associated with higher-privileged Unix accounts.
  • Disruption of audit trails and accountability due to incorrect user attribution in logs.

General mitigation guidance

Effective mitigation focuses on aligning authentication assertions with explicit authorization checks and avoiding partial identity comparison:

  • Ensure that authorization logic compares the full authenticated identity (e.g., full UPN or unique user ID) to the exact Unix account name or mapping, not just the domain portion.
  • Implement a robust identity mapping layer (e.g., UPN → Unix username) that is deterministic, centrally defined, and used consistently across all login flows.
  • Treat multi-domain and alias support as explicit configuration, with strict checks rather than broad domain-based acceptance.
  • Apply least-privilege principles by minimizing automatic account mappings and requiring explicit bindings for privileged or service accounts.
  • Introduce defense-in-depth checks on the Unix side (e.g., PAM modules, policy engines) to validate that the user identity asserted by Himmelblau matches the expected local account before granting a session.

How teams detect issues like this

Organizations can detect similar authorization issues using:

  • Static analysis and code review:
  • Look for authorization logic that relies on partial string comparisons of identities (e.g., only domains, suffixes, or prefixes) instead of full, canonical user identifiers.
  • Identify functions that both authenticate and authorize in a single step, especially where user-supplied parameters (requested account name) are not strictly bound to the authenticated principal.
  • Flag code paths where identity mapping to Unix accounts occurs without explicit equality checks on full UPN or unique IDs.
  • Security testing and auditing:
  • Perform negative tests where an authenticated user attempts to request a session as a different user in the same domain and verify denial.
  • Review authentication and authorization logs for anomalies, such as frequent logins where the asserted account differs from the authenticated UPN's local part.
  • Automated tooling and policy enforcement:
  • Use automated code review or SAST tools configured with rules for improper authorization and identity mapping patterns.
  • Implement CI/CD checks to enforce that any new auth-related code uses central, vetted authorization helpers rather than ad-hoc domain-based checks.

Sources

SourceLink
github.comgithub.com/himmelblau-idm/himmelblau/security/advisories/GHSA-pmxh-j4r6-88mv

Frequently asked

questions

Exploitation typically occurs remotely through the Himmelblau Device Authorization Grant flow. An attacker needs network access to the DAG endpoints but does not require prior local access to the Unix host; a valid Entra ID account in the same domain is the key prerequisite.

Not necessarily. A standard user account in the same Entra ID domain, with the ability to complete the DAG flow, may be sufficient. The weakness lies in how domain-based identity is mapped to Unix accounts, not in Entra ID privilege level.

Enforce strict binding between the authenticated principal and the target account by comparing a canonical, full identity attribute (such as full UPN or immutable user ID) to the requested Unix username. Avoid domain-only or partial string checks, and centralize this logic in well-reviewed authorization helpers.

Design authentication and authorization as separate, explicit steps: first establish who the user is using a trusted identity provider, then evaluate what they are allowed to access based on complete, canonical identifiers and policy. Use consistent identity mapping, perform thorough code reviews on auth flows, and add automated tests that ensure one account can never successfully request a session as a different user, even within the same domain.

Find out what's already
exploitable in your codebase.