/

CVE-2026-28508

Severity:

HIGH RISK

(8.6)

Server-Side Request Forgery (SSRF) in Idno URL Unfurl API

CVE-2026-28508

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized Server-Side Network Access and Data Exfiltration via SSRF

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

A logic flaw in Idno's API authentication flow allows the CSRF protection on the URL unfurl service to be bypassed by unauthenticated remote users.

Because the unfurl endpoint does not require login, attackers can coerce the server into making arbitrary outbound HTTP requests, including to internal services and cloud metadata endpoints, and obtain the response content.

Affected context

This vulnerability affects Idno deployments exposing the URL unfurl API endpoint over the network.

The issue manifests where:

  • The URL unfurl service is accessible without authentication
  • CSRF protections rely on a flawed API authentication logic
  • The server can reach internal network resources or cloud provider metadata services

Environments with flat or highly trusted internal networks are particularly exposed, as the application server is allowed to initiate outbound HTTP connections on behalf of the attacker.

Exploit preconditions

  • Attack surface: Publicly exposed Idno URL unfurl API endpoint.
  • Required access: No prior authentication; any remote attacker with network reachability to the service.
  • Trigger point: Sending crafted HTTP requests to the unfurl endpoint that bypass CSRF logic and specify an attacker-controlled target URL.
  • Why exploitation is possible: A logic error in the API authentication flow neutralizes CSRF enforcement while the endpoint remains unauthenticated, allowing user-supplied URLs to be fetched directly by the server without origin or destination validation.

Why this happens

The core issue is an SSRF vulnerability (CWE-918) caused by a combination of missing authentication and flawed request validation on a server-side HTTP client.

The URL unfurl endpoint accepts user-controlled URLs and has the application server fetch and return their content.

Due to a logic error in the API authentication flow, CSRF protections can be trivially bypassed, and no additional access control is enforced.

As a result, untrusted input directly drives outbound HTTP requests, enabling attackers to abuse the server's network position to reach internal or otherwise restricted endpoints.

Potential impact

  • Unauthorized access to internal web applications or APIs not directly exposed to the internet
  • Retrieval of sensitive data from cloud instance metadata services (e.g., temporary credentials, configuration)
  • Network reconnaissance of internal hosts and services reachable by the Idno server
  • Potential pivoting into other systems if internal services trust the Idno server's network location
  • Exfiltration of configuration or diagnostic endpoints that expose secrets or tokens

General mitigation guidance

Effective mitigation typically combines stricter trust boundaries with hardening of outbound HTTP usage patterns:

  • Require strong authentication and authorization on any endpoint that initiates server-side HTTP requests using user-controlled URLs.
  • Enforce strict allowlists for outbound destinations, limiting unfurling to known-safe domains or patterns.
  • Implement URL validation that blocks access to private and link-local address ranges, including metadata IPs and internal hostnames.
  • Decouple user-supplied data from low-level HTTP client configuration, and avoid reflecting raw response bodies unless strictly necessary.
  • Run application components with least network privilege, using firewall rules or egress policies to prevent access to sensitive internal services.

How teams detect issues like this

Detection can focus on both code-level patterns and runtime behavior:

  • Static analysis or code review to flag endpoints where user input is passed directly or indirectly into HTTP client libraries without proper validation, allowlisting, or authentication.
  • Review of authentication and CSRF logic around API endpoints that perform network I/O, looking for conditional paths that disable or bypass protections.
  • Logging and monitoring of outbound HTTP requests from the application server, with anomaly detection for unusual destinations such as internal IP ranges, metadata endpoints, or unexpected hostnames.
  • Security testing (including automated scanning and manual penetration tests) that probes URL-handling endpoints with internal and reserved address targets to identify SSRF behavior.

Sources

SourceLink
github.comgithub.com/idno/idno/releases/tag/1.6.4
github.comgithub.com/idno/idno/security/advisories/GHSA-fcrh-fqxh-6fx6

Frequently asked

questions

Yes. Any remote attacker who can reach the exposed URL unfurl API endpoint over the network can attempt to exploit the SSRF behavior, without needing valid credentials.

No. Because the endpoint lacks a login requirement and the CSRF protection can be bypassed due to the logic error, the attacker can interact with the endpoint directly from their own client.

The safest approach is to require authentication and appropriate authorization for endpoints that perform server-side HTTP requests, and to couple this with strict outbound destination controls (allowlists, private-range blocking) and robust URL validation.

Design endpoints so that untrusted input cannot directly influence network calls, enforce consistent authentication and CSRF protections across all API paths, apply defense-in-depth with egress filtering and allowlists, and regularly review or automatically scan code that introduces new HTTP client usage or URL-handling features.

Find out what's already
exploitable in your codebase.