Los peligros de setattr: cómo evitar vulnerabilidades de asignación masiva en Python

La asignación masiva, también conocida como vinculación automática o inyección de objetos, es una categoría de vulnerabilidades que se producen cuando la entrada del usuario se vincula a variables u objetos dentro de un programa.

Las vulnerabilidades de asignación masiva suelen ser el resultado de que un atacante agregue campos inesperados a un objeto para manipular la lógica de un programa. Esto causó una famosa vulnerabilidad de autenticación de GitHub, en la que la funcionalidad de asignación masiva de Ruby on Rails permitió que un atacante agregara su clave pública a la organización rails de GitHub y enviara un commit a master.

Esta publicación se inspiró, en parte, en la vulnerabilidad Spring4Shell, una vulnerabilidad de ejecución remota de código (RCE) causada por la funcionalidad de vinculación automática incluida en el framework Spring. Esto motivó una investigación para determinar si podía encontrarse una vulnerabilidad similar en el ecosistema de Python.

En esta publicación, analizaremos los posibles riesgos de la función setattr() de Python y veremos cómo prevenir vulnerabilidades de asignación masiva en tu aplicación.

Presentamos setattr

Una forma común de implementar la asignación masiva en Python es usar la función integrada setattr(). Esta función recibe un objeto, el nombre de un atributo y su valor, y asigna ese valor al atributo del objeto. Puede agregar atributos nuevos y modificar los existentes.

Aunque es práctico, permitir que un usuario establezca el valor de cualquier atributo de un objeto puede tener consecuencias imprevistas.

En primer lugar, puede dar lugar a las vulnerabilidades tradicionales de lógica por asignación masiva en un programa. Ahora se pueden modificar campos de un objeto que no estaban destinados a ser modificados por un usuario.

En segundo lugar, los atributos que se pueden modificar con setattr no se limitan a los campos definidos por el programador: también se pueden establecer funciones y atributos integrados como __class__ y __dict__ . A diferencia de la vulnerabilidad Spring4Shell, setattr no puede establecer atributos secundarios anidados de un objeto, lo que limita el alcance de un ataque. Sin embargo, es fácil provocar una excepción cuando se llama a setattr, asignando un valor de cadena a __class__, o más adelante durante la ejecución del programa, sobrescribiendo una función del objeto. Provocar una excepción de esta manera puede dar lugar a un comportamiento anormal del programa o a una denegación de servicio.

El código de abajo es un pequeño ejemplo que usa setattr para crear un usuario. Si se ejecuta con la entrada first_name=Sam,last_name=S, el resultado será Sam S: Permission denied.

1class User():
2	def __init__(self, admin=False):
3    		self.admin = admin
4
5	def is_admin(self):
6    		return "You are admin!" if self.admin else "Permission denied"
7
8def parse_input(usr_in):
9	return dict([tuple(kv.split("=", 1)) for kv in usr_in.split(",") if "=" in kv])
10
11def create_user(info):
12	user = User()
13	for key, value in info.items():
14    	setattr(user, key, value)
15	return user
16
17def main():
18	user = create_user(parse_input(str(input())))
19	if hasattr(user, "first_name") and hasattr(user, "last_name"):
20    		print(f"{user.first_name} {user.last_name}: {user.is_admin()}")
21
22if __name__ == "__main__":
23	main()

Para hacer que el programa falle debido a una excepción no controlada, se puede usar la entrada first_name=Sam,last_name=S,is_admin=foo. Esta sobrescribirá la función is_admin y la reemplazará por una cadena, lo que provocará una excepción cuando se llame a la función.

La entrada first_name=Sam,last_name=S,admin=foo sobrescribe el atributo admin del objeto User con la cadena foo, porque este es un valor verdadero (Truthy). Cuando la función is_admin comprueba el atributo admin, el usuario se trata como administrador y se muestra Sam S: You are admin!.

Cómo prevenir la asignación masiva

Una estrategia general para mitigar las vulnerabilidades de asignación masiva consiste en mantener separados los objetos que contienen entradas del usuario de los objetos responsables de la lógica interna del programa. Para ello, se crean objetos de transferencia de datos (DTO), que solo contienen los campos que un usuario puede establecer. En Python, esto es fácil de hacer con dataclasses. El siguiente código muestra cómo se puede usar un DTO para definir explícitamente los campos permitidos. Si se especifican campos incorrectos, se genera un TypeError, que luego se captura y se maneja para prevenir los ataques mencionados.

