/

CVE-2026-76820

Severity:

HIGH RISK

(7.7)

Server-Side Request Forgery (CWE-918) in OpenCTI Sync

CVE-2026-76820

Awaiting Analysis

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Internal Network Scanning and Information Disclosure

Severity:

HIGH RISK

(7.7)

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

OpenCTI contains a server-side request forgery vulnerability in the synchronizerFetch GraphQL query, where authenticated users with the INGESTION capability can influence outbound requests to internal destinations. An attacker may scan internal services, access cloud metadata endpoints, or disclose data from compatible internal services when only HTTP or HTTPS URL schemes are checked.

Affected context

The issue occurs in OpenCTI deployments using the synchronizerFetch GraphQL query before the affected fix level. The backend accepted remote stream URLs based primarily on their HTTP or HTTPS scheme, without consistently applying ingestion deny-list rules or rejecting private, loopback, and link-local destinations. Risk depends on whether an authenticated account has the INGESTION capability and whether internal services respond to requests from the OpenCTI backend.

Exploit preconditions

  • Attack surface: The synchronizerFetch GraphQL query and its remote stream fetching functionality
  • Required access: An authenticated OpenCTI account with the INGESTION capability
  • Trigger point: Processing a supplied remote stream URL through the backend fetch operation
  • Why exploitation is possible: URL scheme validation does not adequately constrain destination addresses, allowing requests toward private, loopback, link-local, or other internal endpoints

Why this happens

The vulnerability results from incomplete server-side request validation. The application checked whether a remote stream URL used HTTP or HTTPS but did not sufficiently enforce destination-based network policy, apply the ingestion deny list, or block internal address ranges before making the backend request. This behavior maps to CWE-918: Server-Side Request Forgery, where attacker-influenced server-side requests can reach resources that should not be exposed through the application.

Potential impact

  • An attacker may probe internal hosts and distinguish open HTTP, open non-HTTP, and closed ports
  • Internal service responses could be disclosed when they are compatible with the fetch process
  • Cloud instance metadata or other link-local services could be queried
  • Internal network topology and service availability could be exposed
  • In some environments, reachable administrative services could be targeted for further compromise

General mitigation guidance

Mitigation generally focuses on enforcing destination-aware outbound request controls rather than relying only on URL schemes.

Common defensive patterns include:

  • Allowing requests only to explicitly approved external destinations where practical
  • Blocking loopback, private, link-local, multicast, and reserved address ranges after DNS resolution
  • Applying the same deny lists and network policies to every ingestion and synchronization path
  • Rechecking destinations after redirects and accounting for DNS rebinding and alternate address representations
  • Restricting backend egress with network controls and cloud metadata-service protections
  • Running the application with least-privilege access to internal services
  • Returning uniform errors that do not reveal distinctions between reachable and unreachable internal ports

How teams detect issues like this

Organizations can look for SSRF risks through:

  • Static analysis rules identifying user-controlled URLs passed to HTTP clients
  • Code review checks for scheme-only validation, missing redirect validation, and unresolved DNS or IP range checks
  • Tests covering loopback, private, link-local, IPv4-mapped IPv6, redirect, and DNS-rebinding destinations
  • Egress firewall and proxy logs showing application requests to internal address ranges or metadata endpoints
  • GraphQL audit logs correlating synchronizerFetch activity with accounts holding ingestion privileges
  • Policy enforcement that requires approved destination lists and blocks unrestricted server-side outbound access

Automated application security and code review tools may help identify URL-fetching paths, but network-level monitoring remains important.

Sources

SourceLink
github.comgithub.com/OpenCTI-Platform/opencti/commit/6c1114ce8ce8f3a9d9b8c82dfff3a3a462e5dc1f
github.comgithub.com/OpenCTI-Platform/opencti/pull/16617
github.comgithub.com/OpenCTI-Platform/opencti/releases/tag/7.260701.0
github.comgithub.com/OpenCTI-Platform/opencti/security/advisories/GHSA-f6pj-3m32-q934

Frequently asked

questions

It can be exploitable through the OpenCTI application interface when an attacker can authenticate and use a capability that permits ingestion or synchronizer operations. The attacker does not necessarily need direct network access to the targeted internal services.

The described attack requires an authenticated account with the INGESTION capability. The practical impact also depends on which destinations the OpenCTI backend can reach and what those services return.

Enforce destination-aware SSRF protections, including allowlisted outbound destinations where feasible, blocking internal address ranges, validating resolved addresses and redirects, and applying restrictive egress controls.

Treat all user-influenced URLs as untrusted, centralize secure outbound-request handling, test private and link-local destinations, limit ingestion privileges, and monitor application egress for unexpected internal requests.

Find out what's already
exploitable in your codebase.