Severity:

HIGH RISK

(7.3)

SSRF in Appsmith Dashboard WebClientUtils

CVE-2026-5418

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Server-Side Network Access

Severity:

HIGH RISK

(7.3)

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

A server-side request forgery vulnerability in Appsmith up to version 1.97 allows abuse of the computeDisallowedHosts logic in WebClientUtils to bypass host restrictions for outbound HTTP requests made by the Dashboard component.

Under certain conditions, a remote attacker can coerce the server to initiate HTTP requests to arbitrary internal or external endpoints, potentially reaching systems that are not directly exposed to the internet.

Affected context

The vulnerability exists in Appsmith deployments using the Dashboard functionality that relies on WebClientUtils.computeDisallowedHosts to enforce restrictions on outbound HTTP calls.

It is relevant in scenarios where:

  • The server initiates HTTP requests to user-controlled or partially user-influenced URLs
  • Network access from the Appsmith server to internal services, metadata endpoints, or other protected resources is possible
  • Relying code assumes computeDisallowedHosts correctly prevents access to restricted hosts or networks

The issue does not inherently expose services by itself but becomes risky when outbound requests are made on behalf of users.

Exploit preconditions

  • Attack surface: HTTP endpoints in the Appsmith Dashboard that trigger outbound HTTP requests based on user-supplied or configurable URLs.
  • Required access: Network access to the Appsmith instance (typically authenticated application or API access, depending on how dashboard features are exposed).
  • Trigger point: Supplying crafted hostnames, URLs, or redirection patterns that cause computeDisallowedHosts to misclassify or fail to block disallowed targets.
  • Why exploitation is possible: The disallowed host computation logic is incomplete or flawed, allowing attackers to bypass intended network egress restrictions and cause the server to connect to attacker-chosen destinations.

Why this happens

This issue is a logic flaw in host validation and network egress control within the computeDisallowedHosts function of WebClientUtils.

Instead of treating user-influenced URLs as untrusted and validating them against a robust, deny-by-default policy (including IP resolution, DNS rebinding awareness, and normalization), the implementation likely uses incomplete checks such as:

  • Relying on string comparisons of hostnames without canonicalization
  • Not correctly handling redirects, DNS-resolved IPs, or alternative address notations (e.g., IPv6, 127.0.0.1 variants)
  • Assuming that certain host or domain patterns are sufficient to block access

This maps to CWE-918: Server-Side Request Forgery (SSRF), where an attacker controls or influences a server-side HTTP client to perform requests to unintended internal or external systems.

Potential impact

  • The server may send HTTP requests to internal services that are not directly exposed to the internet.
  • Attackers could probe internal network topology and service availability through response behavior.
  • Sensitive metadata services (such as cloud instance metadata endpoints) could be accessed, potentially leaking credentials or configuration.
  • Internal HTTP-based administrative interfaces, databases, or APIs could be reached and abused depending on their own protections.
  • The application server may be leveraged as a pivot point for further attacks into the internal network.

General mitigation guidance

Effective mitigation centers on treating all user-influenced URLs as untrusted and enforcing hardened egress controls:

  • Apply a strict allowlist of permitted destinations for all server-initiated HTTP requests, especially within dashboard or integration features.
  • Normalize and canonicalize URLs (including following DNS resolution) before validation, ensuring checks are performed on the final host/IP, not just the original string.
  • Block access to link-local, loopback, private, and metadata IP ranges by default unless there is a compelling, narrowly scoped business need.
  • Separate network roles: place the application server in a network segment with limited egress to internal resources, and minimize its direct access to sensitive internal services.
  • Implement least-privilege principles for any credentials or tokens that might be exposed via SSRF-accessible services, reducing the blast radius if SSRF occurs.

How teams detect issues like this

SSRF issues can be surfaced using a combination of code-centric and operational approaches:

  • Static analysis and code review:
  • Flag any use of HTTP client utilities where destination URLs are derived from request parameters, configuration fields, or user-controlled data.
  • Look for custom host validation functions (like computeDisallowedHosts) and verify that they perform robust, deny-by-default checks on canonicalized hosts and resolved IPs.
  • Enforce secure coding guidelines that require allowlisting for outbound connections and forbid ad-hoc host filtering logic.
  • Automated policy enforcement:
  • Use SAST tools configured with SSRF-specific rules to detect risky patterns (e.g., direct use of user-supplied URLs with HTTP clients).
  • Introduce CI checks that block merges when network egress policies are not explicitly defined for new integrations.
  • Runtime and logging:
  • Monitor outbound network connections from the Appsmith server, correlating them with incoming requests to spot unexpected target hosts or internal IP ranges.
  • Add structured logging for outbound HTTP calls (including destination host, resolved IP, and source feature/module) to support anomaly detection.

Sources

SourceLink
github.comgithub.com/appsmithorg/appsmith/
github.comgithub.com/appsmithorg/appsmith/security/advisories/GHSA-9m89-5jw7-q5cr
vuldb.comvuldb.com/submit/780190
vuldb.comvuldb.com/vuln/354855
vuldb.comvuldb.com/vuln/354855/cti

Frequently asked

questions

Yes. A remote attacker who can interact with affected Dashboard functionality and influence outbound request targets can exploit this SSRF issue, subject to authentication and authorization controls in front of the endpoints.

The attacker generally needs the ability to use Appsmith dashboard features that trigger server-side HTTP requests. This may require a valid user account, depending on how the instance is deployed and whether relevant endpoints are protected.

Replace ad-hoc host filtering logic with a robust allowlist-based approach for outbound connections, ensure URLs are fully normalized and DNS-resolved before checks, and hard-block known sensitive ranges such as loopback, private networks, and cloud metadata addresses.

During design, avoid letting users directly specify arbitrary URLs for server-side calls. Where dynamic targets are necessary, constrain them to vetted domains or services, enforce strong validation and egress filters at both the application and network layers, and include SSRF checks in standard code review and static analysis practices.

Find out what's already
exploitable in your codebase.