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/addto 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.

