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-servicebackend RPC - Allow clients to connect to the standard
/servicesmessaging 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
/servicesmessaging endpoint, specifically the/services/request-serviceRPC. - 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.

