llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · justhtml

GHSA-6CR7-H2Q7-28P7

ValueError no capturado que provoca denegación de servicio mediante un dígito Unicode no ASCII en una entidad HTML numérica

Parche disponible
Descargar PNG JSON
CVSS
—
high
Fuente: —
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche el mismo día de la divulgación
Exposición11 dDesde la divulgación, 9 nov 2026, 5:08 p. m.
Detección8 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de la severidad declarada por GHSA (alta) y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Hmm… no me convence. Vigílala de cerquita.Medio riesgo, cero excusas.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
Explotación
Remediación
Parche 3.17.0
Monitoreo
Detectada +1
9 nov 26
18 nov 26
21 nov 26
9 nov 26
12 nov 26
15 nov 26
18 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-6CR7-H2Q7-28P7 divulgada
Remediación Parche 3.17.0 justhtml · 0 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Traducción automática · Ver original
Descripción del advisory
Traducción automática · GitHub

Resumen

El decodificador de entidades HTML de justhtml termina con un `ValueError` no capturado cuando analiza una referencia numérica de carácter cuyos dígitos contienen un dígito Unicode no ASCII, como el carácter dos en superíndice `²` (U+00B2). El recolector de dígitos decimales en `src/justhtml/core/entities.py:286` usa `str.isdigit()` de Python, que acepta cualquier carácter con `Numeric_Type=Digit`, pero la conversión posterior `int(digits, 10)` en `src/justhtml/core/entities.py:215` solo acepta dígitos decimales ASCII estrictos y lanza `ValueError` con el resto. Cualquier invocador que analice HTML no confiable mediante el constructor público `JustHTML(...)` o la API `stream(...)` se ve afectado; no se requiere autenticación, configuración especial ni interacción del usuario. Una carga útil de 4 bytes (`&#²;`) interrumpe de forma confiable el análisis, lo que produce una denegación de servicio.

Causa raíz

justHTML promete en su política de seguridad que las entradas hostiles pequeñas no deben provocar errores de conversión no capturados durante el análisis. La ruta de referencias numéricas de caracteres decimales viola esa garantía. Cuando el decodificador encuentra `&#`, recolecta la secuencia de dígitos con `while j < length and text[j].isdigit()`. `str.isdigit()` devuelve `True` para un conjunto amplio de caracteres Unicode más allá de `0` a `9` en ASCII, incluidos superíndices (`¹`, `²`, `³`), subíndices (`₀`, `₁`, `₂`, `₃`) y otros puntos de código con `Numeric_Type=Digit`. La cadena recolectada se pasa luego a `decode_numeric_entity`, que llama a `int(digits, 10)`. `int()` con una base explícita solo acepta caracteres para los que `str.isdecimal()` devuelve `True`, por lo que un dígito Unicode no decimal recolectado hace que `int()` lance `ValueError`. El recolector y el consumidor no coinciden en lo que es un "dígito", así que el validador admite un carácter que el consumidor no puede procesar.

Affected function: decode_entities_in_text (src/justhtml/core/entities.py)
  - digit collector:  src/justhtml/core/entities.py:286  while text[j].isdigit()
  - failing sink:      src/justhtml/core/entities.py:215  int(digits, base)  (base=10)
Helper: decode_numeric_entity (src/justhtml/core/entities.py), invoked at src/justhtml/core/entities.py:295

La ruta hexadecimal en `src/justhtml/core/entities.py:283` usa un conjunto explícito de caracteres ASCII (`"0123456789abcdefABCDEF"`), por lo que las referencias `&#x...;` no se ven afectadas. La protección de longitud en `src/justhtml/core/entities.py:212` solo rechaza secuencias de dígitos de más de 16 caracteres, así que un único dígito no decimal la supera sin cambios.

Impacto

Un atacante no autenticado que pueda suministrar HTML a una aplicación que lo analice con justhtml puede provocar que el analizador falle a voluntad. La carga útil es mínima (`&#²;`, 4 bytes en UTF-8), determinista en cada solicitud y funciona tanto en el texto HTML como en los valores de atributos. Como el `ValueError` no se captura en ningún punto del analizador ni en sus puntos de entrada públicos, se propaga desde `JustHTML(...)` y `stream(...)` hasta el invocador. En un servicio web típico que analiza o sanitiza HTML enviado por usuarios en línea, cada solicitud maliciosa interrumpe el procesamiento de esa solicitud, y un atacante puede repetirla para denegar el servicio. No hay impacto en la confidencialidad ni en la integridad: la falla aborta el procesamiento, pero no expone ni altera datos. El punto y coma es opcional (`&#²` también provoca el fallo).

Prueba de concepto

Any supported Python 3 interpreter with justhtml installed. No additional dependencies.

Instale justhtml y ejecute:

from justhtml import JustHTML, stream

# Constructor path: raises ValueError
JustHTML("&#\u00b2;", fragment=True)

# Streaming API path: also raises ValueError
list(stream("&#\u00b2;"))

# Attribute-value path: also raises ValueError
JustHTML('<a title="&#\u00b2;">x</a>', fragment=True)
Traceback (most recent call last):
  ...
  File ".../justhtml/core/entities.py", line 215, in decode_numeric_entity
    codepoint = int(digits, base)
ValueError: invalid literal for int() with base 10: '²'

La discrepancia de tipos subyacente se observa directamente en un intérprete básico:

>>> '²'.isdigit()
True
>>> '²'.isdecimal()
False
>>> int('²', 10)
ValueError: invalid literal for int() with base 10: '²'

