/

CVE-2026-27960

Severity:

CRITICAL RISK

(9.8)

Improper Authentication in OpenCTI API

CVE-2026-27960

Analyzed

Vulnerability type

Category:

Improper Authentication

CWE:

CWE-287

Impact:

Authentication Bypass and Privilege Escalation to Administrator

Severity:

CRITICAL RISK

(9.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

A critical authentication flaw in OpenCTI versions 6.6.0 through 6.9.12 allows unauthenticated attackers to query the API while impersonating any existing user account, including the default administrator.

When exposed over a network, this can effectively bypass login controls and grant full administrative access to threat intelligence data and platform configuration.

Affected context

This vulnerability affects OpenCTI deployments running versions 6.6.0 through 6.9.12 where the API is reachable by untrusted clients (e.g., internet-facing instances or internal services without strict network segmentation).

The issue manifests at the authentication layer of the OpenCTI API, allowing crafted requests to be treated as if they were authenticated as any existing user, including the default admin account.

It is particularly concerning in environments where the default administrator account remains enabled and holds broad management privileges over the platform and its data.

Exploit preconditions

  • Attack surface: OpenCTI HTTP API endpoints exposed over the network.
  • Required access: Network-level access to the OpenCTI API; no valid user credentials are required.
  • Trigger point: Sending specially crafted API requests that exploit flaws in how user identity is established or verified.
  • Why exploitation is possible: The authentication mechanism does not correctly validate or bind the claimed user identity to a proven credential or session state, allowing an attacker to be treated as an arbitrary existing user.

Why this happens

The root cause aligns with CWE-287: Improper Authentication, where the system fails to robustly verify that an actor is who they claim to be before granting access.

In this case, the OpenCTI API performs insufficient checks when associating incoming requests with user accounts, allowing an attacker to bypass normal login flows and effectively "attach" to an existing user identity.

This may involve trusting client-controlled parameters, weak token validation, or missing linkage between session artifacts and authenticated principals, resulting in arbitrary user impersonation including the high-privilege default admin.

Potential impact

  • Complete impersonation of any existing user, including the default administrator.
  • Unauthorized access to sensitive cyber threat intelligence data, observables, and reports.
  • Modification or deletion of threat intelligence knowledge, including indicators, relationships, and analysis artifacts.
  • Creation of new high-privilege accounts or API tokens to maintain long-term access.
  • Tampering with platform configuration, integrations, and automation workflows.
  • Use of the compromised platform as a pivot point to influence other integrated security systems.

General mitigation guidance

Effective mitigation focuses on hardening authentication flows and minimizing the blast radius of any single account:

  • Ensure that user identity is always derived from strongly validated credentials or tokens, not from client-supplied identifiers or untrusted headers.
  • Enforce strict binding between sessions, tokens, and user identities, including signature verification, expiration, and revocation mechanisms.
  • Disable or strictly control any default or bootstrap admin accounts once an environment is provisioned; treat them as temporary setup identities rather than long-lived users.
  • Apply least-privilege principles to all roles so that a single account compromise does not expose full administrative capabilities where not strictly required.
  • Restrict network exposure of the OpenCTI API using firewalls, VPNs, or reverse proxies, limiting access to trusted networks and services.
  • Introduce defense-in-depth controls such as multi-factor authentication and IP-based access controls for high-privilege operations where feasible.

How teams detect issues like this

Organizations can identify and monitor for improper authentication issues through:

  • Static analysis and code review focused on authentication and authorization boundaries, looking for:
  • Direct use of user IDs or roles supplied by the client.
  • Trust in unauthenticated headers or query/body parameters to establish identity.
  • Missing verification steps in token parsing or session retrieval.
  • Security testing and API-focused penetration tests that:
  • Attempt to call privileged endpoints without valid credentials.
  • Try to replay or manipulate identity-related fields to impersonate other users.
  • Runtime monitoring and logging that:
  • Correlates authentication events with subsequent API use and flags anomalies (e.g., admin actions without corresponding login).
  • Alerts on API access patterns from unauthenticated or unexpected sources performing high-privilege operations.
  • Use of automated API security scanners or rules in web application firewalls (WAF) to flag suspicious authentication flows and unexpected privilege levels in requests.

Sources

SourceLink
github.comgithub.com/OpenCTI-Platform/opencti/security/advisories/GHSA-6vvv-vmfr-xhrx

Frequently asked

questions

Yes. If the OpenCTI API is accessible over a network to an attacker, the flaw can be exploited remotely without prior authentication.

No. The vulnerability allows unauthenticated users to issue API queries as existing accounts, including the default admin, so valid credentials are not required.

The safest pattern is to enforce strict, centralized authentication where every request to protected endpoints must present a cryptographically strong, verifiable credential or token that is tightly bound to a single user identity, and to avoid trusting any identity-related data from the client without verification.

Build and review authentication and authorization as dedicated components, use well-vetted frameworks for session and token management, perform regular security testing of login and impersonation scenarios, minimize or disable default high-privilege accounts, and enforce least-privilege roles combined with network-layer protections for administrative APIs.

Find out what's already
exploitable in your codebase.