/

CVE-2026-22805

Severity:

HIGH RISK

(8.6)

SSRF in Metabase Self-Hosted Deployments

CVE-2026-22805

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Unauthorized Access to Internal Services

Severity:

HIGH RISK

(8.6)

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

Certain self-hosted Metabase instances that allow users to create subscriptions can be abused to make the server issue HTTP requests to other services it can reach.

When Metabase is colocated with other unsecured internal resources, an attacker may pivot through the Metabase server to interact with those resources via server-side request forgery (SSRF).

Affected context

This vulnerability affects self-hosted Metabase installations where:

  • Users are allowed to create or manage subscriptions (for example, email or webhook-based dashboard/report deliveries).
  • The Metabase server is deployed in an environment that is colocated with other internal or otherwise unsecured resources, such as internal APIs, admin panels, metadata services, or cloud control endpoints.
  • Network controls primarily trust traffic originating from the Metabase host or local network segments.

Under these conditions, subscription features can be misused to direct the Metabase server to initiate outbound requests to targets that are not directly reachable from the attacker's own network.

Exploit preconditions

  • Attack surface: Metabase's subscription creation or management interfaces in self-hosted deployments.
  • Required access: Ability to authenticate and create or modify subscriptions, or access to any exposed interface that accepts subscription destination details.
  • Network layout: Metabase must have network-level reachability to internal or colocated services that are not exposed to the public Internet, and those services must lack sufficient authentication or request validation.
  • Trigger point: The moment a subscription runs (e.g., scheduled dashboard delivery) or when Metabase processes the subscription's delivery endpoint or resource reference.
  • Why exploitation is possible: The subscription mechanism can be influenced to cause Metabase to send server-side HTTP(S) requests, and insufficient validation or restriction on target addresses or protocols enables SSRF-style abuse.

Why this happens

The core issue maps to CWE-918: Server-Side Request Forgery (SSRF), where a backend component is tricked into making arbitrary network requests on behalf of an attacker.

In this case, subscription functionality implicitly trusts user-supplied or user-controlled configuration (such as endpoints or locations to contact) and uses the Metabase server's own network position and credentials to perform requests.

Without rigorous validation of destination addresses, schemes, and resource scopes—and without strict separation between user-controlled configuration and internal network access—an attacker can coerce the server into acting as a proxy into otherwise inaccessible network zones.

Potential impact

  • Unauthorized interaction with internal or colocated services that are not exposed externally.
  • Access to sensitive configuration or operational metadata from internal endpoints.
  • Abuse of internal HTTP APIs to manipulate data, trigger administrative actions, or reconfigure services.
  • Use of Metabase as a pivot point for network reconnaissance inside the hosting environment.
  • Potential chaining with other weaknesses in internal services, leading to broader compromise.

General mitigation guidance

Effective mitigation centers on reducing trust in user-controlled network destinations and hardening network boundaries:

  • Apply strict allowlists for outbound network requests originating from subscription or reporting features, limiting them to known-safe domains or services.
  • Block or strongly restrict access from Metabase to sensitive internal infrastructure (e.g., metadata services, control plane APIs, admin interfaces) at the network layer using firewall rules or service mesh policies.
  • Introduce robust URL and address validation in subscription configuration paths, rejecting private IP ranges, link-local addresses, and non-HTTP(S) schemes where not explicitly required.
  • Separate Metabase from highly sensitive systems using network segmentation, ensuring that compromise or misuse of Metabase cannot directly reach critical management or data services.
  • Run Metabase with least-privilege network and identity permissions, avoiding default access to high-privilege cloud or platform control endpoints.

How teams detect issues like this

High-level detection practices for this class of SSRF risk include:

  • Reviewing application code paths where user-controlled configuration (such as subscription endpoints or hooks) is used to construct outbound HTTP requests, paying attention to missing or weak validation of hostnames, IPs, and protocols.
  • Using static analysis to flag generic HTTP client usage that consumes user-supplied URLs without filtering for internal IP ranges or disallowed schemes.
  • Implementing logging and monitoring of outbound requests from Metabase, with alerts for connections to unexpected RFC1918 or link-local addresses, cloud metadata IPs, or internal-only domain names.
  • Enforcing security policies in infrastructure-as-code or deployment tooling that restrict egress access from Metabase pods/hosts to only those destinations required for normal operation.
  • Periodically conducting network-level tests or red-team style exercises to verify that application features like subscriptions cannot be abused as SSRF channels.

Sources

SourceLink
github.comgithub.com/metabase/metabase/security/advisories/GHSA-2wgg-7r2p-cmqx

Frequently asked

questions

It can be, if an attacker can reach a Metabase instance that exposes subscription functionality and can authenticate or otherwise interact with it. However, the SSRF impact is primarily on internal or colocated resources reachable from Metabase, not necessarily on the Metabase UI itself.

Typically yes, because creating or configuring subscriptions is usually an authenticated action. The exact requirement depends on how access control and user roles are configured in the Metabase deployment.

The most robust approach is to combine strict server-side validation of all user-influenced network destinations with strong network egress controls. Constraining the set of allowed outbound hosts and rejecting internal address ranges substantially reduces SSRF risk.

Treat all user-controlled URLs and network targets as untrusted input, enforce conservative allowlists, and ensure that sensitive internal services are never directly reachable from application tiers used for user-driven features like subscriptions or webhooks. Regular code review and security testing focused on outbound request flows can further reduce the chance of reintroducing SSRF vulnerabilities.

Find out what's already
exploitable in your codebase.