/

CVE-2026-53983

Severity:

HIGH RISK

(8.6)

Server-Side Request Forgery (CWE-918) in Ground Station

CVE-2026-53983

Deferred

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Unauthorized outbound requests to internal services, with potential information disclosure and cloud-environment compromise

Severity:

HIGH RISK

(8.6)

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

Ground Station before 0.6.0 contains an unauthenticated blind server-side request forgery vulnerability in its orbital-source synchronization workflow. An attacker may submit and persist a URL that the ground-station process later requests, potentially reaching internal services or cloud metadata endpoints and observing response status information through Socket.IO events.

Affected context

The issue occurs in deployments where the Ground Station Socket.IO service is reachable and authentication enforcement is disabled or ineffective. The orbital-source configuration path accepts attacker-controlled URLs without scheme restrictions, host validation, or blocking for loopback, private, or link-local destinations. Persisted sources may be requested during manually triggered and scheduled orbital synchronization, and response status or error information may be broadcast to connected clients.

Exploit preconditions

  • Attack surface: Socket.IO service exposed on the ground-station interface, including the configured service port
  • Required access: Network connectivity to the Socket.IO endpoint; valid application credentials are not required when authentication enforcement is disabled
  • Trigger point: Submission of an orbital-source URL followed by an orbital synchronization task, or the recurring synchronization cycle
  • Why exploitation is possible: User-controlled URLs are stored and passed to outbound HTTP request functions without destination validation or network-boundary enforcement
  • Observation channel: Synchronization status events may expose HTTP status codes and error messages that help distinguish responses from internal destinations

Why this happens

The vulnerability is caused by accepting attacker-controlled URLs as trusted outbound request targets. The application lacks a restrictive scheme allowlist, hostname or IP validation, and safeguards against loopback, RFC1918, link-local, or cloud metadata addresses before invoking HTTP client functionality.

This behavior maps to CWE-918: Server-Side Request Forgery, in which a server makes network requests to attacker-selected destinations. The risk is increased by unauthenticated event handlers, permissive cross-origin access, persistent storage of submitted sources, and response-derived status information returned to clients.

Potential impact

  • Internal services may receive unauthorized requests from the ground-station network
  • Cloud instance metadata or other environment details could be exposed indirectly
  • Network topology, service availability, or authentication behavior may be inferred from status and error responses
  • Sensitive administrative endpoints may be reached if network controls permit access
  • Repeated outbound requests may persist across restarts and scheduled synchronization cycles
  • Internal systems could be affected if the reached endpoint performs state-changing operations

General mitigation guidance

Mitigation generally focuses on treating all user-provided URLs as untrusted and enforcing outbound network policy at multiple layers.

Common defensive patterns include:

  • Permit only explicitly required URL schemes, hosts, ports, and destinations
  • Resolve hostnames and validate resulting addresses before connecting
  • Reject loopback, private, link-local, multicast, and cloud-metadata address ranges
  • Revalidate destinations after redirects and prevent DNS-rebinding bypasses
  • Apply egress firewall rules, proxy policies, and network segmentation
  • Require authentication and authorization for configuration-changing events and synchronization triggers
  • Avoid returning detailed outbound status or error information to broad client audiences
  • Restrict persistence of externally supplied sources and apply ownership or approval controls
  • Run the service with minimal network reachability and least privilege

How teams detect issues like this

Organizations can identify SSRF risks through:

  • Static analysis rules for HTTP client calls that consume user-controlled or database-derived URLs
  • Code review checks for missing URL scheme, hostname, port, redirect, and IP-range validation
  • Tests covering loopback, RFC1918, link-local, IPv6 local, metadata, alternate-encoding, and DNS-rebinding destinations
  • Monitoring for outbound requests from the service to internal address ranges or unexpected external hosts
  • Socket.IO and API policy checks confirming authentication and authorization on configuration and task events
  • Alerts for unusual synchronization targets, repeated metadata-address requests, and detailed outbound error disclosure
  • Automated security review tools that trace tainted input into network-request sinks

Sources

SourceLink
github.comgithub.com/sgoudelis/ground-station
github.comgithub.com/sgoudelis/ground-station/commit/2ecde82a8814cbea18883ce023bf45cbf06172eb
github.comgithub.com/sgoudelis/ground-station/security/advisories/GHSA-mjp8-x6h7-229q

Frequently asked

questions

Yes, when the Socket.IO service is network-accessible and its event handlers accept unauthenticated clients. The attacker does not need to be on the target host, although network exposure and deployment controls determine practical reachability.

The key requirement is connectivity to the Socket.IO endpoint when authentication enforcement is disabled or bypassable. The attacker must also be able to submit an orbital source and cause synchronization, either directly or through the scheduled cycle.

Treat submitted URLs as untrusted, enforce strict destination allowlists, block local and link-local ranges, recheck redirects and resolved addresses, and apply outbound network restrictions. Authentication and authorization should protect configuration changes and task execution.

Combine secure URL validation with egress filtering, least-privilege network access, controlled persistence of external sources, and monitoring for unexpected internal-bound requests. Tests and code review should trace every user-controlled value that reaches an HTTP client.

Find out what's already
exploitable in your codebase.