1from dataclasses import dataclass
2
3@dataclass
4class UserDTO():
5	first_name: str
6	last_name: str
7
8class User():
9	def __init__(self, dto, admin=False):
10    		self.first_name = dto.first_name
11    		self.last_name = dto.last_name
12    		self.admin = admin
13
14	def is_admin(self):
15    		return "You are admin!" if self.admin else "Permission denied"
16
17def parse_input(usr_in):
18	return dict([tuple(kv.split("=", 1)) for kv in usr_in.split(",") if "=" in kv])
19
20def create_user(info):
21	try:
22    		return User(UserDTO(**info))
23	except TypeError:
24    		return None
25
26def main():
27	user = create_user(parse_input(str(input())))
28	if user:
29    		print(f"{user.first_name} {user.last_name}: {user.is_admin()}")
30
31if __name__ == "__main__":
32	main()

Validar la entrada del usuario también es una forma de prevenir las vulnerabilidades de asignación masiva. Como siempre, es mejor validar con una lista de datos aprobados en lugar de buscar datos prohibidos. El siguiente código sigue usando setattr, pero compara el nombre del atributo con una lista de atributos permitidos.

1class User():
2	allowed_fields = ["first_name", "last_name"]
3
4	def __init__(self, admin=False):
5    		self.admin = admin
6
7	def is_admin(self):
8    		return "You are admin!" if self.admin else "Permission denied"
9
10def parse_input(usr_in):
11	return dict([tuple(kv.split("=", 1)) for kv in usr_in.split(",") if "=" in kv])
12
13def create_user(info):
14	user = User()
15	for key, value in info.items():
16    		if key in User.allowed_fields:
17        			setattr(user, key, value)
18    		else:
19        			return None
20	return user
21
22def main():
23	user = create_user(parse_input(str(input())))
24	if user:
25    		print(f"{user.first_name} {user.last_name}: {user.is_admin()}")
26
27if __name__ == "__main__":
28	main()

Siempre es mejor especificar explícitamente qué entradas del usuario espera un programa, pero si necesitas más flexibilidad para manejarlas, existen alternativas a la función setattr. El módulo collections de la biblioteca estándar de Python ofrece dos clases útiles para ayudarte: collections.UserDict y collections.abc.MutableMapping. Se puede heredar de estas clases para agregar funcionalidad a las asignaciones de clave y valor. Si necesitas acceder a los valores mediante atributos en lugar de claves, puedes hacerlo implementando un método __getattr__ en tu clase. En el siguiente ejemplo, la clase User funciona como un diccionario y puede almacenar cualquier campo proporcionado por el usuario. Al sobrescribir __getattr__, cuando se accede a un atributo que no se encuentra mediante el mecanismo habitual de acceso a atributos, este se devuelve desde el diccionario de campos proporcionados por el usuario. Así, se puede acceder a estos campos de la misma manera que a los atributos, pero se evita que la entrada del usuario sobrescriba los atributos de la clase.

1from collections import UserDict
2
3class User(UserDict):
4	def __init__(self, info, admin=False):
5    		self.admin = admin
6    		super().__init__(info)
7
8	def is_admin(self):
9    		return "You are admin!" if self.admin else "Permission denied"
10
11	def __getattr__(self, name):
12    	if name in self:
13     		   	return self[name]
14    		else:
15        		raise AttributeError("'User' object has no attribute '{}'".format(name))
16
17def parse_input(usr_in):
18	return dict([tuple(kv.split("=", 1)) for kv in usr_in.split(",") if "=" in kv])
19
20def create_user(info):
21	return User(info)
22
23def main():
24	user = create_user(parse_input(str(input())))
25
26	if "first_name" in user and "last_name" in user:
27    		print(f"{user.first_name} {user.last_name}: {user.is_admin()}")
28
29if __name__ == "__main__":
30	main()

Protege tus bibliotecas de Python

En pleno desarrollo de software, puede ser difícil encontrar el equilibrio entre la seguridad, la comodidad y la flexibilidad. Algo que parece inofensivo a primera vista puede exponerte a ti y a tu aplicación a diversos riesgos de seguridad; por eso son tan importantes la educación y los métodos alternativos. Hemos explicado cómo funciona setattr y los peligros de depender de esta función en tus bibliotecas de Python, además de varias formas de prevenir vulnerabilidades de asignación masiva. Con estos conocimientos, estás más cerca de proteger tus aplicaciones de Python contra ataques y filtraciones de datos. Para obtener más información, visita nuestra página de inicio y crea una cuenta gratuita, o agenda una demostración para ver cómo Snyk puede ayudar a proteger tu código, contenedores, dependencias e infraestructura en la nube.