Severity:

HIGH RISK

(7.3)

Improper Access Control in Rongzhitong Visual Integrated

CVE-2026-2668

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-266, CWE-284

Impact:

Privilege Abuse and Unauthorized Account Management

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

Rongzhitong's Visual Integrated Command and Dispatch Platform contains an improper access control issue in the /dm/dispatch/user/add User Handler endpoint.

Under certain conditions, a remote attacker can abuse weak or missing authorization checks on this user-management function, potentially creating or modifying user accounts without proper permissions.

Affected context

The vulnerability lies in the User Handler component responsible for user management, specifically the /dm/dispatch/user/add endpoint.

It manifests in deployments where the platform exposes this endpoint over a network and relies on insufficient or misconfigured access control checks.

The issue is most relevant in environments where the application trusts client-side state, assumes network location as a security boundary, or does not consistently enforce server-side authorization for user-related operations.

Exploit preconditions

  • Attack surface: Network-accessible HTTP(S) interface of the Visual Integrated Command and Dispatch Platform
  • Required access: Remote access to the affected endpoint; in some configurations this may not require valid credentials or may be accessible with low-privileged accounts
  • Trigger point: Sending crafted requests to /dm/dispatch/user/add to invoke user creation or modification logic
  • Why exploitation is possible: The endpoint does not enforce robust authorization checks (or enforces them inconsistently), allowing actions that should be restricted to higher-privileged roles to be performed by unauthorized or under-privileged users

Why this happens

This vulnerability stems from improper access control in a security-critical user management function, aligning with CWE-284 (Improper Access Control) and CWE-266 (Incorrect Privilege Assignment).

The backend logic handling /dm/dispatch/user/add appears to either:

  • Fail to verify that the caller is authenticated and authorized for user administration, or
  • Assign or allow assignment of privileges without validating that the requester has the right to grant them.

Conceptually, this reflects a design where sensitive operations are exposed via an endpoint without consistent, centralized enforcement of role- and permission-based checks, and where trust is placed in request parameters or client context instead of validated server-side policy.

Potential impact

  • Creation of unauthorized user accounts that may gain access to the platform
  • Escalation of privileges by creating accounts with elevated roles or permissions
  • Bypassing onboarding or approval workflows for new user provisioning
  • Persistence of attacker-controlled access within the system via hidden or backdoor accounts
  • Potential compromise of operational data and command/dispatch functionality if attacker-controlled accounts gain higher privileges

General mitigation guidance

Effective mitigation focuses on enforcing strict, server-side authorization and principle of least privilege for all user-management operations:

  • Require authentication and explicit role-based authorization for all endpoints that create, update, or delete users, including /dm/dispatch/user/add.
  • Centralize access control logic rather than embedding ad-hoc checks within controllers to avoid inconsistent policy enforcement.
  • Ensure that only specific, high-privilege roles can create accounts and assign roles or permissions, and validate that granted privileges never exceed those of the requester.
  • Implement defense-in-depth controls such as mandatory audit logging for administrative actions and, where appropriate, secondary approval or workflow mechanisms for high-impact changes.
  • Avoid trusting client-submitted fields related to roles, permissions, or ownership; derive effective privileges server-side based on authenticated identity and policy.

How teams detect issues like this

Detection typically combines code-level and operational monitoring approaches:

  • Static analysis and code review: Look for controller or handler methods that:
  • Perform user creation or role assignment logic.
  • Omit middleware or filters responsible for authentication and authorization.
  • Rely on request parameters (e.g., role IDs, flags) without validating them against server-side policy.
  • Policy and framework checks: Verify that all user-management routes are protected by standard authorization mechanisms (e.g., RBAC middleware, access control annotations) and that no administrative endpoints are excluded from these protections.
  • Runtime monitoring: Enable and routinely review audit logs for user-related actions, flagging:
  • User creation events originating from unexpected IP ranges or low-privilege accounts.
  • Sudden spikes in user provisioning or role changes.
  • Automated security testing tools and API scanners can be configured to probe user-management endpoints for unauthorized access patterns and privilege escalation behaviors.

Sources

SourceLink
github.comgithub.com/21151213732/CVE/blob/main/VICDP-Unauthorized%20Access2.md
vuldb.comvuldb.com/?ctiid.346465
vuldb.comvuldb.com/?id.346465
vuldb.comvuldb.com/?submit.753283

Frequently asked

questions

Yes. The affected endpoint is reachable over the network, and a remote attacker who can connect to the platform can attempt to exploit the improper access control behavior.

It depends on the specific deployment and configuration. In some cases, weak or missing authorization might allow unauthenticated exploitation; in others, a low-privileged account may be sufficient to abuse the user-add functionality.

Apply strict server-side access control to all user-management operations by enforcing authentication, role-based authorization, and privilege checks in a centralized manner, ensuring only designated administrative roles can create and manage users and assign privileges.

Adopt a consistent access control model across the application: use a standard authorization framework, require explicit permissions for sensitive operations, treat user and role management as high-risk functions, and complement this with code reviews, automated tests, and security scanning focused on access control rules.

Find out what's already
exploitable in your codebase.