/

CVE-2026-28806

Severity:

HIGH RISK

(8.8)

Improper Authorization / Access Control in NervesHub Web

CVE-2026-28806

Analyzed

Vulnerability type

Category:

Improper Authorization / Access Control

CWE:

CWE-285, CWE-668

Impact:

Cross-Organization Device Takeover and Remote Device Compromise

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

An improper authorization flaw in NervesHub Web's device bulk actions and device update APIs allows authenticated users to control devices belonging to other organizations by manipulating device identifiers.

Under certain configurations, this can enable cross-tenant device management, including moving devices to attacker-controlled products, interfering with firmware updates, and in some cases fully compromising affected devices.

Affected context

This vulnerability arises in NervesHub Web deployments where multi-tenant organizations share the same backend and rely on server-side checks to restrict device operations to their owning organization.

The affected context includes:

  • Device bulk action workflows (e.g., batch moves, assignments, or status changes)
  • Device update APIs used to manage device metadata, product membership, and lifecycle
  • Environments where devices from multiple organizations are managed through the same API endpoints

The issue manifests when the backend trusts the device identifiers supplied by an authenticated user without consistently validating that each device belongs to the user's organization.

Exploit preconditions

  • Attack surface: NervesHub Web device management HTTP APIs (bulk device actions and device update endpoints).
  • Required access: Valid authenticated user account in any organization; no administrative role is strictly required if the account can invoke these APIs.
  • Trigger point: Submission of requests that reference device identifiers belonging to other organizations in bulk action or update calls.
  • Why exploitation is possible: The server-side authorization layer fails to enforce per-device ownership checks for each referenced device, allowing operations to proceed solely based on authentication and the presence of a device identifier rather than verifying organizational boundaries.

Why this happens

The core issue is a missing or incomplete authorization check on multi-tenant device operations.

Specifically, the APIs for device bulk actions and device updates accept device identifiers from the client and perform privileged operations without consistently validating that each device is owned by the caller's organization.

This maps to CWE-285: Improper Authorization, where an application grants access or capabilities based only on authentication or partial checks, and CWE-668: Exposure of Resource to Wrong Sphere, since devices (a protected resource) are exposed to control by users from other organizational spheres.

At an abstract level, this reflects an insecure pattern where:

  • The resource identity (device ID) is client-controlled.
  • The authorization logic does not bind the resource to a specific tenant or ownership context.
  • Bulk operations bypass or centralize checks in a way that fails to validate each resource individually.

Potential impact

  • Attackers may move devices from victim organizations into products they control, altering device management flows.
  • Attackers could interfere with firmware rollout, delaying or preventing updates or pushing unintended configurations.
  • Device connectivity could be disrupted by changing device associations, configurations, or update policies.
  • In environments with extended capabilities (e.g., remote console or management features), attackers could gain full remote control of affected devices.
  • Cross-tenant data exposure could occur if device metrics, logs, or status information become visible outside the owning organization.

General mitigation guidance

Effective mitigation focuses on strengthening authorization rules and tenancy boundaries for device resources.

Common defensive patterns include:

  • Enforcing per-resource authorization: For every device referenced in bulk or single-device APIs, verify that it belongs to the caller's organization or tenant before performing any action.
  • Binding devices to a tenant or organization identifier and ensuring all queries and updates include this constraint at the data-access layer (e.g., always filter by organization_id and device_id together).
  • Designing bulk operations to apply the same strict authorization as single-resource operations, avoiding any "fast path" that skips checks for performance.
  • Applying least privilege to user roles and API tokens so only appropriate roles can perform sensitive device management operations.
  • Implementing defense in depth with server-side constraints, such as database-level or policy-level checks that prevent cross-tenant modifications even if application logic regresses.

How teams detect issues like this

Detection and verification strategies can focus on:

  • Static analysis and code review:
  • Look for controller or API handlers that accept device IDs from requests and perform updates without cross-checking organizational ownership.
  • Flag bulk operations where device lists are processed with a single authorization check rather than per-device validation.
  • Review data access patterns to ensure queries always apply tenant/organization filters when fetching or updating devices.
  • Automated tests and policy enforcement:
  • Add integration tests that attempt to operate on devices from another organization and verify that access is denied.
  • Use security-focused linters or policy-as-code tools to enforce multi-tenant access rules at the service and database layers.
  • Monitor audit logs for unusual cross-organization device operations, such as a single user modifying devices owned by multiple organizations.

Sources

SourceLink
cna.erlef.orgcna.erlef.org/cves/CVE-2026-28806.html
github.comgithub.com/nerves-hub/nerves_hub_web/commit/1f69c9d595684a4650c3ac702f3dc7c5bcd7526c
github.comgithub.com/nerves-hub/nerves_hub_web/security/advisories/GHSA-f8fr-mccc-xvcx
osv.devosv.dev/vulnerability/EEF-CVE-2026-28806

Frequently asked

questions

Yes. Any attacker who can authenticate to the NervesHub Web instance and access the device bulk actions or device update APIs can exploit the issue remotely over the network, without needing direct device access.

The attacker needs a valid user account within any organization on the affected deployment. They do not necessarily need administrative privileges if their existing role can invoke the affected APIs. Exploitation relies on manipulating device identifiers rather than elevating their own role.

Implement strict, per-device authorization checks that combine device identifiers with their owning organization or tenant, and enforce those checks in all device management APIs, including bulk operations. Additionally, centralize and reuse authorization logic so that all paths to device modification go through a consistent, well-reviewed access control layer.

Design multi-tenant systems with explicit tenancy boundaries at both the application and data layers, require authorization checks for every resource access, and enforce patterns like "always filter by tenant and ID." Complement this with automated tests, code review checklists focused on access control, and static analysis rules that flag direct use of client-supplied IDs without corresponding ownership validation.

Find out what's already
exploitable in your codebase.