/

CVE-2026-35546

Severity:

CRITICAL RISK

(9.8)

Missing Authentication in Anviz CX2 Lite and CX7

CVE-2026-35546

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Remote Code Execution and Device Takeover

Severity:

CRITICAL RISK

(9.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

Anviz CX2 Lite and CX7 devices accept firmware uploads without enforcing authentication, allowing crafted firmware archives to be installed by anyone who can reach the update interface.

Under these conditions, attackers may plant and execute arbitrary code on the device, including obtaining a reverse shell and fully compromising the unit.

Affected context

This vulnerability occurs in the firmware update mechanism of Anviz CX2 Lite and CX7 devices.

It becomes relevant in environments where:

  • Devices expose their management or update interface over a network segment that attackers can reach, and
  • Firmware upload requests are processed without binding them to a verified, authenticated user session.

The issue is typically observed when update endpoints are left unauthenticated or rely solely on client-side controls, assumptions about network trust, or obscurity.

Exploit preconditions

  • Attack surface: Network-accessible firmware update interface on the Anviz CX2 Lite and CX7 devices.
  • Required access: Network reachability to the device's management/update endpoint; no valid credentials are required if the interface is exposed.
  • Trigger point: Submission of a crafted firmware archive to the firmware upload endpoint or mechanism.
  • Why exploitation is possible: The firmware upload path fails to enforce robust authentication and authorization checks (CWE-306), allowing untrusted parties to perform sensitive update operations that should only be available to administrators.

Why this happens

The core issue is a failure to require authentication for a security-critical operation: firmware upload and installation.

This maps to CWE-306: Missing Authentication for Critical Function, where the system exposes powerful functionality—such as updating device firmware—without verifying the identity or privileges of the caller.

In this case, the update mechanism implicitly trusts any incoming firmware upload request, treating it as if it originated from a legitimate administrator.

Without server-side enforcement of authentication and authorization around the update endpoint, attackers can supply arbitrary firmware images or archives that the device accepts and executes as trusted code.

Potential impact

  • Full device takeover via installation of attacker-controlled firmware
  • Execution of arbitrary code, including establishing a reverse shell from the device
  • Persistent backdoors or implants surviving reboots and routine maintenance
  • Use of compromised devices as footholds for lateral movement within the local network
  • Tampering with device functionality, logs, or collected data
  • Integration of the device into larger botnets or coordinated attack infrastructures

General mitigation guidance

Effective mitigation focuses on enforcing strong identity checks and hardening the firmware update process:

  • Require robust server-side authentication for all firmware upload and management actions, independent of client-side controls.
  • Bind firmware update operations to authenticated sessions with clearly defined administrative roles and least-privilege permissions.
  • Implement integrity and authenticity checks for firmware images (e.g., digital signatures) and reject any update that cannot be cryptographically verified.
  • Restrict network exposure of management and update interfaces to dedicated administration networks or VPNs rather than general-purpose segments.
  • Provide secure, auditable update workflows that prefer pull-based updates from trusted distribution channels over ad-hoc manual uploads where feasible.

How teams detect issues like this

Organizations can approach detection with a mix of code review, configuration assessment, and runtime monitoring:

  • Code and design review: Examine update-related endpoints for missing authentication and authorization checks, and verify that role-based access control is enforced on firmware operations.
  • Static analysis: Configure rules or custom checks that flag critical operations (e.g., firmware upload, configuration reset, root-level actions) when they are not wrapped in authentication and privilege checks.
  • Configuration and deployment review: Validate that management interfaces are not exposed to untrusted networks and that access control policies are applied consistently across devices.
  • Runtime and log monitoring: Monitor device logs and network telemetry for unusual firmware upload events, repeated update attempts, or uploads originating from unexpected IP ranges.
  • Automated security testing and device security assessments can help identify unauthenticated control paths before deployment or at regular intervals.

Sources

SourceLink
github.comgithub.com/cisagov/CSAF/blob/develop/csaf_files/OT/white/2026/icsa-26-106-03.json
anviz.comanviz.com/contact-us.html
cisa.govcisa.gov/news-events/ics-advisories/icsa-26-106-03

Frequently asked

questions

It can be, but only if the device's management or firmware update interface is reachable from the attacker's location, such as when exposed directly to the internet or to a compromised network segment. If the interface is restricted to a tightly controlled administrative network, remote exploitation becomes significantly harder.

No. The described flaw stems from missing authentication on the firmware upload function, meaning that an attacker who can reach the update endpoint may perform firmware uploads without any valid credentials.

The safest pattern is to enforce strong, server-side authentication and authorization for all critical operations such as firmware updates, combined with cryptographic verification of firmware authenticity. All update actions should only be accessible to authenticated administrators and validated through defense-in-depth checks.

During design and implementation, treat firmware updates and other powerful administrative operations as high-risk functions that must always be gated by authentication, authorization, and integrity checks. Adopt a secure-by-default approach: design management interfaces for closed, authenticated access; perform regular security architecture reviews; and apply automated checks that flag unauthenticated access paths to critical functionality.

Find out what's already
exploitable in your codebase.