/

CVE-2026-10055

Severity:

HIGH RISK

(8.5)

Server-Side Request Forgery (CWE-918) in Eclipse Theia

CVE-2026-10055

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-200, CWE-918

Impact:

Exposure of Internal Services and Sensitive Data via SSRF

Severity:

HIGH RISK

(8.5)

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

Eclipse Theia's backend request-service RPC can be abused to make arbitrary HTTP requests from the server to attacker-specified URLs and return the full responses to the client.

When exposed to untrusted users, this enables server-side request forgery (SSRF) that can access internal services, instance metadata endpoints, or other resources not directly reachable from the browser.

Affected context

This vulnerability appears in Eclipse Theia deployments that:

  • Enable the /services/request-service backend RPC
  • Allow clients to connect to the standard /services messaging endpoint
  • Do not enforce strict URL validation, allowlisting, or network segmentation for backend HTTP requests

It is most impactful in multi-tenant or publicly reachable Theia instances where untrusted users can establish a service connection to the backend.

Exploit preconditions

  • Attack surface: The Theia backend /services messaging endpoint, specifically the /services/request-service RPC.
  • Required access: Ability to authenticate or otherwise connect as a Theia client to the backend messaging endpoint (which may be open in shared or public deployments).
  • Trigger point: Sending an RPC request that supplies an arbitrary URL to /services/request-service, causing the backend to perform the HTTP request on the server's network.
  • Why exploitation is possible: The server blindly trusts client-supplied URLs without validation or allowlisting and returns the full HTTP response body, allowing attackers to pivot through the backend's network context.

Why this happens

The root cause lies in treating attacker-supplied URLs as safe targets for backend HTTP requests without applying validation, allowlists, or network-aware safeguards.

The backend request-service acts as an open proxy, issuing requests from a more privileged network position and returning raw responses to the requester.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where a server-side component initiates network requests based on untrusted input, and CWE-200: Exposure of Sensitive Information, because internal responses are disclosed outside their intended boundary.

At an abstract level, the pattern is: untrusted user input → direct backend HTTP call → unfiltered response returned to the client.

Potential impact

  • Exposure of internal administrative dashboards and APIs that are not directly internet-accessible
  • Access to cloud instance or container metadata services, potentially revealing credentials or tokens
  • Discovery of internal network structure, services, and configuration through response analysis
  • Abuse of internal HTTP-based APIs to perform actions on behalf of the server (e.g., configuration changes, triggering jobs)
  • Support for further attacks such as lateral movement or privilege escalation using leaked secrets

General mitigation guidance

Effective mitigation focuses on constraining backend-initiated HTTP requests and reducing trust in client-supplied URLs.

Common defensive patterns include:

  • Implementing strict allowlists of permitted target hosts, schemes, and paths for any backend HTTP proxy or request-service.
  • Rejecting or normalizing URLs that target loopback, private, or link-local address ranges, or non-HTTP(S) schemes, unless explicitly required.
  • Introducing a dedicated, minimally privileged outbound HTTP component that only exposes necessary external endpoints, rather than enabling general-purpose proxying.
  • Applying network-layer controls (firewalls, security groups, service meshes) to limit backend access to sensitive internal services and metadata endpoints.
  • Designing APIs so that clients select from predefined, server-controlled destinations instead of providing raw URLs.

How teams detect issues like this

Detection generally relies on identifying unsafe backend HTTP proxy behavior and monitoring unusual network patterns.

Organizations can:

  • Use static analysis or code scanning to flag patterns where untrusted input flows into HTTP client libraries without validation, especially in RPC or request-forwarding services.
  • During code review, treat any "generic HTTP proxy" or "request-service" functionality as high risk, verifying strict allowlists and network restrictions.
  • Implement logging and monitoring for backend HTTP requests, highlighting unusual destinations such as 127.0.0.1, internal IP ranges, or metadata service endpoints.
  • Apply security policies in CI/CD that disallow direct use of generic URL-forwarding services without explicit approvals and tests.

Sources

SourceLink
github.comgithub.com/eclipse-theia/theia/security/advisories/GHSA-2m57-xxmh-v696
gitlab.eclipse.orggitlab.eclipse.org/security/vulnerability-reports/-/work_items/446

Frequently asked

questions

Yes, in deployments where the Theia /services backend endpoint is reachable by untrusted users, a remote attacker can exploit the request-service to issue SSRF requests and obtain internal responses.

The attacker must be able to act as a Theia client connected to the backend messaging endpoint. In single-tenant or tightly controlled deployments, this may require valid user access; in multi-tenant or public instances, it might be available to untrusted or low-privileged users.

The strongest fix is to eliminate generic URL-forwarding capabilities and replace them with narrowly scoped APIs that call only predefined, server-owned destinations. Where a request-service is required, apply strict allowlists, URL validation, and network-layer restrictions so arbitrary internal targets cannot be reached.

Treat any feature that makes server-side HTTP requests based on user input as high risk: enforce allowlists, avoid exposing raw URL-based proxies, apply least-privilege networking, and include SSRF-specific checks in code review and automated security testing.

Find out what's already
exploitable in your codebase.