/

CVE-2026-55880

Severity:

HIGH RISK

(7.1)

Insecure Direct Object Reference (CWE-639) in OpenReplay

CVE-2026-55880

Deferred

Vulnerability type

Category:

Insecure Direct Object Reference

CWE:

CWE-639

Impact:

Unauthorized Data Modification and Deletion

Severity:

HIGH RISK

(7.1)

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

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.

Sources

SourceLink
github.comgithub.com/openreplay/openreplay/security/advisories/GHSA-9xfv-p2fx-vmx9

Frequently asked

questions

No. Exploitation requires authenticated access as a project member. However, once authenticated, a user can target object identifiers belonging to other users within the same project.

No elevated privileges are necessary. Any regular authenticated member with access to the vulnerable endpoints can attempt to delete notes or modify widgets on dashboards owned by other project users.

The most robust fix is to enforce consistent authorization checks for all CRUD operations on notes and dashboards. That typically means applying ownership or role-based predicates in every SQL query and centralizing authorization logic so that it cannot be accidentally skipped in individual handlers.

Prevention involves designing APIs around strong access control principles: treat all identifiers as untrusted, require explicit authorization checks before every mutation, reuse shared authorization middleware, and validate that read, write, and delete paths use the same ownership and role constraints. Regular security-focused code reviews and automated tests that exercise cross-user access scenarios further reduce the risk of reintroducing this class of vulnerability.

Find out what's already
exploitable in your codebase.