Summary
OpenReplay's dashboard and note mutation APIs lack proper ownership checks on certain SQL operations, causing insecure direct object references.
Any authenticated user can target note or dashboard identifiers directly, allowing deletion of private session notes and modification of other users' private dashboard widgets when these endpoints are exposed.
Affected context
This vulnerability occurs in OpenReplay deployments where:
- Multiple authenticated users share projects and dashboards
- Note and dashboard mutation endpoints are accessible to regular project members
- Backend SQL queries for delete/update operations do not enforce ownership predicates
It is most impactful in environments where dashboards and notes are treated as private, user-specific resources but are still stored within shared projects.
Exploit preconditions
- Attack surface: Application backend APIs handling notes.delete, dashboards.update_widget, and dashboards.remove_widget operations
- Required access: Any authenticated project membership within the affected OpenReplay instance
- Trigger point: Supplying the identifiers of notes or dashboards/widgets owned by another user to the vulnerable mutation functions
- Why exploitation is possible: The SQL statements filter only on identifiers like note id, project id, dashboard id, and widget id, and omit ownership checks, so the backend does not distinguish between resources owned by the caller and those owned by other users.
Why this happens
The underlying issue is a missing authorization control when mutating objects identified by direct IDs.
While sibling read and edit functions include ownership predicates in their SQL queries, the vulnerable delete and widget mutation functions rely solely on object identifiers (note id, project id, dashboard id, widget id).
This maps to CWE-639: Insecure Direct Object Reference, where user-controlled identifiers are trusted without verifying that the caller is authorized to perform the requested operation on the referenced resource.
Potential impact
- Authenticated users may delete other users' private session notes within shared projects.
- Authenticated users could remove widgets from other users' private dashboards.
- Authenticated users can potentially rewrite or alter widgets on dashboards they do not own.
- Users may lose critical analytical configurations, leading to data misinterpretation and loss of trust in audit trails.
General mitigation guidance
Effective mitigation focuses on enforcing robust, consistent authorization for all object mutation operations.
Recommended patterns include:
- Applying the same ownership predicates used in read/edit queries to delete and update operations, ensuring that resource access is always scoped to the current user or explicitly authorized roles.
- Centralizing authorization logic so that checks are not duplicated or accidentally omitted in individual endpoints.
- Treating object identifiers as untrusted input and validating both the existence of the resource and the requester's relationship to it before performing any mutation.
- Implementing least-privilege role models, where default project members have limited ability to modify or delete resources belonging to other users.
- Designing APIs so that "private" resources are always anchored to explicit owner identifiers or access control lists, not just project-level scoping.
How teams detect issues like this
Detection typically involves examining both code and runtime behavior for missing authorization checks around object IDs.
Useful strategies include:
- Static analysis rules that flag data-modifying queries built solely on user-supplied IDs without additional ownership or role predicates.
- Code review practices that require all CRUD handlers to demonstrate explicit authorization decisions, especially for multi-tenant or multi-user resources.
- Access control policy audits that compare read and write paths for each resource type, checking for inconsistencies in predicate application.
- Logging and monitoring of deletion or dashboard widget changes correlated with resource ownership, to identify suspicious patterns where one user frequently alters another's private resources.
- Optional use of automated security testing tools that can fuzz object IDs and observe whether unauthorized modifications are accepted.

