/

CVE-2026-33953

Severity:

HIGH RISK

(8.5)

Server-Side Request Forgery (SSRF) in LinkAce

CVE-2026-33953

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources 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

LinkAce versions prior to 2.5.3 are vulnerable to server-side request forgery (SSRF) when internal-only resources are referenced through internal hostnames instead of private IP literals.

An authenticated user can leverage this behavior to make the LinkAce server issue HTTP requests to internal services that are not directly accessible from the internet.

Affected context

The vulnerability occurs in LinkAce deployments where the application can resolve and reach internal hostnames (e.g., services on the same LAN, VPC, or container network).

While direct requests to private IP address literals are blocked, the application still permits outbound requests when a URL points to an internal resource via hostname resolution.

This risk is present when authenticated users can submit or cause the application to fetch arbitrary URLs and the LinkAce server has network access to internal-only services.

Exploit preconditions

  • Attack surface: HTTP endpoints where LinkAce accepts user-supplied URLs and performs server-side HTTP requests (e.g., link preview, metadata fetching, URL validation).
  • Required access: Authenticated user account with the ability to add or reference URLs that are subsequently fetched by the server.
  • Network assumptions: The LinkAce server can resolve and connect to internal hostnames (such as internal DNS zones, service discovery hostnames, or container/cluster-local names).
  • Trigger point: Submission or processing of a URL that uses an internal hostname pointing to a private or internal-only service.
  • Why exploitation is possible: Input validation focuses on blocking private IP address literals but does not treat hostnames that resolve to internal addresses as sensitive, allowing the server to perform internal requests on behalf of the attacker.

Why this happens

This vulnerability stems from incomplete SSRF protection logic that only checks for private IP address patterns in URLs but does not account for hostnames that resolve to those same private ranges.

From an architectural perspective, LinkAce treats user-controlled URLs as safe targets for server-side HTTP requests without thoroughly validating the resolved destination or enforcing strict egress policies.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where a web application fetches remote resources based on user-specified URLs, enabling attackers to reach internal or otherwise restricted endpoints through the application's network privileges.

Potential impact

  • An attacker could make the server send HTTP requests to internal web services not exposed to the public internet.
  • An attacker could probe internal network topology by observing response behaviors (status codes, timing, response size).
  • An attacker could access sensitive metadata or configuration endpoints if they are available via HTTP from the application host (e.g., internal dashboards, admin panels, instance metadata services).
  • An attacker could interact with internal APIs, potentially performing actions within those services depending on how they authenticate and trust the application's source IP.
  • An attacker could use the application as a pivot point for further reconnaissance inside the hosting environment.

General mitigation guidance

Effective mitigation focuses on tightening control over where the application is allowed to make outbound HTTP requests and reducing trust in user-provided URLs:

  • Implement strict allowlists (or well-defined blocklists) for outbound destinations, limiting server-side requests to known, external domains when possible.
  • Validate URLs both syntactically and semantically, including DNS resolution and final IP checks, to ensure they do not resolve to private, link-local, loopback, or otherwise internal ranges.
  • Normalize and re-resolve URLs after redirects to avoid bypasses through intermediate hosts or DNS tricks.
  • Separate network segments so that the application server has minimal or no access to sensitive internal services unless strictly required.
  • Use application-layer proxies or egress filters to enforce outbound request policies outside of the application code.
  • Apply the principle of least privilege to both the application runtime and its network access, so that even if SSRF is triggered, reachable resources and operations are limited.

How teams detect issues like this

Organizations can approach detection and assessment of SSRF risks in similar applications using:

  • Static analysis and code review: Look for code paths that accept user-supplied URLs and make outbound HTTP(S) requests without strict validation, DNS/IP checking, or domain allowlisting.
  • Configuration review: Evaluate egress firewall rules, service mesh policies, or proxy configurations to confirm that the application's outbound network access is constrained.
  • Runtime monitoring: Monitor outbound HTTP traffic patterns from the application host/container for unusual destinations, such as internal IP ranges or unexpected internal hostnames.
  • Automated security testing: Use dynamic analysis tools or SSRF-focused test cases that supply internal hostnames and observe whether the application fetches them.
  • Policy enforcement in CI/CD: Include checks for insecure URL-fetching patterns, missing hostname resolution checks, or absent network egress policies as part of code and configuration review pipelines.

Sources

SourceLink
github.comgithub.com/Kovah/LinkAce/security/advisories/GHSA-wp4g-qw9j-wfjg

Frequently asked

questions

Yes, but only by authenticated users of the LinkAce instance. An external attacker who gains or creates a valid account can supply crafted URLs that cause the server to make internal network requests.

The attacker needs an authenticated account with the ability to submit or influence URLs that LinkAce will fetch server-side. No direct shell or network-level access to the server is required beyond application access.

The safest pattern is to combine strict outbound request control (e.g., domain allowlists or proxy enforcement) with robust URL validation that rejects any destination resolving to internal or non-routable address ranges, including those reached via hostnames and redirects.

When designing features that fetch remote resources, assume all user-supplied URLs are untrusted, centralize outbound HTTP logic through a hardened client that enforces destination policies, validate DNS resolution results, and restrict the application's network reach using infrastructure controls such as firewalls, service meshes, and network policies.

Find out what's already
exploitable in your codebase.