llamaCVEVulnerability Intelligence
/
Advisory · GitHub · PyPI · langroid

GHSA-V46X-W252-4793

La descompresión de DOCX puede agotar recursos y eludir max_chunks

Parche disponible
Descargar PNG JSON
CVSS
—
medium
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ón43 dDesde la divulgación, 9 oct 2026, 8:15 a. m.
Detección40 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 (media) 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.
Ni el CISO se despertaría por esta.Ponle etiqueta y a la cola. Ordenadito.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche 0.69.2
Monitoreo
Detectada +1
9 oct 26
19 nov 26
21 nov 26
9 oct 26
20 oct 26
31 oct 26
10 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-V46X-W252-4793 divulgada
Remediación Parche 0.69.2 langroid · 0 d desde divulgación
Divulgación Modificada Última actualización del registro
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

Detalles de la vulnerabilidad

1. Resumen

La ruta de ingesta de DOCX de Langroid acepta un documento basado en ZIP, expande su XML mediante el analizador predeterminado `unstructured` y luego tokeniza y materializa fragmentos sin aplicar el tamaño expandido de entrada configurado ni el límite `max_chunks`. Por eso, una aplicación que pasa a Langroid contenido DOCX suministrado por un atacante puede consumir CPU y memoria considerables con una entrada comprimida muy pequeña.

Reproduje el problema con el código fuente revisado de `0.68.6`. Un DOCX sintético de 52,187 bytes se expandió a un miembro `word/document.xml` de 8,086,400 bytes, aproximadamente 155 veces el tamaño de todo el archivo comprimido. Con el `ParsingConfig` predeterminado, Langroid devolvió 10,677 fragmentos aunque `max_chunks` era 10,000. La ejecución tardó 72.14 segundos en la máquina de prueba. Un listado de procesos tomado durante la ejecución mostró 516,112 KiB de memoria residente. Es una muestra, no un pico medido.

Este es un problema de agotamiento de recursos en el análisis de documentos. El reporte no afirma acceso no autenticado a un servicio de Langroid, ejecución remota de código, divulgación de datos ni modificación de datos. La explotabilidad depende de que una aplicación acepte documentos suministrados por un atacante e invoque el analizador afectado.

2. Software y versiones afectadas

El comportamiento se confirmó en `langroid` `0.68.6`, en el commit `c5d2b59d4c3a8da30b40769155a75144e4ef63c0`. La revisión verificada de `main` es el mismo commit. No se evaluaron versiones anteriores, por lo que este reporte no afirma un rango de versiones afectadas más allá de la versión probada.

La política de seguridad del repositorio incluye explícitamente las bombas de descompresión en los analizadores de documentos y pide a quienes reportan que proporcionen una prueba de concepto contra la configuración predeterminada. La política también dirige los reportes al canal privado de avisos. La página de seguridad de GitHub ofrece actualmente la acción de reporte privado. Véase la política de seguridad https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/SECURITY.md#L224-L240 y la versión 0.68.6 https://github.com/langroid/langroid/releases/tag/0.68.6.

El backend de DOCX se selecciona mediante el `DocxParsingConfig` predeterminado cuando está instalada la dependencia opcional del analizador `unstructured`. El paquete principal de Langroid no instala por sí mismo ese analizador opcional. Las aplicaciones sin él, o que nunca analizan archivos DOCX no confiables, no están expuestas por esta ruta.

3. Condiciones previas

La aplicación afectada debe usar la ingesta de documentos de Langroid con el analizador DOCX `unstructured` instalado. Además, debe recibir bytes DOCX suministrados por un atacante, una URL de documento controlada por un atacante o un archivo que el atacante pueda hacer que la aplicación procese. Este reporte no implica un receptor de red de Langroid.

El límite predeterminado de descarga por URL restringe la respuesta HTTP comprimida a 10 MiB. Ese límite no restringe el total de bytes expandidos a partir de los miembros del archivo DOCX. La ruta de entrada directa de bytes no tiene una verificación de tamaño correspondiente en `DocumentParser`.

4. Causa raíz
4.1. El analizador DOCX predeterminado acepta datos comprimidos sin un presupuesto de tamaño expandido

`DocxParsingConfig.library` usa `unstructured` como valor predeterminado. `DocumentParser.create` selecciona `UnstructuredDocxParser` para esa configuración, y el analizador pasa su entrada completa en memoria a `partition_docx` sin verificar antes los tamaños de los miembros del archivo ni el total de bytes expandidos. El código relevante de Langroid está en `parser.py` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/parser.py#L92-L121 y `document_parser.py` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_parser.py#L240-L249, líneas 269 a 282 https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_parser.py#L269-L282, y líneas 970 a 1002 https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_parser.py#L970-L1002.