Los caracteres desencadenantes confirmados incluyen `²` (U+00B2), `³` (U+00B3), `¹` (U+00B9), `⁰` (U+2070), `₀` (U+2080), `₁` (U+2081), `₂` (U+2082) y `₃` (U+2083).

Cadena de ataque

  1. Exposición: Una aplicación analiza HTML proporcionado por el atacante mediante el constructor público `JustHTML(...)` (`src/justhtml/parser/__init__.py`) o `stream(...)` (`src/justhtml/parser/stream.py`). Estos aceptan cadenas arbitrarias sin ninguna barrera de autenticación ni de configuración.
  2. Control: El atacante suministra la cadena HTML completa. La carga mínima `&#²;` coloca un dígito Unicode no ASCII justo después de `&#`. Las cadenas de Python conservan el carácter; ninguna capa de entrada lo normaliza ni lo elimina.
  3. Ruta: Al encontrar `&` en el texto, el analizador llama incondicionalmente a `decode_entities_in_text` (por ejemplo, en `src/justhtml/parser/engine.py:2070`). La rama decimal recolecta la secuencia de dígitos en `src/justhtml/core/entities.py:286`.
  4. Protección: `str.isdigit()` en `src/justhtml/core/entities.py:286` acepta `²`, y la protección de longitud en `src/justhtml/core/entities.py:212` deja pasar un único carácter. Ninguna protección rechaza el dígito no decimal antes de la conversión.
  5. Primitiva: `decode_numeric_entity` llega a `int(digits, 10)` en `src/justhtml/core/entities.py:215` y lanza `ValueError`.
  6. Resultado: El `ValueError` se propaga sin captura fuera del analizador y de la API pública, interrumpiendo el análisis. Repetir la solicitud sostiene una denegación de servicio contra cualquier aplicación que analice HTML no confiable.

Evidencia de omisión de protecciones

La protección relevante es la validación de dígitos que precede a la conversión `int()`. El recolector decimal usa `str.isdigit()`, que es más amplio que el conjunto de `str.isdecimal()` que requiere `int(..., 10)`, por lo que la validación admite caracteres que la conversión rechaza. Los intentos de encontrar una capa de protección fracasaron: ningún invocador de `decode_entities_in_text` lo envuelve en un `try/except ValueError` (los manejadores de `ValueError` en `src/justhtml/parser/engine.py` envuelven operaciones `list.index`/`list.remove` del DOM, no la decodificación de entidades), los puntos de entrada del constructor y de stream invocan el analizador sin capturar la excepción, las comprobaciones `lstrip("0")` y `len > 16` en `src/justhtml/core/entities.py:211` y `:212` dejan sin cambios una carga de un solo carácter, y ninguna normalización de entrada elimina dígitos no ASCII antes de la decodificación. La rama hexadecimal en `src/justhtml/core/entities.py:283` no se ve afectada porque usa un conjunto explícito de caracteres ASCII. Las medidas de endurecimiento contra denegación de servicio del aviso GHSA-r8cj-3554-33mr (corregido en 1.18.0) abordaron un uso indebido relacionado de `isdigit()` en la ruta de IPv4 de la linkificación (`src/justhtml/transforms/linkify_core.py`), pero nunca modificaron el decodificador de entidades, por lo que esta ruta no tenía una corrección previa.

Versiones afectadas

  • Ecosistema: `pip`
  • Paquete: `justhtml`
  • Rango afectado confirmado: `<= 3.16.0`
  • Última versión revisada: `3.16.0` (PyPI https://pypi.org/project/justhtml/3.16.0/)
  • Estado de la corrección: no corregido

El fallo se reprodujo en versiones instaladas desde PyPI que abarcan todo el historial de publicaciones del proyecto, incluidas `0.1.0`, `0.20.0`, `0.40.0`, `1.0.0`, `1.18.0`, `1.23.0`, `2.0.0`, `2.4.1`, `3.0.0`, `3.10.1`, `3.15.0` y la última, `3.16.0`. El decodificador de entidades decimales usa el recolector `isdigit()` con reconocimiento Unicode desde la primera versión publicada; el módulo se reorganizó más tarde (el decodificador ahora está en `core/entities.py`), pero el defecto es anterior a esa reorganización, por lo que el rango afectado cubre todas las versiones hasta la última inclusive. Ninguna versión corrige esta ruta.

Corrección sugerida

Recolectar los dígitos de las referencias numéricas decimales con una prueba estricta de dígitos ASCII, para que el recolector y el consumidor `int(..., 10)` acepten el mismo conjunto de caracteres. Por ejemplo, restringir la rama decimal al conjunto explícito `"0123456789"` (igual que la rama hexadecimal) o, de forma equivalente, exigir `text[j].isascii() and text[j].isdecimal()`. Como defensa en profundidad, tratar una referencia numérica que no se pueda convertir como inválida y emitir el carácter de reemplazo Unicode o conservar el texto literal, como hace el analizador en el manejo actual de referencias mal formadas, en lugar de permitir que el error de conversión escape. La corrección debe cubrir tanto la decodificación del texto HTML como la de los valores de atributos, que comparten la misma ruta `decode_entities_in_text`. Hasta que haya una actualización disponible, las aplicaciones pueden acotar la exposición limitando o filtrando previamente el HTML no confiable, pero no existe ningún indicador de configuración que desactive la ruta vulnerable de entidades decimales.

---

Reportado por zx.

Versiones

Rangos afectados

Afectada Corregida Última
justhtml≤ 3.16.0
3.16.0
3.17.0
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypijusthtml
Corregida 3.17.0 0 d 3.17.0 no afectada
Versiones corregidas3.17.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/EmilStenstrom/justhtml/security/advisories/GHSA-6cr7-h2q7-28p7

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.