/

CVE-2026-61835

Severity:

HIGH RISK

(7.7)

SSRF (CWE-918) via 0.0.0.0 in Directus File Import

CVE-2026-61835

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Unauthorized access to internal network resources

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

A server-side request forgery (SSRF) flaw in Directus allows authenticated users with file-upload permissions to bypass IP-based protections using the 0.0.0.0 address.

On Linux and macOS systems, 0.0.0.0 effectively routes to localhost, enabling the server to fetch internal services via the file import endpoint and return their responses as downloadable files.

Affected context

This vulnerability appears in Directus deployments that:

  • Expose the /files/import endpoint to authenticated users with file-upload rights
  • Rely on IP denylisting (including localhost) to prevent SSRF
  • Run on platforms where 0.0.0.0 resolves to local network interfaces, such as Linux and macOS

It is most relevant in environments where internal HTTP services, admin panels, or metadata endpoints are reachable from the Directus server's network context.

Exploit preconditions

  • Attack surface: Directus /files/import file-import-from-URL feature
  • Required access: Authenticated access with permissions to upload or import files
  • Trigger point: Supplying http://0.0.0.0:<port>/... or similar URLs to the import-from-URL mechanism
  • Why exploitation is possible: The SSRF filter treats 0.0.0.0 as a keyword for local interfaces without blocking the literal IP address, allowing requests to internal services that appear as regular outbound requests.

Why this happens

The core issue is an incomplete validation of destination addresses in server-initiated HTTP requests, mapped to CWE-918: Server-Side Request Forgery (SSRF).

The Directus IP-denial logic conceptually recognizes localhost and internal interfaces but fails to treat 0.0.0.0 as a concrete address that must be blocked.

As a result, the application trusts user-supplied URLs and permits the backend to act as a proxy to internal network targets, violating the intended isolation between user inputs and sensitive internal services.

Potential impact

  • Unauthorized access to internal HTTP services that are not meant to be publicly reachable
  • Exposure of configuration endpoints, diagnostics pages, or internal APIs through downloaded response files
  • Potential access to cloud instance metadata services or secrets if reachable from the Directus host
  • Information gathering that could assist lateral movement or privilege escalation within the infrastructure

General mitigation guidance

Effective mitigation centers on reducing trust in user-supplied URLs and hardening outbound request controls.

Common defensive patterns include:

  • Implementing strict allowlists for external domains that can be used for file import, rather than relying solely on denylists
  • Normalizing and validating destination IPs and hostnames, including special addresses like 0.0.0.0, localhost variants, and private network ranges
  • Enforcing network-level egress controls so application servers cannot freely reach internal services or metadata endpoints
  • Reducing privileges of the Directus runtime and segregating it from sensitive internal interfaces through network segmentation

How teams detect issues like this

Organizations can detect SSRF-style risks by:

  • Using static analysis or code scanning rules that flag user-controlled URLs passed directly to HTTP clients without robust validation
  • Reviewing request-filtering utilities for incomplete coverage of special IP addresses, localhost variants, and private ranges
  • Monitoring application logs and network telemetry for unusual requests to 0.0.0.0, 127.0.0.1, or internal IP ranges originating from web application processes
  • Enforcing development policies that require explicit outbound domain allowlists and threat modeling for any server-side HTTP client features

Sources

SourceLink
github.comgithub.com/directus/directus/commit/f75b25fa44b05c6022b20f231c20bc6e50f021d7
github.comgithub.com/directus/directus/pull/27606
github.comgithub.com/directus/directus/releases/tag/v12.0.0
github.comgithub.com/directus/directus/security/advisories/GHSA-j5h6-vqc3-phqh

Frequently asked

questions

Exploitation is limited to authenticated users who have file-upload or import permissions, but within that scope it can be powerful because the application server can reach internal services that the user cannot access directly.

The attacker must be able to authenticate to Directus and use the file-import-from-URL functionality. No direct shell or network access to the server is required; the application itself performs the requests.

The safest approach is to treat all user-supplied URLs as untrusted, enforce destination allowlists, block all localhost and private network targets (including special addresses like 0.0.0.0), and support these controls with network-layer egress restrictions.

Future prevention relies on combining strict URL validation, IP and hostname normalization, and outbound firewall rules with secure design reviews for any feature that lets the server fetch remote resources on behalf of a user.

Find out what's already
exploitable in your codebase.