/

CVE-2026-56769

Severity:

HIGH RISK

(8.5)

Authenticated SSRF (CWE-918) in Huly Import Endpoint

CVE-2026-56769

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and data exfiltration 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

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.

Sources

SourceLink
github.comgithub.com/hcengineering/platform/commit/68cbf8a88642d8313f151a274fb5c24dee6a2762
github.comgithub.com/hcengineering/platform/issues/10892
github.comgithub.com/hcengineering/platform/pull/10910
vulncheck.comvulncheck.com/advisories/huly-platform-server-side-request-forgery-via-import-endpoint

Frequently asked

questions

It is exploitable by authenticated workspace users who can access the /import endpoint. While external attackers need an account, once authenticated, they can leverage SSRF to reach internal services not otherwise exposed externally.

An attacker generally needs a valid workspace user role sufficient to invoke the import functionality. Elevated administrative privileges are not strictly required, though broader access may increase the impact.

The safest approach is to avoid making outbound network requests based directly on arbitrary user-supplied URLs. When such functionality is required, enforce strict allowlists, block internal address ranges, and ensure that no sensitive credentials or headers are propagated to remote hosts.

Adopt a design pattern where server-side features do not trust user-controlled URLs and where internal services are isolated from user-driven network calls. Combine strict input validation, outbound network egress controls, code review practices focused on URL handling, and routine security testing to catch SSRF patterns early in development.

Find out what's already
exploitable in your codebase.