En el código fuente de `unstructured` `0.18.32` incluido en el lock, `partition_docx` materializa los elementos analizados como una lista. Su validación de DOCX comprueba que la entrada sea un archivo ZIP y luego lo carga con `python-docx`. Esas comprobaciones no imponen un límite de bytes expandidos. Véase `partition/docx.py` https://github.com/Unstructured-IO/unstructured/blob/0.18.32/unstructured/partition/docx.py#L135-L182, la validación de DOCX https://github.com/Unstructured-IO/unstructured/blob/0.18.32/unstructured/partition/docx.py#L353-L365 y la carga con `python-docx` https://github.com/Unstructured-IO/unstructured/blob/0.18.32/unstructured/partition/docx.py#L226-L229.

4.2. Los límites de tamaño de URL se aplican solo a los bytes comprimidos de la respuesta

`ParsingConfig.url_max_size` tiene como valor predeterminado 10 MiB. `fetch_url_bytes` aplica ese límite mientras descarga la respuesta, antes de que Langroid pase el archivo al analizador DOCX. No mide los tamaños expandidos de las entradas del archivo. Las entradas directas de bytes se envuelven en `BytesIO` sin verificación de tamaño, y las rutas locales se leen completas. Véase `document_url.py` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_url.py#L40-L100 y `document_parser.py` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_parser.py#L269-L282, líneas 378 a 390 https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_parser.py#L378-L390.

4.3. `get_doc_chunks` no aplica `max_chunks`

`ParsingConfig.max_chunks` tiene como valor predeterminado 10,000. El divisor de texto genérico verifica este valor, pero `DocumentParser.get_doc_chunks` codifica cada página completa en una lista de tokens y agrega fragmentos en un bucle hasta consumir todos los tokens. Ese método no compara su número de fragmentos con `max_chunks`. Luego asigna identificadores de ventana a la lista completa. Véase `parser.py` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/parser.py#L112-L121, el divisor genérico con límite https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/parser.py#L339-L365 y `get_doc_chunks` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/parsing/document_parser.py#L534-L599.

4.4. El límite posterior de DocChatAgent llega demasiado tarde

`DocChatAgent` envía rutas y entradas de bytes a través de `RepoLoader.get_documents`, que llama a `DocumentParser.chunks_from_path_or_bytes`. El analizador de documentos expande, tokeniza y construye completamente la lista de fragmentos antes de devolverla. `DocChatAgent.ingest_docs` recorta la lista a `max_chunks` más adelante en su flujo de ingesta. Ese recorte posterior puede limitar lo que se almacena, pero no acota el trabajo de análisis de DOCX ni la memoria temporal ya consumida. Véase `doc_chat_agent.py` https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/agent/special/doc_chat_agent.py#L540-L611 y el recorte posterior https://github.com/langroid/langroid/blob/c5d2b59d4c3a8da30b40769155a75144e4ef63c0/langroid/agent/special/doc_chat_agent.py#L670-L710.

5. Flujo del ataque
  1. Una aplicación acepta un DOCX de un usuario no confiable o descarga una URL de DOCX en nombre de ese usuario.
  2. La aplicación invoca la ruta de ingesta de documentos de Langroid con la configuración predeterminada del analizador DOCX.
  3. El analizador expande el archivo y construye los elementos del documento sin un límite de tamaño expandido.
  4. Langroid tokeniza el contenido completo de cada página y crea fragmentos sin aplicar `max_chunks` en `get_doc_chunks`.
  5. El proceso de ingesta de la aplicación consume CPU y memoria considerables con el documento. Las solicitudes repetidas pueden agotar los workers o terminar el proceso bajo el límite de memoria configurado.
6. Prueba de concepto segura

Ejecútela únicamente en un entorno local aislado. Crea un DOCX sintético en memoria y no contacta a otro sistema ni escribe archivos. El entorno probado usó Python 3.11.9, Langroid `0.68.6`, `unstructured` `0.18.32` y `python-docx` `1.2.0`.

```python
from io import BytesIO
from time import perf_counter
from zipfile import ZIP_DEFLATED, ZipFile

from docx import Document as WordDocument
from langroid.parsing.document_parser import DocumentParser
from langroid.parsing.parser import Parser, ParsingConfig

paragraph_count = 1600
words_per_paragraph = 1000
text = b"word " * words_per_paragraph
replacement = b"".join(
b'<w:p><w:r><w:t xml:space="preserve">' + text + b"</w:t></w:r></w:p>"
for _ in range(paragraph_count)
)

base = BytesIO()
doc = WordDocument()
doc.add_paragraph("seed")
doc.save(base)

rebuilt = BytesIO()
with ZipFile(BytesIO(base.getvalue()), "r") as source, ZipFile(
rebuilt, "w", ZIP_DEFLATED, compresslevel=9
) as target:
for item in source.infolist():
payload = source.read(item.filename)
if item.filename == "word/docum

Versiones

Rangos afectados

Afectada Corregida Última
langroid< 0.69.2
0.69.2
0.69.22
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
pypilangroid
Corregida 0.69.2 0 d 0.69.22 no afectada
Versiones corregidas0.69.2
Explotación

Arsenal público

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

Referencias
Advisoryhttps://github.com/langroid/langroid/security/advisories/GHSA-v46x-w252-4793

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