/

CVE-2026-36538

Severity:

HIGH RISK

(7.3)

Hard-Coded Credentials in Netis AC1200 Router NC21

CVE-2026-36538

Deferred

Vulnerability type

Category:

Hard-Coded Credentials

CWE:

CWE-798

Impact:

Full Device Compromise / Privilege Escalation

Severity:

HIGH RISK

(7.3)

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

The Netis AC1200 Router NC21 V4.0.1.4296 contains a hard-coded root credential stored in /etc/shadow.sample, with the password set to the trivially weak value root.

An attacker who can reach the device's authentication interface or relevant services may log in as root and obtain full administrative control of the underlying operating system.

Affected context

This vulnerability affects Netis AC1200 Router NC21 V4.0.1.4296 devices that retain the vendor-provided root account and password as shipped.

It becomes relevant wherever:

  • The router exposes an interface (e.g., console, SSH, telnet, debug service, or local management channel) that accepts the root credential.
  • The hard-coded credential is not disabled, rotated, or otherwise protected by additional controls.

Environments where devices are reachable from untrusted networks or shared physical spaces are particularly exposed.

Exploit preconditions

  • Attack surface: Any interface that permits root authentication, such as:
  • Local or remote shell access (e.g., SSH, telnet, serial console) if enabled
  • Internal maintenance or debug services bound to the LAN or WAN
  • Required access: Network or physical access sufficient to reach the relevant login interface on the device.
  • Trigger point: Attempting to authenticate using the known root username and the default password root.
  • Why exploitation is possible: The root credential is hard-coded and trivially guessable, and there is no uniqueness or enforced change on first use, enabling anyone with access to authenticate as the highest-privileged user.

Why this happens

The core issue is the inclusion of a static, hard-coded root credential with a known, weak password in the device firmware, stored in /etc/shadow.sample.

This maps to CWE-798: Use of Hard-coded Credentials, where a product embeds fixed authentication secrets instead of generating unique credentials per device or requiring user configuration.

Because all affected devices share the same root password and are not forced to rotate it, authentication no longer serves as an effective security barrier—anyone aware of the default can bypass access controls and operate with full privileges.

Potential impact

  • Full administrative access to the router's operating system as root.
  • Modification of network configuration, including DNS, routing, and firewall rules.
  • Installation of persistent malware or participation in botnets.
  • Interception, redirection, or manipulation of user traffic traversing the router.
  • Use of the compromised router as a pivot point to attack other devices on the local network.
  • Tampering with firmware, backup configurations, or logging to conceal malicious activity.

General mitigation guidance

Effective mitigation generally focuses on minimizing the trust placed in vendor-supplied credentials and reducing the reachable attack surface:

  • Replace any default or hard-coded credentials with unique, strong passwords as soon as deployment or access permits.
  • Disable or restrict high-privilege login interfaces (e.g., remote shell, debug services) to trusted management networks or via out-of-band access only.
  • Enforce least-privilege principles by separating administrative and operational accounts where possible and reducing routine dependence on root.
  • Place routers behind additional security controls, such as management VLANs, jump hosts, or VPN-based administration, so that only trusted operators can reach management interfaces.
  • Adopt operational policies requiring periodic credential rotation and verification that default accounts are disabled or hardened.

How teams detect issues like this

Detection typically involves both configuration review and behavioral monitoring:

  • Configuration and firmware review:
  • Inspect firmware images or filesystem snapshots for hard-coded credential files (e.g., /etc/shadow.sample, /etc/passwd, backup configs).
  • Use static analysis or scanning tools to flag known default usernames and weak passwords embedded in device images or configuration templates.
  • Access and authentication monitoring:
  • Review authentication logs (when available) for direct root logins, especially from unexpected IP ranges or at unusual times.
  • Apply network monitoring to detect new or unauthorized management services being exposed on the router.
  • Policy and CI/CD integration:
  • Include checks for hard-coded secrets in build pipelines for custom firmware or management scripts.
  • Define security policies that disallow shared or vendor-default credentials across managed devices and validate compliance regularly.

Sources

SourceLink
github.comgithub.com/sir3ns/cve-disclosure/blob/main/CVE-2026-36538/readme.md

Frequently asked

questions

It can be, depending on deployment. If the router's management or shell interfaces that accept root credentials are exposed to untrusted networks (including the public internet), a remote attacker could authenticate as root. If those interfaces are restricted to a local or management network, exploitation is limited to actors who can reach that network.

An attacker needs enough network or physical access to reach a login interface that honors the root account (for example, SSH, telnet, console, or other management/maintenance services). No prior authentication is required beyond knowledge of the default root password.

The safest pattern is to eliminate shared, hard-coded credentials entirely. In practice, this means enforcing unique credentials per device or per deployment, requiring a password change on first use, and disabling or locking down any root or maintenance accounts that rely on vendor defaults.

Prevention relies on secure credential lifecycle design: avoid embedding passwords in firmware, generate unique secrets for each device, ensure that high-privilege accounts require explicit configuration by operators, and integrate secret scanning and configuration checks into development, QA, and deployment processes to catch hard-coded credentials before release.

Find out what's already
exploitable in your codebase.