Summary
Webkul Krayin CRM v2.2.x contains a Broken Object-Level Authorization (BOLA) flaw in the /Settings/UserController.php endpoint that mishandles access control on user accounts.
An authenticated attacker can craft HTTP requests that target other users' identifiers to reset their passwords, enabling full account takeover when the application fails to properly verify ownership of the affected account.
Affected context
The vulnerability occurs in the user settings and account management functionality of Krayin CRM v2.2.x, specifically within the /Settings/UserController.php endpoint.
It manifests when the application allows password reset or modification operations based solely on client-supplied identifiers (such as user IDs, emails, or similar references) without enforcing robust server-side checks that the authenticated user is actually authorized to perform actions on the targeted account.
Instances where multi-tenant or multi-user environments share the same endpoint and rely primarily on client-controlled parameters are particularly susceptible.
Exploit preconditions
- Attack surface: HTTP API/WEB endpoint at
/Settings/UserController.php - Required access: Valid authenticated session in the CRM (even low-privileged or standard user)
- Trigger point: Sending a crafted HTTP request that references another user's account (e.g., via user ID or similar identifier) to the user settings/password reset functionality
- Why exploitation is possible: The endpoint performs sensitive operations (such as updating credentials) based on user-controlled identifiers and session presence, but does not consistently verify that the caller owns or is authorized to manage the targeted user object, leading to Broken Object-Level Authorization.
Why this happens
This issue stems from improper authorization checks on object-level resources, mapping directly to CWE-639: Authorization Bypass Through User-Controlled Key and more broadly to CWE-269: Improper Privilege Management.
The application trusts client-supplied identifiers (e.g., user ID fields in POST/PUT parameters) when performing sensitive operations like password resets, assuming that any authenticated requester should be allowed to act on the specified account.
Instead of deriving the target account from the server-side session (or enforcing role-based checks on administrative actions), the controller logic ties authorization to data provided by the caller, allowing one user to manipulate another user's account by guessing or enumerating identifiers.
This pattern reflects a classic BOLA bug class: insufficient object access control on individual records or resources in an otherwise authenticated API.
Potential impact
- An attacker may reset passwords for arbitrary user accounts.
- An attacker could achieve full account takeover of other CRM users, including potentially administrative accounts.
- An attacker may gain access to sensitive CRM data such as leads, customer information, deals, and communication history.
- An attacker could impersonate other users when interacting with customers or other systems integrated with the CRM.
- An attacker may use compromised accounts as a foothold for further lateral movement or data exfiltration within the organization.
General mitigation guidance
Effective mitigation focuses on enforcing robust server-side authorization around every object-level action:
- Tie sensitive operations (like password changes) to the authenticated user's identity stored in the server-side session or token, rather than accepting arbitrary user identifiers from client input.
- Apply strict object-level authorization checks that verify the caller's permission to access or modify each specific user resource, following the principle of "don't trust the ID from the client".
- For administrative operations that legitimately modify other users, implement explicit role- and permission-based checks and clearly separate admin endpoints from self-service user endpoints.
- Normalize access control logic into centralized authorization middleware or policies, reducing the risk of inconsistent checks across controllers.
- Where feasible, reduce the exposure of internal identifiers and rate-limit sensitive endpoints to make enumeration and abuse more difficult.
How teams detect issues like this
Organizations can identify similar BOLA issues using a combination of testing and review techniques:
- Static analysis and code review: Look for controllers or endpoints that:
- Accept user IDs or other object keys as request parameters for sensitive operations.
- Do not contain explicit authorization checks comparing the authenticated user to the targeted resource.
- Bypass centralized authorization middleware or perform direct database updates based on request parameters.
- Security testing and API fuzzing: Use automated or manual tests to:
- Replay sensitive requests (e.g., password update) while changing only the user identifier to that of another account.
- Test multi-tenant scenarios where one user attempts to access or modify another tenant's data using predictable IDs.
- Policy and gateway enforcement: Employ API gateways, WAF rules, or access-control middleware that:
- Enforce object-level access policies where possible.
- Log and alert on patterns where one account repeatedly targets identifiers belonging to other users.
- Automated SAST/DAST tools can help surface common broken access control patterns but should be complemented with targeted manual review of sensitive endpoints.

