/

CVE-2026-28798

Severity:

CRITICAL RISK

(9.0)

Server-Side Request Forgery (SSRF) in ZimaOS Proxy Endpoint

CVE-2026-28798

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthenticated Access to Internal Services and Potential Lateral Movement

Severity:

CRITICAL RISK

(9.0)

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

A server-side request forgery (SSRF) vulnerability in ZimaOS's /v1/sys/proxy endpoint allows attackers to leverage the system as a proxy to access internal localhost services.

When a ZimaOS instance is exposed to the Internet via a Cloudflare Tunnel, this flaw can enable unauthenticated access to internal-only HTTP endpoints and sensitive local services.

Affected context

The vulnerability arises in ZimaOS installations that:

  • Expose the web interface to the Internet through a Cloudflare Tunnel or similar reverse-proxy mechanism
  • Enable the /v1/sys/proxy endpoint to forward arbitrary outbound HTTP requests
  • Run internal services bound to localhost or other non-public interfaces on the same host

In this context, the proxy endpoint can be directed toward 127.0.0.1 or other internal addresses, bypassing intended network isolation between external users and local-only services.

Exploit preconditions

  • Attack surface: The ZimaOS web interface, specifically the /v1/sys/proxy endpoint, reachable from the Internet (e.g., via Cloudflare Tunnel).
  • Required access: No authentication required; the endpoint can be invoked by any remote party that can reach the exposed domain.
  • Trigger point: Attacker-controlled parameters within the proxy endpoint that specify the target URL or host of the proxied request.
  • Why exploitation is possible: The proxy endpoint does not sufficiently restrict or validate target destinations, allowing requests to be made to localhost or other internal addresses that are not directly exposed externally.

Why this happens

This issue is a classic example of CWE-918: Server-Side Request Forgery (SSRF), where a server-side component issues outbound HTTP requests based on user input without robust validation of the target address.

The /v1/sys/proxy endpoint acts as a generic HTTP client on behalf of the user, but it fails to enforce strong allow-lists, block-lists for loopback and internal IP ranges, or scheme and port restrictions.

As a result, untrusted external input can steer the server to contact internal-only services, effectively bypassing intended network segmentation and trust boundaries.

Potential impact

  • Unauthenticated access to HTTP services bound only to localhost on the ZimaOS host
  • Exposure of internal administrative APIs that were assumed to be unreachable from the Internet
  • Disclosure of sensitive data such as configuration details, access tokens, or system metadata returned by internal services
  • Potential manipulation of local services (e.g., file operations, process control, configuration changes) if their APIs are accessible over HTTP
  • Use of the host as a pivot point for further lateral movement within the local network, depending on what targets the proxy can reach

General mitigation guidance

Effective mitigation focuses on tightening how proxy endpoints handle destination addresses and reducing exposure of internal services:

  • Implement strict allow-lists for destinations that the proxy endpoint is permitted to contact (e.g., specific domains or well-known external APIs only).
  • Explicitly block loopback and internal address ranges (e.g., 127.0.0.0/8, ::1, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, link-local, and metadata IPs).
  • Restrict supported schemes and ports to those actually needed (e.g., https on standard ports) and avoid arbitrary port access.
  • Where practical, separate local-only administrative services from general-purpose HTTP services accessed via tunnels or reverse proxies, using different interfaces, ports, or authentication layers.
  • Apply least-privilege network policies so that the component handling proxy functionality has minimal access to internal network segments and sensitive services.

Designing proxy endpoints with a default-deny posture and explicit destination controls significantly reduces the risk of SSRF.

How teams detect issues like this

Detection and monitoring can combine code-centric review with runtime observation:

  • Static analysis and code review:
  • Flag endpoints that accept user-supplied URLs or hosts and then initiate server-side HTTP requests.
  • Review for absence of allow-list logic or IP range checks before making outbound requests.
  • Examine proxy or tunneling utilities and shared helpers that wrap HTTP client libraries for consistent SSRF protections.
  • Configuration and policy checks:
  • Enforce internal security policies that require validation of all user-controlled outbound request targets.
  • Integrate automated checks in CI pipelines that search for generic proxy endpoints or suspicious forwarding patterns.
  • Runtime monitoring:
  • Log and monitor outbound requests made by web components, including destination IP ranges and ports.
  • Alert on requests from web-facing components to loopback addresses or internal subnets, which can indicate SSRF attempts.

Security scanning tools and application security testing platforms can help surface SSRF patterns, but should be complemented by manual review of proxy-like functionality.

Sources

SourceLink
github.comgithub.com/IceWhaleTech/ZimaOS/releases/tag/1.5.3
github.comgithub.com/IceWhaleTech/ZimaOS/security/advisories/GHSA-vqqj-f979-8c8m

Frequently asked

questions

Yes. When ZimaOS is exposed via a Cloudflare Tunnel or similar mechanism, remote attackers can exploit the proxy endpoint over the Internet without prior access, as long as they can reach the /v1/sys/proxy path.

No. The described behavior allows unauthenticated use of the proxy endpoint, so exploitation does not require a user account or session on the system.

The most robust fix pattern is to limit proxy endpoints to a clearly defined set of external destinations using allow-lists, and to explicitly deny requests to loopback, link-local, and private network ranges, while also restricting protocols and ports.

Avoid implementing generic proxy or "fetch any URL" endpoints; when such functionality is necessary, treat all user-controlled URLs as untrusted, enforce strict destination validation, isolate components that make outbound requests with network controls, and include SSRF-focused checks in code review and automated security testing.

Find out what's already
exploitable in your codebase.