GHSA-74V8-HGWQ-2PPV
pyLoad AIA cert chasing: authenticated user triggers blind SSRF to internal hosts via urllib on attacker AIA URLs
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:L/I:N/A:N
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-74V8-HGWQ-2PPV divulgada · CVSS 5 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Summary
When a pyLoad administrator selects the SSL verification mode "on (using aia-chaser)", pyLoad performs Authority Information Access (AIA) certificate-chain chasing for every HTTPS download URL. For such URLs, pyLoad hands the URL to the `aia-chaser` library, which connects to the target server with certificate verification disabled, reads the server certificate's AIA CA Issuers extension, and fetches each URL found there with `urllib.request.urlopen`. An authenticated user with the standard link-adding permission can submit an HTTPS URL pointing at a server they control, whose certificate carries AIA CA Issuers URLs aimed at internal hosts. pyLoad then issues blind HTTP GET requests to those internal URLs. These requests use Python's `urllib`, so they never pass through pyLoad's pycurl-based SSRF guard.
Root Cause
pyLoad's outbound SSRF protection is implemented only in the pycurl request path via a `PREREQFUNCTION` callback that calls `is_global_address()`. The AIA chasing feature runs before and beside that path: it uses the third-party `aia-chaser` library, which fetches certificate-supplied URLs through `urllib.request.urlopen` with no destination validation, no private-address check, and a TLS context configured with `CERT_NONE` so any server certificate is accepted. pyLoad invokes this library with an attacker-influenced URL and adds no SSRF guard of its own, so the certificate-driven fetches reach whatever hosts the attacker encodes into the AIA extension.
Affected symbols:
- HTTPRequest.set_request_context (src/pyload/core/network/http/http_request.py): for HTTPS URLs when the aia-chaser SSL mode is active, calls AiaChaser().fetch_ca_chain_for_url(url), driving certificate-supplied URL fetches with no SSRF guard.
- aia_chaser.chaser._download_certificate (third-party aia-chaser dependency, >= 0.9.0): calls urllib.request.urlopen on AIA CA Issuers URLs extracted from untrusted certificates, with no host validation.Impact
On a deployment where an administrator has enabled the "on (using aia-chaser)" SSL verification mode, an authenticated user with the standard link-adding permission can cause the pyLoad server to make blind HTTP GET requests to arbitrary internal hosts and ports selected by the attacker through a crafted TLS certificate. A single certificate may carry multiple AIA CA Issuers URLs, each fetched in turn, allowing the attacker to probe several internal hosts from one submitted download. Because the fetch is blind (the response is consumed internally as certificate data and not returned to the attacker), the demonstrated capability is internal service and port discovery through timing and error differences and reachability testing of endpoints such as the cloud metadata service where the network routes it. The requests are HTTP GET only, so no request body is attacker-controlled; no integrity or availability impact was demonstrated. The feature is admin-only and non-default, which significantly narrows the population of affected deployments.
Proof of Concept
Preconditions: a pyLoad deployment where an administrator has set ssl_verify to "on (using aia-chaser)"; an authenticated account with the link-adding permission; a TLS server the attacker controls; and a network path from the pyLoad host to the chosen internal target.- The attacker stands up an HTTPS server presenting a certificate whose Authority Information Access CA Issuers field contains an internal URL, for example `http://169.254.169.254/latest/meta-data/`.
- The attacker submits the HTTPS URL of that server as a download link (link-adding permission).
- Because the aia-chaser SSL mode is active, pyLoad calls the AIA chaser for the HTTPS URL. The chaser connects to the attacker server with `CERT_NONE`, reads the certificate's AIA CA Issuers URLs, and fetches each with `urllib.request.urlopen`.
Certificate AIA extension (attacker-controlled), abbreviated:
Authority Information Access:
CA Issuers - URI: http://169.254.169.254/latest/meta-data/
CA Issuers - URI: http://10.0.0.5:8080/internal/statusObserved result: the pyLoad process issues HTTP GET requests to http://169.254.169.254/latest/meta-data/ and http://10.0.0.5:8080/internal/status. The responses fail to parse as certificates, pyLoad logs the failure and falls back to its default CA bundle, and the download proceeds; the internal requests have already been sent.Attack Chain
- Exposure: The download-link submission API is network reachable and requires only the standard non-admin link-adding permission.
- Control: The attacker controls the submitted HTTPS URL, the certificate served by their host, and the AIA CA Issuers URLs embedded in that certificate (host, port, and path of each fetch).
- Path: pyLoad reads the admin-configured SSL mode, sets the aia-chaser flag, and on an HTTPS URL calls `AiaChaser().fetch_ca_chain_for_url(url)`; the library connects with `CERT_NONE`, extracts the AIA URLs, and calls `urllib.request.urlopen` on each.
- Guard: The pycurl `PREREQFUNCTION` SSRF guard and `is_global_address` are never invoked on the `urllib` path; the library validates only the URL scheme and performs no host or private-address checks; certificate-chain verification runs only after the fetches complete.
- Primitive: `urllib.request.urlopen` issues a blind HTTP GET to each attacker-chosen AIA URL.
- Result: The pyLoad server reaches attacker-selected internal hosts and ports from its own network position.
Bypass Evidence
pyLoad's SSRF guard (`is_global_address` inside the pycurl `PREREQFUNCTION`) is not reached because the AIA fetches are made by `urllib.request.urlopen` inside the `aia-chaser` library, which is entirely separate from pycurl. Inspection of the installed `aia-chaser` (version 3.4.1) confirms the SSL context uses `verify_mode=CERT_NONE` and `check_hostname=False`, that URL handling validates only the `http:`/`https:` scheme, and that the fetch uses `urlopen` with no host or private-address validation. Disproof attempts were made and failed: a non-self-signed attacker certificate proceeds past the trust checks and reaches the AIA fetch; the library's certificate-chain verification runs only after the fetches, so it cannot prevent them; pyLoad's `except` handler around the chaser call catches errors only after the requests have been sent; and AIA URLs may use plain HTTP, matching real PKI practice, so internal HTTP services are reachable. The one substantive counterargument, that the administrator opted into a feature, was examined closely: the administrator enabled a TLS-hardening mode, not a permission to fetch attacker-specified internal URLs, so the resulting SSRF crosses a different security boundary than the one intentionally configured and is not the "operator disabled a control" case.
Affected Versions
- `Ecosystem: pip`
- `Package: pyload-ng`
- `Confirmed affected range: <= 0.5.0b3.dev101`
- `Latest release checked: pyload-ng 0.5.0b3.dev101 (PyPI sdist, sha256 427cfb35bc8e0db104e86a53576b2fdef99127aec178b80f58380a7977130251)`
- `Fix status: not fixed in any released version`
The AIA chasing integration and the `aia-chaser` (>= 0.9.0) dependency are present in the latest published PyPI artifact, `pyload_ng-0.5.0b3.dev101`. The project publishes only prerelease builds; there is no final `0.5.0` release, so the upper bound is the latest published prerelease. The introduction point was not bisected, so the range uses an open lower bound. No published version contains a fix. This finding is contingent on the administrator having selected the non-default "on (using aia-chaser)" SSL verification mode.
Suggested Fix
Apply pyLoad's outbound destination policy to the AIA chasing path. Before the chaser fetches a certificate-supplied URL, resolve and validate the destination against the existing global-address policy (including IPv6 transition-form handling), or supply the library a fetch hook that enforces that check, or run AIA fetches through a single hardened client shared with the rest of pyLoad. Rejecting non-global AIA URLs preserves the intended TLS-hardening behavior for public CA endpoints while closing the internal-network reach. Interim mitigation: leave SSL verification in its default mode (do not select "on (using aia-chaser)") on deployments where untrusted users can submit download links, or ensure the pyLoad host cannot reach sensitive internal endpoints.
Reported by zx (GitHub: @manus-pi).
Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
pypipyload-ng |
Sin parche | — | — | 0.5.0b3.dev102 no afectada |
Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/pyload/pyload/security/advisories/GHSA-74v8-hgwq-2ppvLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
