Summary
Taskosaur 1.0.0 fails to properly validate the role parameter during user registration, allowing the client to dictate its own privilege level.
By modifying the registration request payload, an unauthenticated attacker can create an account with SUPER_ADMIN privileges and gain full administrative control of the application.
Affected context
The vulnerability exists in the Taskosaur 1.0.0 user registration endpoint where account roles are determined.
The server trusts the client-supplied role field instead of enforcing role assignment on the backend.
In deployments where registration is publicly accessible and no additional server-side constraints exist, any new user can register with elevated roles such as SUPER_ADMIN.
Exploit preconditions
- Attack surface: Public-facing user registration endpoint
- Required access: None; exploitable by unauthenticated users with network access to the registration API
- Trigger point: Submission of a crafted registration request containing an elevated
rolevalue (e.g., SUPER_ADMIN) - Why exploitation is possible: The backend does not enforce role constraints, does not ignore or sanitize client-supplied
rolevalues, and lacks server-side checks ensuring that only trusted flows can assign privileged roles
Why this happens
This issue stems from improper access control (CWE-284) combined with insecure privilege management.
The application design allows the client to specify the role attribute during registration, and the backend directly uses this value to create the account without validating that new users should only receive standard, low-privilege roles.
Conceptually, the authorization decision (who can be an administrator) is delegated to untrusted input instead of being enforced by server-side policy, resulting in universal privilege escalation for anyone who can send a crafted request.
Potential impact
- An attacker can create a SUPER_ADMIN account and gain full administrative control of the Taskosaur instance
- Modification or deletion of projects, tasks, and user data
- Creation, revocation, or modification of other user accounts and roles
- Changes to system-wide configuration, integrations, and security settings
- Potential access to sensitive information managed through the platform, including internal conversations and task execution history
General mitigation guidance
Effective mitigation focuses on enforcing strict, server-side authorization and role management policies:
- Assign roles exclusively on the server, based on trusted logic (e.g., defaulting new registrations to a minimal, non-privileged role).
- Ignore or strictly validate any client-supplied role or privilege-related parameters during registration and profile creation.
- Centralize role assignment logic and ensure privileged roles can only be granted through authenticated, authorized administrative workflows.
- Apply the principle of least privilege so that newly created accounts start with the lowest practical permissions.
- Regularly review role definitions and authorization rules to ensure they reflect intended business policies and are not influenced by client-controlled data.
How teams detect issues like this
Organizations can detect this class of vulnerability by:
- Performing targeted code review of registration and onboarding flows, looking specifically for:
- Direct use of client-supplied
role,is_admin, or similar fields in account creation. - Missing server-side checks for privileged role assignment.
- Using static analysis rules to flag patterns where authorization or role decisions depend on request parameters.
- Implementing security tests that attempt to modify role-related fields during sign-up and confirm they are rejected or ignored.
- Logging and monitoring account creation events, alerting on new administrator or SUPER_ADMIN accounts created through public registration endpoints.

