Summary
Semaphore UI contains an authorization flaw that lets a project manager create a custom manager role with permissions exceeding the intended manager capabilities. Under affected configurations, this may grant project-owner actions such as updating project settings or managing project users.
Affected context
The issue occurs in Semaphore UI project role management when the application accepts a project manager's request to create a custom role and permits a permission bitmask that includes owner-level capabilities. It affects deployments using the vulnerable project middleware and role lookup logic, particularly where project managers are trusted to manage project roles through the web API.
Exploit preconditions
- Attack surface: Authenticated project role-management API
- Required access: Project manager privileges for a target project
- Trigger point: Creation of a custom role through the project roles endpoint
- Why exploitation is possible: Server-side authorization permits a project manager to assign a permission combination that includes project-management and project-user-management capabilities
Why this happens
The vulnerability is caused by insufficient privilege boundary enforcement during custom role creation and authorization. The application treats a project manager's requested permission set as acceptable without preventing combinations that exceed the manager's intended authority, allowing a lower-privileged role administrator to obtain owner-level capabilities. This behavior maps to CWE-269: Improper Privilege Management, where access rights are assigned or enforced beyond the intended security boundary.
Potential impact
- A project manager may gain unauthorized project-owner capabilities
- An attacker could modify project settings or configuration
- An attacker may add, remove, or alter project users and their access
- Project resources could be disrupted, exposed, or mismanaged
- Administrative actions could be performed without appropriate owner authorization
General mitigation guidance
Mitigation generally focuses on enforcing privilege boundaries independently of client-supplied permission values.
Common defensive patterns include:
- Define server-side allowlists for permissions available to each administrative role
- Prevent custom roles from combining project-manager permissions with owner-only capabilities
- Treat built-in role privileges as immutable security policy rather than ordinary bitmasks
- Re-evaluate authorization for every project and user-management operation
- Apply least privilege to project managers and separate role administration from ownership functions
- Record and review changes to roles, permissions, and project membership
How teams detect issues like this
Organizations can identify similar issues through:
- Static analysis and authorization tests that compare role creation permissions with protected operations
- Code review checks for client-controlled permission bitmasks and unchecked role combinations
- Policy tests confirming that project managers cannot grant owner-only capabilities
- Monitoring for custom roles containing sensitive project or user-management permissions
- Audit review of role creation, permission changes, and project membership updates
Automated security review tools may help flag missing authorization checks, but business-logic tests should verify the intended privilege hierarchy.

