Summary
OpenObserve versions 0.70.3 and earlier contain a server-side request forgery (SSRF) flaw in the validate_enrichment_url function, where IPv6 addresses are not properly blocked due to bracketed URL parsing behavior.
An authenticated attacker can abuse this to make the server initiate HTTP requests to internal or metadata services, potentially exposing cloud IAM credentials or enabling internal network probing.
Affected context
This vulnerability appears in OpenObserve deployments where enrichment URLs are accepted from authenticated users and validated using validate_enrichment_url in src/handler/http/request/enrichment_table/mod.rs.
The validation logic is intended to prevent access to internal and metadata endpoints, but when parsing host components for IPv6 addresses, the Rust url crate returns bracketed forms (e.g., [::1]). The filter logic does not correctly handle these forms, allowing some internal or otherwise blocked destinations to pass validation.
The risk is highest in:
- Cloud environments where metadata services (AWS IMDS, GCP, Azure) are reachable
- Self-hosted environments where OpenObserve can reach internal-only services
Exploit preconditions
- Attack surface: HTTP API endpoints that accept user-controlled enrichment URLs.
- Required access: Valid authenticated user account capable of configuring or providing enrichment URLs.
- Trigger point: Submission or update of an enrichment URL that resolves to internal or metadata IP addresses, particularly those expressed in ways that bypass the filter (e.g., IPv6/IPv4 mapping or bracketed hosts).
- Why exploitation is possible: The host validation logic assumes a specific representation of addresses and does not account for the bracketed IPv6 format returned by the
urlcrate, allowing requests to be constructed and sent by the server to internal targets that should be blocked.
Why this happens
The issue stems from incomplete validation of server-initiated HTTP targets, a hallmark of server-side request forgery (SSRF) cataloged as CWE-918.
The validate_enrichment_url function attempts to block access to sensitive internal addresses (such as cloud metadata services or loopback interfaces) by examining the parsed URL host. However, it relies on string comparisons that fail to normalize or correctly interpret bracketed IPv6 (and related) address forms returned by the url crate (e.g., [::1] instead of ::1).
This mismatch between expected and actual host representations leads to a logic gap where certain internal destinations are not recognized as restricted and are therefore permitted, allowing the application to act as a proxy to otherwise protected endpoints.
Potential impact
- Retrieval of cloud instance metadata, including IAM or service account credentials, via:
- AWS IMDSv1 (169.254.169.254)
- GCP metadata server
- Azure IMDS endpoints
- Use of obtained credentials to access additional cloud resources, depending on attached roles and permissions.
- Internal network reconnaissance by probing internal services that are not externally exposed.
- Potential pivoting into internal applications, APIs, or management interfaces reachable from the OpenObserve host.
- Increased blast radius in case of compromised application-level accounts, as the server becomes a network pivot point.
General mitigation guidance
Effective mitigation focuses on robust target validation and network-layer defense-in-depth:
- Normalize and strictly validate destination hosts and IPs before allowing any outbound request, including consistent handling of IPv4, IPv6 (with brackets), and hostname resolution.
- Implement allowlists for enrichment destinations (e.g., specific domains or service endpoints) instead of trying to maintain blocklists of internal or metadata addresses.
- Resolve hostnames and check the resulting IP addresses (including all DNS results) against private, loopback, link-local, and metadata address ranges before making a request.
- Enforce network-level controls (firewalls, security groups, egress rules) that prevent the application from reaching metadata services and sensitive internal subnets where feasible.
- Use least privilege for any cloud instance roles to minimize impact if metadata access is accidentally exposed.
These measures reduce the risk of SSRF and limit the consequences even if an application-level filter is bypassed.
How teams detect issues like this
Detection can combine code-level analysis with runtime monitoring:
- Static analysis and code review:
- Flag code paths where user-controlled URLs are used in outbound HTTP requests.
- Look for validation routines using simple string prefix or equality checks on hosts or IPs without proper normalization, DNS resolution, or IP range checks.
- Verify that IPv6, bracketed addresses, and hostname-to-IP resolution are consistently handled in validation logic.
- Security testing:
- Perform application security tests with crafted URLs targeting loopback, link-local, and metadata addresses in various encodings (IPv4, IPv6, hostnames).
- Runtime monitoring:
- Monitor outbound HTTP traffic from OpenObserve instances for requests to metadata IPs (
169.254.169.254and provider-specific metadata hostnames) or unexpected internal ranges. - Use egress filtering logs and network observability tools to alert on suspicious internal destinations requested by the application.
Automated SAST/DAST tools and CI-integrated security scanners can help consistently identify SSRF patterns and regressions.

