/

CVE-2026-48064

Severity:

HIGH RISK

(8.1)

Authorization Logic Error in pam_usb Remote Session Handling

CVE-2026-48064

Deferred

Vulnerability type

Category:

Authorization Logic Error

CWE:

CWE-863

Impact:

Bypass of Remote Access Restrictions

Severity:

HIGH RISK

(8.1)

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

A logic flaw in pam_usb's remote-host handling allows genuine remote sessions (such as XDMCP clients) to reach the USB device authentication step when deny_remote is set to false.

Under these conditions, remote logins that should be rejected based on PAM_RHOST may instead be treated like local sessions, weakening the intended remote access controls around USB-based authentication.

Affected context

This vulnerability appears in Linux systems that:

  • Use pam_usb for hardware-backed authentication with removable media, and
  • Configure a PAM service (e.g., display managers like gdm-password or lightdm) with deny_remote=false, and
  • Accept remote connections via mechanisms that set PAM_RHOST (such as XDMCP servers or other remote display daemons)

In this configuration, the PAM stack may treat some remote sessions as eligible for USB-based authentication instead of enforcing a strict "no-remote" policy.

Exploit preconditions

  • Attack surface: Remote login interfaces that integrate with PAM and set PAM_RHOST (e.g., XDMCP-enabled display managers or similar remote display services).
  • Required access: Ability to initiate a remote connection to the affected service (network reachability to the display/login endpoint).
  • Trigger point: A remote session is started while the target PAM service is configured with pam_usb and deny_remote=false.
  • Why exploitation is possible: The authorization check that should reject remote sessions is guarded by the opts.deny_remote flag. When that flag is false, the PAM_RHOST-based decision is never evaluated, so remote connections can progress into USB device authentication instead of being blocked outright.

Why this happens

The underlying issue is an incorrect authorization decision flow that conflates heuristic-bypassing behavior with remote-host rejection.

In pam_usb's pusb_do_auth(), the check that inspects PAM_RHOST to identify and deny remote sessions is placed inside a conditional branch executed only when opts.deny_remote is true.

As a result, setting deny_remote=false not only relaxes local/TTY heuristics (the intended effect) but also unintentionally disables the remote-host rejection logic.

This matches CWE-863: Incorrect Authorization, where checks for whether an action is allowed are either incomplete or skipped in certain configurations, allowing access in contexts that were meant to be denied.

Potential impact

  • Remote XDMCP or similar sessions may be treated as if they were local, reaching USB-based authentication instead of being rejected.
  • Remote users could attempt to satisfy USB authentication requirements from locations or environments where such access was not intended.
  • Network exposure of what was assumed to be a "local-only" authentication factor, increasing the attack surface for brute-force or relay-style attacks against the USB authentication flow.
  • Undermining of policy assumptions that local, console-based sessions are the only ones allowed to use removable media as an authentication factor.

General mitigation guidance

Reducing risk from this class of authorization logic issues typically involves:

  • Separating policy flags: Distinguish between options that control local-heuristic bypass and those that control acceptance or rejection of remote sessions; avoid coupling multiple security decisions to a single flag.
  • Enforcing explicit remote checks: Ensure that remote-host validation based on PAM_RHOST or equivalent indicators runs independently of convenience or heuristic-bypass options.
  • Default-deny for remote contexts: Treat any session with a set remote host as untrusted by default, requiring explicit configuration to allow it.
  • Hardening PAM configurations: Review PAM service files for modules that may alter behavior based on ambiguous flags; clearly document which options affect authorization decisions.
  • Defense in depth: Combine pam_usb with additional factors (password, smart card, SSO) and restrict network exposure of remote display or login services to trusted networks only.

How teams detect issues like this

To detect and manage similar issues:

  • Configuration review: Periodically audit PAM configuration files, focusing on pam_usb usage and any services where deny_remote or analogous options are set to false.
  • Code-level analysis: Use static analysis or manual review to find authorization checks that are conditionally executed based on configuration flags, especially where PAM_RHOST or remote indicators are only checked under certain branches.
  • Policy-based testing: Include remote-session test cases in security regression tests to verify that remote connections are rejected or constrained as intended when hardware tokens are involved.
  • Logging and monitoring: Increase logging around PAM decisions that involve PAM_RHOST and pam_usb; monitor for patterns of unexpected remote attempts being processed through USB authentication.

Sources

SourceLink
github.comgithub.com/mcdope/pam_usb/issues/348
github.comgithub.com/mcdope/pam_usb/security/advisories/GHSA-w38v-cw9r-x9p6

Frequently asked

questions

Yes. If a service uses pam_usb with deny_remote=false and is reachable over the network via XDMCP or a similar mechanism that sets PAM_RHOST, a remote client can reach the USB authentication step instead of being rejected.

The attacker needs network access to an affected remote login or display service that uses pam_usb. They do not need prior authentication, but they do need to be able to initiate a remote session that passes through the PAM stack.

Ensure that remote-host checks (such as those based on PAM_RHOST) are always evaluated for sessions that originate remotely, regardless of options meant to relax local/TTY heuristics. Authorization logic should make remote vs. local decisions explicitly and independently of convenience flags.

When designing configuration-driven behavior, avoid overloading single options with multiple security implications. Model authorization decisions explicitly in code, add regression tests for both local and remote scenarios, and regularly review PAM module and service configurations for unintended interactions between flags and access checks.

Find out what's already
exploitable in your codebase.