/

CVE-2026-35459

Severity:

CRITICAL RISK

(9.1)

Server-Side Request Forgery (SSRF) in pyLoad Downloader

CVE-2026-35459

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Internal Resource Access via SSRF

Severity:

CRITICAL RISK

(9.1)

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

pyLoad versions 0.5.0b3.dev96 and earlier contain a server-side request forgery (SSRF) flaw in the download component, where only the initial URL is IP-validated but subsequent HTTP redirects are not.

An authenticated user with ADD permissions can submit a URL that redirects to internal network resources, allowing the server to make unauthorized requests on their behalf.

Affected context

This vulnerability affects pyLoad deployments where users can add download URLs through the web interface or API.

The risk is present when:

  • pyLoad can reach internal or otherwise protected network endpoints from its host environment
  • The downloader is configured to automatically follow HTTP redirects (FOLLOWLOCATION enabled)
  • Only the initial URL is subject to SSRF filtering, while redirect targets are not re-validated

In such contexts, the pyLoad server can be abused as a proxy to reach internal services that are not directly reachable by the attacker.

Exploit preconditions

  • Attack surface: pyLoad web UI or API endpoint that accepts user-supplied download URLs.
  • Required access: Authenticated account with the ability to ADD new downloads (no special system-level access required).
  • Network conditions: pyLoad instance must have network connectivity to internal or restricted targets (e.g., localhost, internal subnets, metadata services).
  • Trigger point: Submitting a crafted external URL that returns an HTTP redirect (3xx) to an internal IP/hostname.
  • Why exploitation is possible: The SSRF filter validates only the hostname/IP of the initial URL. pycurl is configured with FOLLOWLOCATION=1 and MAXREDIRS=10, so it transparently follows HTTP redirects without reapplying the IP/hostname validation to the redirect targets, allowing a bypass of the intended SSRF protection.

Why this happens

The root cause is an incomplete SSRF mitigation that focuses solely on the first network destination while ignoring subsequent redirect hops.

This maps to CWE-918: Server-Side Request Forgery, where the application fetches a remote resource based on user-controlled input without robustly constraining where that request may go.

The downloader correctly attempts to validate the initial URL against an IP-based allow/deny policy, but the HTTP client (pycurl) is configured to automatically follow redirects.

Because redirect locations are not revalidated, any upstream server can instruct pyLoad to fetch arbitrary internal URLs, turning the downloader into a blind SSRF primitive.

Conceptually, this is a trust boundary failure: the application assumes that validating the first hop is sufficient, while the actual behavior of the HTTP client allows additional untrusted hops that bypass the filter.

Potential impact

  • Access to internal HTTP services that are not exposed externally (e.g., admin panels, monitoring dashboards, internal APIs).
  • Interaction with cloud or container metadata services that may lead to credential disclosure.
  • Port scanning of internal networks by observing timing, error responses, or side effects.
  • Potential data exfiltration from internal endpoints that respond with sensitive information.
  • Use of pyLoad as a pivot point in a larger intrusion, aiding lateral movement within the network.
  • Triggering actions on internal services that trust requests from the pyLoad host (e.g., internal webhooks, management interfaces).

General mitigation guidance

Effective mitigation focuses on enforcing strict network egress controls from server-side HTTP clients and validating every hop of a user-influenced request flow.

Recommended defensive patterns include:

  • Treat all user-supplied URLs as untrusted and enforce allowlists for reachable domains or IP ranges.
  • Re-apply SSRF validation logic after every redirect, or disable automatic redirect following for user-controlled URLs and handle redirects in controlled application logic.
  • Introduce network-level egress filtering so that the pyLoad host can only reach explicitly approved external destinations and cannot access sensitive internal subnets or metadata IPs.
  • Segregate the downloader component into a constrained network segment with minimal access to internal resources.
  • Apply least-privilege principles to associated credentials and tokens so that any SSRF-based access yields minimal sensitive data.

How teams detect issues like this

Detection can leverage both code-centric and operational approaches:

  • Static analysis and code review:
  • Flag patterns where HTTP clients are configured with automatic redirect following (FOLLOWLOCATION, similar flags in other libraries) and user-controlled URLs.
  • Look for SSRF filters that validate only the initial request URL/host without considering redirects, DNS rebinding, or protocol changes.
  • Review downloader or HTTP proxy components for missing allowlists or network boundary checks.
  • Runtime and logging analysis:
  • Monitor application logs for repeated access attempts to internal IP ranges (e.g., 127.0.0.0/8, 10.0.0.0/8, 169.254.169.254) originating from pyLoad.
  • Use network monitoring or IDS to detect unusual outbound traffic from the pyLoad host to internal or metadata endpoints.
  • Policy and CI/CD checks:
  • Enforce linting or security policies that flag unsafe URL fetching patterns in pull requests.
  • Integrate security scanning tools that understand SSRF patterns, including redirect handling, into the development pipeline.

Sources

SourceLink
github.comgithub.com/pyload/pyload/commit/33c55da084320430edfd941b60e3da0eb1be9443
github.comgithub.com/pyload/pyload/security/advisories/GHSA-7gvf-3w72-p2pg

Frequently asked

questions

It requires an authenticated pyLoad account with ADD permissions. If registration is open or low-privileged accounts are easy to obtain, it can be effectively exploitable over the internet; otherwise, it is limited to users who already have access to the instance.

The attacker needs application-level authentication to pyLoad with the ability to add new download URLs. No shell access or administrative OS privileges are necessary, though broader network access of the pyLoad host amplifies the impact.

The most robust fix is to ensure that every outbound HTTP request influenced by user input, including all redirect targets, is subject to strict SSRF validation or constrained by a well-defined allowlist, and to disable or tightly control automatic redirect following in the HTTP client.

Design HTTP-fetching features with clear network trust boundaries, use restrictive egress and domain/IP allowlists, audit all libraries' behavior (such as redirects, protocol upgrades, and DNS resolution), and incorporate secure defaults plus automated checks for SSRF-prone patterns into the development lifecycle.

Find out what's already
exploitable in your codebase.