/

CVE-2026-55455

Severity:

CRITICAL RISK

(9.1)

SSRF (CWE-918) in Appsmith HTTP Data Source Path

CVE-2026-55455

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Service Access via SSRF

Severity:

CRITICAL RISK

(9.1)

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

Appsmith's HTTP datasource plugins previously enforced only a string-based host denylist, without applying broader address-class checks for outbound requests.

Under these conditions, an authenticated user could craft requests that access loopback-bound services inside the container, turning Appsmith into a proxy to internal services.

Affected context

This vulnerability affects Appsmith deployments where users can configure REST API or GraphQL datasources through the platform's HTTP plugins.

The HTTP request path relies on WebClientUtils for host filtering but only applies an exact-match denylist against hostnames, without performing comprehensive IP address-class validation.

When Appsmith runs inside a container, loopback-bound services and other internal endpoints may be reachable if requests are not fully constrained by network or plugin-level policies.

Exploit preconditions

  • Attack surface: Appsmith HTTP-based datasource configuration (REST API and GraphQL plugins).
  • Required access: Authenticated access to create or modify outbound HTTP datasources or queries.
  • Trigger point: User-defined HTTP requests sent via Appsmith that specify hostnames or IPs resolving to loopback or other internal network targets.
  • Why exploitation is possible: The WebClientUtils host filter used on the HTTP plugin path relies on exact string matching against a denylist and does not consistently enforce address-class checks (e.g., loopback, link-local, fc00::/7), allowing crafted hosts that route to internal services.

Why this happens

The root cause lies in incomplete enforcement of outbound network restrictions for HTTP datasources.

While Appsmith includes an address-class validation path (loopback, any-local, link-local, unique local IPv6), it is only wired into the SMTP code path, not the REST API or GraphQL HTTP path.

On the HTTP side, WebClientUtils validates hosts using a simple exact-match denylist, which does not account for different host representations, DNS resolution results, or IP ranges associated with internal or loopback addresses.

This maps to CWE-918: Server-Side Request Forgery, where a server-side component sends requests to attacker-chosen destinations without robust validation, enabling access to internal or otherwise restricted services.

Potential impact

  • An attacker could reach loopback-bound services running inside the Appsmith container.
  • Internal admin interfaces or metadata services exposed only on localhost could be queried via the platform.
  • Sensitive configuration or credentials accessible from internal endpoints may be disclosed.
  • The application may be abused as a pivot point for further exploration of internal network surfaces reachable from the container.
  • Abuse of internal APIs could lead to data modification or indirect privilege escalation depending on what those services expose.

General mitigation guidance

Effective mitigation patterns focus on enforcing strict outbound request controls and minimizing trust in user-configurable endpoints.

Recommended approaches include:

  • Applying consistent address-class validation across all outbound request paths, rejecting loopback, link-local, and private-range destinations where not explicitly required.
  • Using allowlists for outbound hosts or domains that Appsmith is permitted to contact, rather than relying on denylist checks.
  • Decoupling user-configurable datasources from direct access to the container's local network; for example, routing through a tightly controlled proxy that enforces policy.
  • Running Appsmith with constrained network privileges and isolating internal services so they are not reachable from application containers whenever feasible.
  • Designing datasource plugins to treat user-specified endpoints as untrusted and subject to centralized, reusable validation logic.

How teams detect issues like this

SSRF-related issues can be surfaced through a blend of static analysis, code review, and runtime monitoring:

  • Static analysis rules can flag outbound HTTP client usage that does not pass through centralized host and address-class validation utilities.
  • Code reviews should look for ad hoc host filtering logic, string-based denylist checks, or duplicated network validation code paths that diverge from a common policy.
  • Security teams can define policies requiring all outbound requests to be mediated by a vetted helper or proxy, and enforce these via automated checks in CI pipelines.
  • Runtime monitoring and logging of outbound requests (including destination host and resolved IP) can help detect suspicious access patterns, such as requests to 127.0.0.1, ::1, or unexpected internal ranges.
  • Automated security testing tools that specifically probe for SSRF (e.g., by attempting calls to loopback or metadata services) can be integrated into pre-release validation.

Sources

SourceLink
github.comgithub.com/appsmithorg/appsmith/security/advisories/GHSA-m23h-pvf3-2m7p

Frequently asked

questions

Exploitation is limited to scenarios where an authenticated user can configure HTTP datasources or queries, but within that scope it can be highly impactful by exposing internal services reachable from the Appsmith container.

An attacker typically needs an authenticated Appsmith account with permissions to create or modify REST API or GraphQL datasources; they do not require direct network access to the container or host.

The most robust fix is to route all outbound HTTP traffic through a single, well-audited validation layer that applies address-class checks and enforces strict allowlists for permitted destinations, rather than relying on per-plugin denylist logic.

Teams can adopt a design principle where user-controlled endpoints are always treated as untrusted, enforce centralized outbound request policies, include SSRF checks in threat modeling, and use automated tests and static analysis to ensure new code paths cannot bypass the established validation mechanisms.

Find out what's already
exploitable in your codebase.