/

CVE-2026-38529

Severity:

HIGH RISK

(8.8)

Broken Access Control / BOLA in Webkul Krayin CRM User

CVE-2026-38529

Analyzed

Vulnerability type

Category:

Broken Access Control / BOLA

CWE:

CWE-269, CWE-639

Impact:

Account Takeover via Password Reset

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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.

Sources

SourceLink
github.comgithub.com/TREXNEGRO/Security-Advisories/tree/main/CVE-2026-38529
github.comgithub.com/krayin/laravel-crm

Frequently asked

questions

The vulnerability is broadly exploitable by any authenticated user who can reach the affected endpoint and is able to craft or modify HTTP requests. No special roles or privileges are required if the application fails to enforce proper object-level checks on the user settings controller.

No. The flaw arises from broken authorization on object-level resources, so even low-privileged or standard user accounts can exploit it, provided they can supply identifiers of other users in the vulnerable request.

The safest fix is to ensure that password changes and similar sensitive operations always derive the target user from the authenticated session or token, not from client-provided identifiers, and to enforce clear role-based checks on any legitimate administrative capabilities that modify other users' accounts.

Prevention relies on a consistent, centralized authorization strategy: design APIs with object-level access control in mind, avoid trusting client-supplied identifiers for sensitive actions, apply mandatory checks in middleware or policy layers, and include BOLA-specific tests and reviews (including API security testing) as a standard part of the development and CI/CD pipeline.

Find out what's already
exploitable in your codebase.