/

CVE-2026-30953

Severity:

HIGH RISK

(7.7)

SSRF in LinkAce Link Creation Endpoint

CVE-2026-30953

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access via SSRF

Severity:

HIGH RISK

(7.7)

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

LinkAce's link creation flow performs server-side HTTP requests to fetch HTML metadata from user-supplied URLs without enforcing private IP restrictions.

Because the NoPrivateIpRule is not applied to POST /links, an attacker can abuse this behavior to make the server issue requests to internal services, Docker hostnames, or cloud metadata endpoints.

Affected context

This vulnerability appears in LinkAce deployments where users can create links via the primary link creation endpoint (POST /links).

During link creation, the backend calls HtmlMeta::getFromUrl() to fetch metadata from the supplied URL.

In this path, the LinkStoreRequest validation does not apply the existing NoPrivateIpRule, so URLs pointing to private IP ranges, internal Docker hostnames, or cloud metadata services are not blocked.

The FetchController path does use this rule, but it does not protect the main link creation workflow, leaving a gap where SSRF can occur.

Exploit preconditions

  • Attack surface: HTTP API endpoint POST /links exposed to users (typically authenticated, depending on deployment).
  • Required access: Ability to submit or influence link creation requests with arbitrary URLs.
  • Trigger point: The server-side metadata fetch performed by HtmlMeta::getFromUrl() during link creation.
  • Why exploitation is possible: The validation rules for LinkStoreRequest do not enforce NoPrivateIpRule, so the application accepts URLs that resolve to internal or sensitive network locations, and the server then issues outbound HTTP requests to those addresses on behalf of the attacker.

Why this happens

The core issue is a missing application of a network boundary validation rule on user-supplied URLs in one of the main data flows.

The codebase already contains a NoPrivateIpRule that checks and blocks requests to private or internal IP ranges, but this rule is only enforced in FetchController and not in the LinkStoreRequest used by LinkRepository::create().

This gap leads to CWE-918: Server-Side Request Forgery (SSRF), where an attacker-controlled URL is used as input to a server-side HTTP client, allowing the attacker to pivot the application into making arbitrary network requests and bypassing external network boundaries.

Potential impact

  • Access to internal web services that are not directly reachable from the internet
  • Interaction with Docker-internal service hostnames or cluster-only endpoints
  • Retrieval of sensitive data from cloud provider metadata services (e.g., IAM credentials, instance data)
  • Network reconnaissance of internal IP ranges by observing timing and error behavior
  • Potential chaining with other weaknesses on internal services (e.g., exploiting admin-only panels exposed only on the local network)

General mitigation guidance

Mitigation generally involves tightening URL handling and enforcing strict network egress policies for server-side HTTP requests.

Useful defensive patterns include:

  • Applying a consistent URL validation rule (such as NoPrivateIpRule) to all inputs that are used as targets for server-side HTTP requests, including link creation forms and any auxiliary fetch endpoints.
  • Normalizing and resolving hostnames before validation so that DNS-based bypasses (e.g., internal hosts resolving from public-looking names) are detected.
  • Maintaining a default-deny outbound network posture from application containers, allowing only necessary external destinations and blocking internal ranges and metadata endpoints by network policy or firewall rules.
  • Using allowlists for acceptable domains or schemes where feasible, especially for metadata fetching functionalities.
  • Separating metadata-fetching components into isolated, low-privilege services with constrained network access.

How teams detect issues like this

Organizations can identify and monitor this class of issue using several approaches:

  • Static analysis and code review: Search for HTTP client usage (e.g., Guzzle, cURL wrappers, HtmlMeta::getFromUrl()) that consume user-controlled URLs without passing through URL/IP validation components like NoPrivateIpRule.
  • Configuration and policy checks: Enforce coding standards that require all external URL inputs to be validated with a shared rule or validator class before use.
  • Dynamic and black-box testing: Use SSRF-focused security tests to supply internal IPs, localhost variants, and cloud metadata endpoints as URLs to link creation APIs and observe the responses and timing.
  • Runtime monitoring: Log outbound HTTP requests from the application and detect anomalies such as requests to RFC1918 address ranges, link-local addresses, or known metadata IPs (e.g., 169.254.169.254).

Sources

SourceLink
github.comgithub.com/Kovah/LinkAce/security/advisories/GHSA-f2mp-q78r-7jx7

Frequently asked

questions

Yes, it can be exploited remotely by any user who can reach the link creation endpoint and supply arbitrary URLs, subject to whatever authentication or access control the deployment enforces.

In many self-hosted setups, creating links is restricted to authenticated users, so an attacker typically needs at least low-privileged access. However, if the instance exposes link creation to the public (e.g., open registration or guest submissions), then unauthenticated exploitation may be possible.

Apply the existing NoPrivateIpRule (or an equivalent URL/IP validation rule) to all code paths that accept URLs and then perform server-side HTTP requests, including the primary POST /links flow. Complement input validation with network-level controls that prevent application containers from reaching internal and metadata endpoints.

Adopt a shared, mandatory validation layer for all user-provided URLs, enforce an allowlist or strict egress rules at the network level, and include SSRF-specific checks in both manual code review and automated security testing so that any new HTTP call sites using user input are systematically scrutinized.

Find out what's already
exploitable in your codebase.