/

CVE-2025-61781

Severity:

HIGH RISK

(7.1)

Authorization Bypass in OpenCTI GraphQL Mutation

CVE-2025-61781

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-285, CWE-566, CWE-915, CWE-863

Impact:

Unauthorized Data Deletion and Workspace Takeover

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

A missing authorization check in the WorkspacePopoverDeletionMutation GraphQL mutation in OpenCTI allows a user to delete workspace-related objects, including entire workspaces, that they do not own.

By providing the UUID of another user's workspace, an attacker can trigger unauthorized deletions because the API does not validate resource ownership before performing the operation.

Affected context

This vulnerability occurs in OpenCTI deployments where the WorkspacePopoverDeletionMutation GraphQL mutation is exposed to authenticated users and is used to manage dashboards, investigation cases, and related workspace objects.

The issue is present when:

  • Workspace deletion operations are tied to user-specific resources
  • The API relies on client-supplied identifiers (UUIDs) to select the target workspace
  • The server does not enforce ownership or fine-grained authorization before performing destructive operations

Exploit preconditions

  • Attack surface: OpenCTI GraphQL API, specifically the WorkspacePopoverDeletionMutation mutation.
  • Required access: Authenticated access with any account that can invoke the mutation (even with limited privileges).
  • Prerequisites: Knowledge or discovery of a valid, active UUID referencing another user's workspace or workspace-related object.
  • Trigger point: Sending a GraphQL mutation request with a target UUID that belongs to another user's workspace.
  • Why exploitation is possible: The server-side logic checks that the requester is authenticated and the UUID is valid, but does not verify that the requester owns or is authorized to manage the targeted workspace, allowing cross-tenant or cross-user deletion.

Why this happens

The core issue is a missing or incomplete authorization control on a sensitive operation: workspace deletion.

Instead of deriving the target resource from the authenticated user's context or verifying that the user has appropriate ownership or role-based permissions, the mutation trusts the client-supplied UUID and executes the deletion if the resource exists.

This aligns with CWE-285: Improper Authorization and CWE-566: Authorization Bypass Through User-Controlled Key, where user-controlled identifiers are used to access or modify resources without enforcing access control rules.

The bug is logical rather than technical—no checks are made to restrict the scope of deletion to resources associated with the caller's identity.

Potential impact

  • Deletion of other users' workspaces, dashboards, and investigation cases.
  • Loss of critical threat intelligence data and analytic artifacts.
  • Disruption of ongoing investigations or SOC workflows.
  • Potential for multi-tenant data impact if multiple teams or organizations share an instance.
  • Erosion of auditability and trust in the platform due to unexpected data loss.

General mitigation guidance

Effective mitigation focuses on enforcing server-side authorization for all resource-scoped operations:

  • Implement strict ownership checks for workspace and workspace-related operations, ensuring that only authorized users (owners or appropriately privileged roles) can delete a given resource.
  • Use role-based or attribute-based access control models where workspace operations are gated by permissions derived from the authenticated user's identity and group memberships.
  • Avoid relying solely on client-supplied identifiers; where possible, derive the target scope from the user context or validate that the provided UUID is attached to a resource the caller is allowed to manage.
  • Centralize authorization logic so that all GraphQL mutations and REST endpoints reuse consistent permission checks, reducing the risk of missing controls in individual operations.
  • Apply the principle of least privilege to mutation capabilities, limiting who can initiate destructive actions such as deletions.

How teams detect issues like this

Detecting this class of issue typically involves both code-centric and behavior-centric approaches:

  • Static analysis and code review:
  • Flag GraphQL mutations and REST endpoints that perform destructive or privilege-sensitive actions without explicit authorization checks tied to the authenticated user.
  • Look for patterns where resource access is driven by user-supplied identifiers (UUIDs, IDs) without subsequent ownership or permission verification.
  • Ensure that all mutations use shared authorization middleware or decorators, and highlight exceptions.
  • Automated policy enforcement:
  • Integrate security linters or SAST tools that recognize common access-control frameworks and can warn when they are not applied to certain routes or resolvers.
  • Enforce architectural policies that every resolver handling deletions or updates must call a standard authorization function.
  • Runtime and logging analysis:
  • Monitor logs for deletion events where the acting user is not typically associated with the target workspace or where a single account deletes multiple unrelated users' workspaces.
  • Set alerts for anomalous spikes in destructive operations that may indicate abuse of missing authorization controls.

Sources

SourceLink
github.comgithub.com/OpenCTI-Platform/opencti/security/advisories/GHSA-pr6m-q4g7-342c

Frequently asked

questions

Yes. Any remote user who can authenticate to the OpenCTI instance and invoke the affected GraphQL mutation can attempt to exploit the issue, provided they can obtain or guess valid workspace UUIDs.

Not necessarily. Exploitation may be possible with a low-privileged account as long as it is permitted to call the WorkspacePopoverDeletionMutation mutation; the vulnerability stems from inadequate authorization checks, not from over-privileged roles.

Apply strict, centralized authorization checks to all workspace-scoped operations.

For deletion mutations, ensure the server verifies that the authenticated user owns the resource or has the requisite role before performing the action, using a standard access-control layer rather than ad-hoc checks.

Adopt a consistent access-control strategy where every GraphQL resolver or endpoint:

  • Derives permissions from the authenticated user's identity and roles,
  • Uses a shared authorization component or middleware,
  • Is covered by tests that verify unauthorized users cannot access or modify others' resources.

Combine this with code review checklists and automated tooling that highlight any mutation or endpoint performing sensitive operations without explicit authorization enforcement.

Find out what's already
exploitable in your codebase.