/

CVE-2026-28747

Severity:

HIGH RISK

(7.1)

Broken Authorization / Insecure Direct Object Reference

CVE-2026-28747

Awaiting Analysis

Vulnerability type

Category:

Broken Authorization / Insecure Direct Object Reference

CWE:

CWE-639

Impact:

Authorization Bypass and Unauthorized Access

Severity:

HIGH RISK

(7.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 weak key generation vulnerability in certain Milesight AIoT camera firmware versions allows attackers to bypass authorization controls that should protect access to device functionality and data.

When an attacker can predict or derive authorization-related keys or tokens, they may access camera streams or administrative functions without valid credentials.

Affected context

This issue affects Milesight AIoT cameras running specific vulnerable firmware where authorization decisions depend on keys, tokens, or identifiers generated with insufficient randomness or predictable patterns.

The vulnerability typically manifests in environments where:

  • Network access to the camera's management or API interface is possible
  • Authorization relies on client-supplied identifiers or tokens tied to weakly generated keys
  • Access checks trust those keys without strong server-side validation that the caller is the legitimate owner

Exploit preconditions

  • Attack surface: Network-accessible camera management interfaces, APIs, or streaming endpoints.
  • Required access: Ability to send requests to the device over the network (local network or, in some deployments, over the internet).
  • Trigger point: Use of predictable or weakly generated authorization keys/tokens in requests to privileged endpoints or resources.
  • Why exploitation is possible: The key generation mechanism lacks sufficient entropy, uniqueness, or binding to the authenticated user, allowing attackers to guess, derive, or reuse keys belonging to other sessions or accounts and thereby bypass proper authorization checks.

Why this happens

The root cause aligns with CWE-639: Insecure Direct Object Reference (IDOR), where authorization is enforced using user-controllable identifiers that are not adequately protected.

In this case, authorization keys or tokens are generated using a weak or predictable scheme (for example, sequential values, device-specific constants, timestamps, or other low-entropy sources).

Because these values are guessable or derivable, an attacker can manipulate identifiers or keys in requests to directly reference resources or privileges they are not authorized to access.

The fundamental bug class is trusting weakly generated keys as proof of authorization instead of performing robust, server-side access control checks tied to a verified identity.

Potential impact

  • Unauthorized viewing of live or recorded camera feeds
  • Access to configuration interfaces, including network and security settings
  • Modification of device settings, such as firmware, credentials, or alert rules
  • Disabling or tampering with monitoring capabilities (e.g., turning off recording or motion detection)
  • Use of compromised cameras as footholds for further network reconnaissance

General mitigation guidance

Effective mitigation focuses on strengthening authorization architecture and eliminating reliance on weakly generated identifiers:

  • Replace any predictable or low-entropy key generation with cryptographically secure random token generation.
  • Ensure authorization decisions are consistently enforced server-side using strongly bound identities (e.g., authenticated sessions, access control lists) rather than client-supplied IDs alone.
  • Bind tokens and keys to specific users, devices, or sessions, and validate this binding on every privileged request.
  • Implement least-privilege roles for all device functions so that compromise of a single token does not grant full administrative control.
  • Introduce rate limiting and anomaly detection for repeated access attempts using incorrect or non-existent keys to reduce effective brute-forcing.
  • Design interfaces so that internal identifiers are not exposed or guessable from URL patterns, sequential numbering, or error messages.

How teams detect issues like this

Detection typically combines design review, code inspection, and behavioral analysis:

  • Review firmware and backend code for patterns where access control relies on user-supplied IDs, tokens, or keys without additional authorization checks.
  • Use static analysis rules to flag custom key/token generation routines that do not use cryptographically secure randomness or that derive keys from predictable sources (timestamps, sequential IDs, MAC addresses).
  • Analyze API and web interface routes for IDOR patterns: resources addressed by incremental IDs, device IDs, or session IDs without server-side ownership checks.
  • Perform security testing with crafted requests that modify identifiers, tokens, or parameters to access other users' streams or settings.
  • Deploy logging that records authorization decisions and suspicious access attempts, and periodically audit logs for atypical resource access patterns.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-113-03.json
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-113-03
milesight.commilesight.com/support/download/firmware

Frequently asked

questions

Exploitability depends on network exposure. If the camera interfaces are reachable from untrusted networks and authorization is based on weak keys, an attacker may remotely bypass controls. On isolated or properly firewalled networks, the risk is more limited to insiders or already-present attackers.

Not necessarily. Because the weakness is in key generation and authorization enforcement, an attacker might be able to guess or derive valid keys without owning an account, or escalate from a low-privilege position to higher-privilege access.

The robust fix is to replace any predictable key or token scheme with cryptographically secure random tokens and enforce all authorization checks server-side, binding tokens to authenticated identities and explicit access control rules rather than trusting client-supplied identifiers.

Adopt a security-by-design approach: model authorization requirements early, use well-vetted authentication and token libraries, perform threat modeling for all remote interfaces, and subject authorization logic to focused code review and penetration testing so that IDOR and weak key generation patterns are caught before release.

Find out what's already
exploitable in your codebase.