/

CVE-2026-27785

Severity:

HIGH RISK

(8.8)

Hard-Coded Credentials in Milesight AIoT Camera Firmware

CVE-2026-27785

Awaiting Analysis

Vulnerability type

Category:

Hard-Coded Credentials

CWE:

CWE-798

Impact:

Authentication Bypass and Unauthorized Device Control

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

Certain Milesight AIoT camera firmware versions embed hard-coded credentials directly into the device software, creating a universal access path that cannot be changed by end users.

An attacker who can reach the device over the network may be able to authenticate using these fixed credentials, bypass normal account controls, and gain privileged access to camera functions and configuration.

Affected context

This vulnerability occurs in specific Milesight AIoT camera firmware builds where default or vendor-backdoor credentials are compiled into the firmware image.

It is relevant in environments where cameras are reachable over local networks or the internet and where network segmentation, strong access control, or device-level hardening is limited.

The risk is higher when devices are directly exposed to the public internet, share common passwords across deployments, or rely solely on application-layer authentication without additional network defenses.

Exploit preconditions

  • Attack surface: Network-accessible management or service interfaces exposed by the camera (e.g., web UI, API, RTSP/ONVIF, proprietary services).
  • Required access: Ability to initiate network connections to the device's listening ports (local network or remote if exposed via port forwarding, VPN misconfiguration, or cloud relay).
  • Authentication state: The hard-coded credentials are accepted by the device as valid, often with elevated privileges, independent of user-configured accounts.
  • Why exploitation is possible: Credentials are statically embedded in firmware and are either documented or trivially discoverable (e.g., via firmware extraction, leaked documentation, or shared across devices), allowing attackers to log in without needing unique per-device secrets.

Why this happens

The underlying issue maps to CWE-798: Use of Hard-Coded Credentials, where authentication secrets are embedded directly within the firmware as constant values.

This pattern emerges when developers bake default administrative passwords, support accounts, or maintenance backdoors into the device to simplify deployment, testing, or remote servicing.

Because these secrets are not generated per device and cannot be rotated or disabled by operators, compromise of a single credential effectively compromises any device sharing that firmware and interface exposure pattern.

The firmware architecture places long-term trust in static values rather than relying on user-provisioned or hardware-bound keys, creating a systemic, persistent authentication weakness.

Potential impact

  • Unauthorized access to camera live video streams and stored recordings
  • Full administrative control over camera configuration, including network settings and firmware management
  • Enrollment of devices into botnets for distributed denial-of-service (DDoS) attacks or scanning campaigns
  • Use of the camera as an internal pivot point for further attacks within the local network
  • Tampering with security monitoring by disabling cameras, altering fields of view, or erasing logs and recordings
  • Loss of privacy and potential regulatory or contractual non-compliance due to unapproved surveillance access

General mitigation guidance

Effective mitigation focuses on eliminating static, shared secrets and reducing the exposed attack surface around device management.

Common defensive patterns include:

  • Designing firmware so that no universal or hard-coded administrative credentials exist; rely on per-device, user-provisioned secrets instead.
  • Enforcing secure onboarding flows that require setting a unique strong password or key at first use, blocking operation until completed.
  • Implementing mechanisms to disable or lock down any support or maintenance accounts in production deployments, ideally controlled by configuration flags or build-time options.
  • Applying strong network-layer protections such as restricting management interfaces to dedicated management networks or VPN-only access.
  • Using role- and least-privilege-based access controls so that any necessary service accounts have minimal permissions and are auditable.
  • Favoring cryptographically strong, hardware-bound identity mechanisms (device certificates, TPM/secure element-backed keys) over password-like secrets for remote administration.

How teams detect issues like this

Identifying hard-coded credentials typically involves a mix of firmware analysis, behavioral testing, and configuration review.

Common approaches include:

  • Static analysis of firmware images: Extracting and scanning binaries, configuration files, and scripts for known username/password patterns, authentication tokens, or embedded keys.
  • Code review signals: Looking for literal credential strings, embedded hashes, or conditional logic that recognizes undocumented accounts or bypasses password checks.
  • Dynamic testing: Attempting authentication with default or known vendor credentials across fleets of devices, especially using security scanning tools tailored for IoT and camera systems.
  • Policy enforcement: Establishing development policies disallowing hard-coded credentials, with automated checks in CI pipelines that flag suspicious constants or authentication shortcuts.
  • Runtime monitoring: Logging and analyzing successful logins, particularly from unusual accounts or across large populations of devices using the same credential pattern.

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

It can be. If the camera's management or streaming interfaces are reachable from untrusted networks (such as the internet or guest Wi-Fi), an attacker may exploit the hard-coded credentials remotely. If devices are fully isolated on internal networks, exploitation is generally limited to insiders or anyone who gains internal network access.

The attacker needs network-level access to the device's exposed services. No prior knowledge of user-configured accounts is required; the hard-coded credentials may grant direct access, often with administrative privileges.

The safest pattern is to eliminate hard-coded credentials entirely and require unique, user-controlled secrets per device. Any necessary service or support accounts should be disabled by default or tied to temporary, revocable credentials established through secure provisioning flows.

Prevention relies on secure design practices: prohibit hard-coded credentials in architecture and coding standards, implement secure device onboarding with mandatory unique credentials or certificates, use hardware-backed keys where possible, and enforce automated checks in the development lifecycle to detect static secrets before release.

Find out what's already
exploitable in your codebase.