llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · pyload-ng

GHSA-R44W-V6GF-X3P6

pyLoad has an authentication bypass in API key validation (check_apikey cache)

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche a -92 d de la divulgación
Exposición40 dDesde la divulgación, 9 oct 2026, 11:43 a. m.
Detección31 dDesde la divulgación hasta su ingreso al índice
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Modificada
Explotación
Remediación
Parche 0.5.0b3.dev101
Monitoreo
Detectada
Verificada
9 jul 26
9 oct 26
9 nov 26
16 nov 26
19 nov 26
9 jul 26
11 ago 26
14 sept 26
17 oct 26
19 nov 26
FechaFaseEventoDetalle
Remediación Parche 0.5.0b3.dev101 pyload-ng · -92 d desde divulgación
Divulgación Publicada GHSA-R44W-V6GF-X3P6 divulgada
Divulgación Modificada Última actualización del registro
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Descripción del advisory
Texto original · GitHub · en inglés

Summary

The API-key cache in `check_apikey()` allows an attacker to authenticate with a forged API key as long as the legitimate key for the same `key_id` has been used recently.

On a cache hit, the API key secret is never verified, resulting in a complete authentication bypass during the cache lifetime.

---

Affected Components

  • `src/pyload/core/api/init.py`
  • `Api.check_apikey()`
  • `src/pyload/core/database/apikey_database.py`
  • `check_apikey()`
  • `_check_key()`

The cache is used by normal API requests through:

  • `src/pyload/webui/app/helpers.py`

which calls:

api.check_apikey(api_key)

without providing a `ttl`, meaning the default 300-second cache is always enabled.

---

Root Cause

Successful API key validations are cached in:

self._apikey_cache

using the following structure:

{
    key_id: (timestamp, cached_data)
}

The cache key is based only on `key_id`, and that value is parsed directly from the user-supplied API key rather than being obtained from a trusted lookup.

When a cache hit occurs within the TTL, `check_apikey()` returns:

{
    "success": True,
    "data": cached_data
}

after checking only:

  • `expires_at`

At no point on this execution path is the supplied secret:

apikey[-43:]

compared against the stored key hash.

---

The actual secret verification exists only in:

_check_key()

which correctly uses:

hmac.compare_digest()

However, this function is only reached on a cache miss through the database layer's `check_apikey()` implementation.

Furthermore, the cached object cannot be used for verification because it intentionally does not include the stored key hash.

The cached record contains only:

  • `id`
  • `user_id`
  • `name`
  • `created_at`
  • `expires_at`
  • `last_used`

Since `key_hash` is absent, the cache lacks the information required to validate the presented secret.

As a result, once a legitimate request populates the cache, every subsequent request using the same `key_id` within the 300-second cache window is accepted without validating the secret.

---

Impact

`key_id` values are small sequential integers assigned when API keys are created (1, 2, 3, ...), making them trivial to enumerate.

The API key format is also publicly reconstructable from the source code.

An attacker therefore does not need to know any valid API key secret.

They only need a `key_id` whose legitimate key has been used within the previous five minutes, which is likely on an actively used deployment.

During that cache window, a forged API key follows exactly the same authentication path as a legitimate key and inherits the associated user's permissions.

This results in a complete remote authentication bypass.

I would classify the issue as Critical severity.

---

Estimated CVSS v3.1

AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H

(`AC:H` only because successful exploitation depends on the cache already containing an entry.)

---

Reproduction

1. Create an administrator account.

---

2. Generate an API key.

Example:

pl_11<43-character-secret>

where:

key_id = 1

---

3. Send a legitimate authenticated request.
curl \
  -H "X-API-Key: pl_11<real-43-char-secret>" \
  http://127.0.0.1:8000/api/status

Expected response:

HTTP/1.1 200 OK

---

4. Within 300 seconds, send the same request using a forged API key.
curl \
  -H "X-API-Key: pl_11xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" \
  http://127.0.0.1:8000/api/status

Observed response:

HTTP/1.1 200 OK

The request succeeds even though the API key secret is entirely incorrect.

---

Control Test

If the forged API key is sent before any legitimate request has populated the cache, the server correctly returns:

HTTP/1.1 401 Unauthorized

The only difference between the failing and succeeding forged request is whether the cache already contains an entry for that `key_id`.

This isolates the vulnerability specifically to the cache-hit path.

---

Suggested Fix

Cache hits should never replace secret verification.

Possible approaches include:

  • Store a value derived from the complete API key (or its hash) in the cache and verify it using `hmac.compare_digest()` on every cache hit before returning success.
  • Alternatively, key the cache using a value derived from the entire API key secret (for example, a cryptographic hash of the complete API key) rather than using only `key_id`.

Regardless of implementation, the security invariant should remain:

> The API key secret must be validated on every authenticated request, regardless of whether the cache is hit or missed.

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Versiones

Rangos afectados

Afectada Corregida Última
pyload-ng< 0.5.0b3.dev101
0.5.0b3.dev101
0.5.0b3.dev102
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypipyload-ng
Corregida 0.5.0b3.dev101 -92 d 0.5.0b3.dev102 no afectada
Versiones corregidas0.5.0b3.dev101
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Otrahttps://github.com/pyload/pyload/security/advisories/GHSA-r44w-v6gf-x3p6
Otrahttps://github.com/pyload/pyload/commit/00d1372510f915f843b1574a3f1b28fbb724a42e
Otrahttps://github.com/pyload/pyload

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.