/

CVE-2026-49969

Severity:

HIGH RISK

(7.4)

Server-Side Request Forgery (CWE-918) in Laravel-Mediable

CVE-2026-49969

Deferred

Vulnerability type

Category:

Server-Side Request Forgery

CWE:

CWE-918

Impact:

Internal Network Access and Sensitive Data Exposure

Severity:

HIGH RISK

(7.4)

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

Laravel-Mediable before 7.0.0 contains a server-side request forgery issue where MediaUploader::fromSource() accepts attacker-controlled URLs without adequate validation.

Under these conditions, a remote attacker can coerce the server into issuing arbitrary HTTP or file requests, potentially reaching internal services, metadata endpoints, or local files that are not directly exposed to the internet.

Affected context

This vulnerability occurs in applications using Laravel-Mediable's MediaUploader::fromSource() with RemoteUrlAdapter to ingest media from user-supplied URLs.

It is most relevant when:

  • User input is passed directly or indirectly as the URL source
  • URL validation, allowlisting, or scheme restrictions are weak or absent
  • The application server has network reachability to internal services, cloud metadata endpoints, or access to local files via URL handlers

Exploit preconditions

  • Attack surface: HTTP endpoints that accept or process remote URLs via MediaUploader::fromSource() / RemoteUrlAdapter.
  • Required access: Ability to submit or influence URL parameters (e.g., form fields, API payloads).
  • Trigger point: Invocation of MediaUploader::fromSource() on attacker-controlled URLs without robust validation or restriction.
  • Why exploitation is possible: The component treats the provided URL as trustworthy and allows requests to arbitrary hosts, private IP ranges, loopback interfaces, metadata services, and file schemes, effectively proxying the attacker's traffic through the server.

Why this happens

The root cause aligns with CWE-918: Server-Side Request Forgery (SSRF), where a server-side component performs network or resource requests based on untrusted input.

MediaUploader::fromSource(), when combined with RemoteUrlAdapter, accepts caller-controlled URLs and fails to enforce strict constraints on destination hosts, IP ranges, or URI schemes.

This pattern allows the application server to act as an unintended network proxy and file accessor, bridging the gap between the external attacker and internal-only resources that should not be directly accessible.

Potential impact

  • Attackers may reach internal RFC-1918 services (e.g., internal APIs, databases, admin panels) that are not publicly exposed.
  • Attackers could query cloud instance metadata endpoints to retrieve IAM tokens or other cloud credentials.
  • Attackers can potentially read sensitive local files via supported file:// or similar URI schemes.
  • Attackers may use the server as a pivot point to map internal infrastructure and gather configuration details.
  • Attackers could exfiltrate secrets and tokens, leading to broader compromise of cloud accounts or downstream services.

General mitigation guidance

Effective mitigation focuses on constraining how URLs are accepted and where outbound requests can go.

Common defensive patterns include:

  • Enforcing strict allowlists for remote hosts or domains and rejecting requests to private, loopback, or link-local IP ranges.
  • Restricting acceptable URI schemes (e.g., only https/http) and banning file:// and other local-resource schemes.
  • Applying robust URL and DNS resolution validation, including IP range checks after hostname resolution.
  • Decoupling user-controlled input from direct network calls by introducing trusted, curated download services or background jobs with stricter policies.
  • Running application servers with least-privilege network and filesystem access, reducing reachable internal surfaces and sensitive files.

How teams detect issues like this

Organizations can detect SSRF risks and instances through:

  • Static analysis rules that flag functions performing outbound HTTP or file requests using unvalidated or direct user input parameters.
  • Code review practices that highlight patterns where URL fields from requests or models are passed into MediaUploader::fromSource() without validation, allowlisting, or scheme checks.
  • Runtime monitoring and logging of outbound requests, with alerts for traffic to internal IP ranges, metadata service endpoints, or unusual schemes.
  • Policy enforcement in CI/CD pipelines that block deployments when SSRF-prone components are used without accompanying validation helpers or network egress controls.

Sources

SourceLink
github.comgithub.com/plank/laravel-mediable/commit/7e9e3000fa05fe16e678f15bfb51a091e60c2cb8
github.comgithub.com/plank/laravel-mediable/releases/tag/7.0.0
vulncheck.comvulncheck.com/advisories/laravel-mediable-ssrf-via-remoteurladapter-url-handling

Frequently asked

questions

Exploitability depends on how widely MediaUploader::fromSource() is exposed to user input. If multiple endpoints accept arbitrary URLs, an external attacker may have broad SSRF capabilities; if usage is narrowly scoped or authenticated, the window is smaller but still significant.

An attacker generally needs the ability to submit or influence URL parameters handled by Laravel-Mediable, such as form fields or API payload attributes. No direct server access is required; interaction through normal application interfaces is usually sufficient.

The safest pattern is to introduce strict controls on outbound requests: validate and sanitize URLs, enforce host/domain allowlists, block private and loopback IP ranges, restrict URI schemes, and ensure MediaUploader::fromSource() can only reach explicitly trusted, external locations.

Future designs should treat any user-controlled URL or network address as untrusted, route it through centralized validation and policy checks, and minimize the server's ability to reach internal or sensitive resources. Combining strong input validation with network-layer egress controls and routine security review of outbound-request code paths helps prevent recurring SSRF vulnerabilities.

Find out what's already
exploitable in your codebase.