Summary
A server-side request forgery (SSRF) vulnerability in OpenCTI's data ingestion feature allows user-supplied URLs to be requested by the server without proper validation.
Because Axios is used with its default configuration and accepts absolute URLs, an attacker can cause OpenCTI to issue semi-blind HTTP requests to arbitrary internal or external endpoints, potentially impacting internal services even if full responses are not exposed.
Affected context
The vulnerability occurs in OpenCTI deployments where the data ingestion feature accepts user-provided URLs that are subsequently requested from the server environment.
It is relevant when:
- The OpenCTI instance can reach internal services or metadata endpoints (e.g., within a VPC, cluster network, or corporate intranet)
- URL parameters are not constrained to specific domains, protocols, or IP ranges
- The Axios HTTP client is used with default settings that allow absolute URLs and automatic following of user-specified destinations
Exploit preconditions
- Attack surface: OpenCTI data ingestion interface or any API/feature that accepts user-supplied URLs for retrieval.
- Required access: Ability to submit or control the URL value processed by the ingestion mechanism (e.g., authenticated OpenCTI user or integrated system, depending on deployment).
- Trigger point: The server-side logic that uses Axios to fetch the provided URL for ingestion or processing.
- Why exploitation is possible: The URL parameter is treated as fully trusted input, and Axios is configured to allow absolute URLs without restricting target hosts, networks, or protocols. This enables the server to initiate outbound HTTP requests to attacker-chosen destinations, including internal addresses not normally exposed.
Why this happens
The underlying bug class is Server-Side Request Forgery (SSRF), mapped to CWE-918.
The application takes a URL provided by a user and forwards it directly to Axios for retrieval using default options (allowAbsoluteUrls: true) without:
- Validating allowed domains or IP ranges
- Enforcing scheme restrictions
- Normalizing and re-validating redirects or rewritten URLs
This pattern allows an attacker to pivot through the OpenCTI server to reach network locations that are otherwise inaccessible, using the server as a proxy for their traffic.
Potential impact
- Access to internal HTTP services that are not exposed to the public internet (e.g., admin panels, management APIs, databases with HTTP interfaces)
- Interaction with cloud instance metadata services, potentially leading to credential exposure or configuration leakage, depending on environment
- Port scanning and service discovery on internal networks via response behavior, timing differences, or error messages
- Triggering state-changing actions on internal APIs (e.g., configuration changes, job execution, or data modification) when internal endpoints accept unauthenticated or weakly protected requests
- Assistance in lateral movement or further exploitation when combined with other vulnerabilities or misconfigurations
General mitigation guidance
Effective mitigation focuses on tightening how URLs are handled and reducing the server's ability to act as an uncontrolled proxy:
- Introduce strict allow-lists for outbound requests, limiting ingestion targets to known-safe domains or specific endpoints.
- Enforce URL validation and normalization before use, including checks on scheme (e.g., only
https/http), hostnames, and resolved IP addresses. - Block or restrict requests to:
- Private and link-local address ranges (e.g.,
127.0.0.0/8,10.0.0.0/8,169.254.0.0/16,192.168.0.0/16) - Metadata and management endpoints (e.g., common cloud provider metadata IPs)
- Apply network-layer egress controls (firewalls, security groups, proxies) so application servers can only reach required external services.
- Separate high-privilege or sensitive internal services from general application traffic, using segmentation and dedicated networks.
- Consider using a hardened HTTP client configuration with explicit rules for redirects, absolute URLs, and forbidden destination ranges.
How teams detect issues like this
Detection generally combines application-level review with infrastructure monitoring:
- Static analysis and code review:
- Flag code paths where untrusted URL input is passed directly into HTTP clients (such as Axios,
fetch, or similar libraries). - Look for lack of checks on host, scheme, and resolved IP, or absence of allow/deny lists around outbound requests.
- Review configuration defaults for HTTP clients to ensure that absolute URL handling and redirect behavior are constrained.
- Logging and monitoring:
- Log inbound URL parameters and outbound HTTP request targets from ingestion features.
- Monitor for unusual patterns such as requests to internal IP ranges, metadata endpoints, or non-standard ports.
- Network controls and observability:
- Use egress firewalls, service meshes, or gateway proxies that can enforce outbound policies and generate alerts on violations.
- Periodically run security tests that attempt to reach protected internal resources via application endpoints to validate defenses.

