Summary
An authenticated server-side request forgery (SSRF) vulnerability in the Huly Platform /import endpoint allows workspace users to direct the front pod to make arbitrary HTTP requests on their behalf.
By providing crafted URLs, attackers can reach internal services, exfiltrate sensitive responses, and potentially replay credentials against backend systems under the platform's trust context.
Affected context
This vulnerability occurs in Huly Platform deployments that expose the /import endpoint on the front pod to authenticated workspace users.
The issue is present when the endpoint accepts user-supplied URLs and forwards requests using the application's network privileges without adequate validation, network segmentation, or URL filtering.
It is most relevant in environments where the front pod can reach internal services, metadata endpoints, or backend APIs not intended for direct user access.
Exploit preconditions
- Attack surface: The /import HTTP endpoint on the front pod, reachable by authenticated workspace users.
- Required access: Valid user account with permission to call the import functionality; no additional elevated privileges are strictly required.
- Trigger point: Submission of a crafted or malicious URL parameter that the endpoint uses to fetch remote content.
- Why exploitation is possible: The server uses the provided URL to initiate outbound network requests with its own credentials and network reach, without robust validation, leading to SSRF conditions.
Why this happens
The underlying bug aligns with CWE-918: Server-Side Request Forgery, where a server-side component performs network requests based on user-controlled input.
In this case, the /import endpoint trusts URLs supplied by authenticated workspace users and forwards them to internal or external destinations using the front pod's network privileges.
The absence of strict URL validation, target allowlists, protocol restrictions, and segregation between external and internal network paths enables abuse of the import mechanism to query internal services and backend APIs.
Potential impact
- Attackers may access internal HTTP services that are not directly exposed to users.
- Attackers could exfiltrate sensitive configuration data, metadata, or service responses.
- Attackers can replay or leverage backend credentials implicitly used by the front pod.
- Attackers may pivot further by discovering internal API endpoints and misconfigurations.
- Attackers could influence backend systems by sending crafted requests through trusted channels.
General mitigation guidance
Effective mitigation centers on reducing trust in user-supplied URLs and constraining server-side network access.
Common defensive patterns include:
- Implementing strict allowlists for permitted remote hosts and paths for import operations.
- Blocking requests to private IP ranges, loopback addresses, link-local ranges, and cloud metadata endpoints.
- Enforcing protocol and scheme restrictions (e.g., HTTPS only, disallow file://, gopher://, etc.).
- Separating outbound network capabilities for user-driven features from internal service networks via segmentation.
- Limiting propagation of implicit authentication headers, cookies, or tokens on outgoing import requests.
- Designing import/refetch features to operate on predefined sources rather than arbitrary user-defined URLs.
How teams detect issues like this
Detection typically focuses on identifying user-controlled network calls originating from server components.
Helpful strategies include:
- Static analysis rules that flag HTTP client usage with unsanitized or unvalidated URL parameters.
- Code review checklists that require justification and controls for any feature that fetches external URLs.
- Logging and monitoring of outbound requests from front pods, with alerts for unusual internal destinations.
- Network-level policies that restrict which hosts the front pod can contact, combined with anomaly detection.
- Automated security testing (e.g., DAST or SSRF-focused scanners) targeting endpoints that accept URL-like input.

