Summary
Anchor CMS through version 0.12.7 does not consistently enforce role-based access controls on administrative user-management endpoints. An authenticated low-privilege user may create administrator accounts or modify an existing administrator's credentials, potentially gaining full administrative access.
Affected context
The vulnerability occurs in Anchor CMS administrative user-management functionality when endpoints for adding or editing users accept requests from authenticated accounts without adequately verifying administrative privileges. Deployments are most exposed when editor- or user-level accounts can reach these endpoints and the application relies on endpoint access without centralized authorization checks.
Exploit preconditions
- Attack surface: Anchor CMS administrative user-management endpoints
- Required access: An authenticated account with low privileges, such as an editor or user role
- Trigger point: Direct requests to user creation or user editing operations
- Why exploitation is possible: The application does not reliably enforce role-based authorization before processing sensitive account-management actions
Why this happens
The underlying flaw is a missing or ineffective authorization check on administrative operations. The application authenticates the requester but fails to verify whether that identity is permitted to create privileged accounts or modify administrator credentials. This behavior maps to CWE-862, Missing Authorization, because access to a protected function is not consistently enforced according to the user's role.
Potential impact
- An attacker could create unauthorized administrator accounts.
- An attacker could change an existing administrator's password.
- The compromise could result in administrative account takeover.
- An attacker may modify site content, settings, or user permissions.
- The vulnerability could support further compromise of connected services or stored data.
General mitigation guidance
Mitigation generally focuses on enforcing authorization at the server-side
boundary for every sensitive user-management operation.
Common defensive patterns include:
- Applying centralized, deny-by-default role checks to account creation and modification actions.
- Separating authentication from authorization and validating the effective privilege for each request.
- Preventing non-administrative roles from setting privileged account attributes.
- Requiring stronger verification for administrator credential and role changes.
- Limiting administrative capabilities according to least privilege.
- Invalidating active sessions or requiring reauthentication after high-impact credential changes.
- Treating client-side controls and hidden administrative links as insufficient security boundaries.
How teams detect issues like this
Organizations can assess this class of issue through:
- Static analysis and code review checks for administrative handlers without explicit authorization gates.
- Review of route middleware, controller policies, and service-layer permission checks.
- Dynamic tests that exercise sensitive endpoints with accounts representing every supported role.
- Monitoring for low-privilege users creating administrators or changing privileged account credentials.
- Policy enforcement requiring authorization tests for all user-management and privilege-management routes.
- Neutral automated security review tools that identify missing or inconsistent access-control checks.

