/

CVE-2026-35210

Severity:

HIGH RISK

(7.1)

AuthZ Bypass (CWE-639) in OpenCTI Confidence Controls

CVE-2026-35210

Analyzed

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-639, CWE-863

Impact:

Integrity and Confidentiality Compromise of Threat Intelligence Data

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

An authorization bypass in OpenCTI lets users with KNOWLEDGE_KNUPDATE permission circumvent confidence level and object marking enforcement by adding a special HTTP header. Under these conditions, an attacker can downgrade confidence levels, strip sensitive markings like TLP:RED, and modify relationships across multiple STIX object types.

Affected context

This vulnerability appears in OpenCTI deployments where authenticated users can perform knowledge updates and where server-side authorization checks are not consistently enforced across all update paths. It specifically concerns API requests that honor the synchronized-upsert: true HTTP header, allowing those requests to skip normal validation of confidence levels and security markings. The issue is most relevant in environments that rely on STIX object markings and confidence scores to control sensitive data distribution and analytical trust.

Exploit preconditions

  • Attack surface: OpenCTI HTTP API endpoints that process STIX object updates and upserts.
  • Required access: Any authenticated account holding KNOWLEDGE_KNUPDATE permission or equivalent update capabilities.
  • Trigger point: Sending update or upsert requests with the synchronized-upsert: true header set, targeting objects such as Indicators, ThreatActors, Malware, or Reports.
  • Why exploitation is possible: The presence of the special header causes the application to bypass or weaken confidence level validation and object marking restrictions, meaning authorization checks are not consistently applied for all update modes.

Why this happens

The underlying issue stems from inconsistent authorization enforcement across different API execution paths. When the synchronized-upsert: true header is present, the system follows a specialized synchronization/upsert flow where trust and marking controls are either omitted or applied incorrectly. This maps to CWE-639: Insecure Direct Object Reference and CWE-863: Incorrect Authorization, as the application allows users with general update permissions to perform privileged operations (changing confidence and removing sensitive markings) on STIX objects without verifying whether they are authorized to override those specific attributes. The design treats a client-controlled header as a trustworthy signal for bypassing normal policy checks, rather than deriving privileges from server-side configuration and role-based rules.

Potential impact

  • Attackers may downgrade confidence levels on Indicators, ThreatActors, Malware, and Reports, undermining analytic reliability.
  • Attackers could remove or alter object markings such as TLP:RED, leading to unauthorized broader distribution of sensitive intelligence.
  • Threat intelligence relationships may be manipulated, potentially obscuring or fabricating links between entities.
  • Security teams can be misled by falsified or weakened data, impacting incident response, attribution, and strategic decision-making.
  • Sharing partners and integrated tooling may consume corrupted or misclassified STIX data, spreading misinformation across ecosystems.

General mitigation guidance

Mitigation typically involves tightening authorization boundaries around object attributes and ensuring that every update path enforces the same policy rules. Defensive patterns include:

  • Centralizing authorization and validation logic so that all API flows, including special synchronization/upsert modes, call the same enforcement layer for confidence levels and markings.
  • Treating client-controlled headers and parameters as untrusted hints, not as triggers for bypassing security checks or approval workflows.
  • Applying fine-grained permission models where overrides to confidence levels and sensitive markings require explicit, elevated privileges separate from general update rights.
  • Implementing server-side policy definitions for marking and confidence rules that cannot be altered or skipped by request metadata.
  • Using least-privilege principles so that routine knowledge editors cannot change distribution markings or downgrade analytic trust without review.

How teams detect issues like this

Detection efforts can focus on both code and runtime behavior:

  • Static analysis and manual review to identify API handlers where authorization is conditional on request headers or client flags instead of role-based checks.
  • Code review policies that flag any logic path which skips or duplicates validation for confidence levels, markings, or other critical attributes.
  • Logging and monitoring of update requests that include special headers like synchronized-upsert, correlating them with changes to markings and confidence fields for anomaly detection.
  • Periodic audits of STIX objects to identify unexpected confidence downgrades, removal of sensitive markings, or unusual relationship changes originating from non-privileged accounts.
  • Integrating automated security testing tools that exercise different update modes and verify that authorization and marking rules are consistently enforced.

Sources

SourceLink
github.comgithub.com/OpenCTI-Platform/opencti/commit/134531ddf5ecf741006b7f0870b7c36711b96540
github.comgithub.com/OpenCTI-Platform/opencti/pull/14243
github.comgithub.com/OpenCTI-Platform/opencti/releases/tag/7.260326.0
github.comgithub.com/OpenCTI-Platform/opencti/security/advisories/GHSA-36fr-4m54-94mj

Frequently asked

questions

Any authenticated user with KNOWLEDGE_KNUPDATE or similar update permissions can potentially exploit the issue by crafting API requests that include the special header, even if they are not supposed to alter confidence levels or sensitive markings.

Not necessarily. The vulnerability affects users who have standard knowledge update rights, meaning exploitation can occur from non-admin accounts as long as they can send crafted HTTP requests to the API.

The most robust fix pattern is to centralize and enforce consistent authorization checks for all update paths and to ensure that privilege decisions are based solely on server-side role and policy evaluation, never on client-provided headers or flags. Attribute-level controls should guard sensitive fields like confidence and markings regardless of how the update is initiated.

Prevention strategies include designing APIs so that special modes (synchronization, bulk upsert, migration) reuse the same authorization and validation pipeline as standard operations, avoiding conditional shortcuts; establishing coding standards that forbid using client-controlled headers for security decisions; and regularly performing access control reviews and targeted security testing of all object update endpoints.

Find out what's already
exploitable in your codebase.