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.

