/

CVE-2026-39361

Severity:

HIGH RISK

(7.7)

SSRF in OpenObserve Enrichment URL Validation

CVE-2026-39361

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal services and potential cloud credential exposure

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

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 url crate, 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.254 and 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.

Sources

SourceLink
github.comgithub.com/openobserve/openobserve/commit/d1a5d8f65b432e2e82f83231390dec7f107e8d75
github.comgithub.com/openobserve/openobserve/security/advisories/GHSA-gcwf-3p7h-wm79

Frequently asked

questions

Exploitation typically requires an authenticated user who can submit or configure enrichment URLs. Once that condition is met, the attack surface includes any internal or metadata endpoints reachable from the OpenObserve environment.

The attacker needs whatever level of access is sufficient to control enrichment URLs. In many setups, this may be available to non-admin users who can define or modify enrichment configurations.

Adopt an allowlist-based approach for outbound enrichment destinations, normalize and resolve all hostnames/IPs before making requests, and reject any URL that resolves to private, loopback, link-local, or metadata address ranges. Combine this with network-layer egress controls to sensitive endpoints.

Treat all user-supplied URLs as untrusted, design outbound HTTP features with SSRF in mind from the outset, centralize and harden URL validation logic (including IPv4/IPv6 and DNS handling), enforce strict egress rules, and incorporate SSRF-specific checks into code review and automated security testing pipelines.

Find out what's already
exploitable in your codebase.