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
computeDisallowedHostscorrectly 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
computeDisallowedHoststo 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.

