Summary
Weblate's REST API may fail to enforce the intended scope of project- and workspace-scoped teams, allowing invalid team configurations to be submitted. A user who can manipulate team assignments could gain access to private projects and perform translation, repository, or project-management operations beyond their authorized scope.
Affected context
The issue may occur in Weblate deployments where the REST API accepts team configuration changes without adequately verifying that project assignments are permitted by the requesting user's existing scope. Risk is higher when users can submit team-management requests and when projects or workspaces contain private resources.
Exploit preconditions
- Attack surface: Weblate REST API endpoints that manage teams and project assignments
- Required access: An authenticated user with permission to submit relevant team or configuration requests
- Trigger point: Processing a request that assigns projects to a project- or workspace-scoped team
- Why exploitation is possible: Server-side authorization checks may not consistently validate whether the requested team scope and project relationships are allowed
Why this happens
The underlying bug is an object-level authorization failure mapped to CWE-639: Authorization Bypass Through User-Controlled Key. The API appears to trust user-supplied project or team relationships without enforcing the complete authorization context for the affected objects. This insecure pattern allows a valid request from a lower-privileged user to influence resources outside the user's permitted scope.
Potential impact
- Unauthorized users may view private projects
- Attackers could modify translations or related project content
- Repository-management operations may be performed outside the intended scope
- Project settings or team relationships could be changed without proper authorization
- Confidential localization data may be exposed
General mitigation guidance
Mitigation generally focuses on enforcing authorization at every object relationship boundary rather than relying on client-supplied scope information.
Common defensive patterns include:
- Revalidating team scope, workspace membership, and project ownership on the server for every mutation
- Deriving authorization context from trusted server-side records instead of request parameters
- Applying deny-by-default object-level access controls
- Separating permissions for viewing, translating, repository management, and project administration
- Restricting team-management capabilities according to least privilege
- Maintaining consistent authorization checks across REST endpoints and equivalent user interfaces
How teams detect issues like this
Organizations can look for this class of issue through:
- Static analysis and code review checks for authorization decisions based only on user-controlled identifiers
- Tests that attempt cross-workspace and cross-project object references using accounts with different privilege levels
- Review of API handlers for missing checks on team scope, project ownership, and workspace membership
- Runtime logging of team-assignment changes and unusual access to private projects
- Policy enforcement requiring server-side authorization tests for every object-level mutation
Automated security review tools may help identify inconsistent access-control checks, but authorization behavior should also be validated with integration and permission-boundary tests.

