Seguridad
Python no es inseguro, pero trae cuatro herramientas que permiten escribir código inseguro con una línea: eval, pickle, la interpolación de SQL y el manejo de secretos. Las cuatro tienen sustituto, y el sustituto casi siempre es más rápido de escribir de lo que parece.
En una línea
Sección titulada «En una línea»Si un dato externo se convierte en código, en SQL o en un objeto deserializado, ya tienes una vulnerabilidad.
eval y exec
Sección titulada «eval y exec»| Forma | Coste |
|---|---|
eval("[1, 2, 3]") |
7.5 µs |
ast.literal_eval("[1, 2, 3]") |
8.2 µs |
python mediciones/07-06-10-servidor-seguridad-debug.py
El coste es parecido; el riesgo no. eval ejecuta cualquier expresión, incluidas las que llaman a funciones, leen atributos y acceden a __builtins__. Un eval sobre una entrada del usuario es ejecución remota de código, con el mismo privilegio que el proceso.
ast.literal_eval sólo acepta literales: números, cadenas, listas, diccionarios, tuplas, True/False/None. Para leer un valor de configuración o un campo de un formulario, es lo que se usa.
pickle no serializa datos: serializa instrucciones para reconstruir objetos. Al deserializar, ejecuta código arbitrario a través de __reduce__. Un pickle.loads sobre bytes de una fuente no confiable es una puerta abierta, aunque el archivo «parezca» un diccionario.
| Necesitas | Usa |
|---|---|
| Intercambio con otros sistemas | JSON |
| Datos con tipos exactos, mismo proceso | pickle (nunca de red) |
| Mensajes binarios rápidos | msgpack, protobuf |
| Configuración | JSON, TOML |
# malcursor.execute(f"SELECT * FROM usuarios WHERE email = '{email}'")
# biencursor.execute("SELECT * FROM usuarios WHERE email = %s", (email,))La f-string construye la consulta con el dato dentro: una comilla en el email cambia la consulta. Los parámetros van por un canal distinto y el motor los trata como valores, nunca como SQL.
Lo mismo aplica a los identificadores: si el nombre de tabla viene del usuario, no hay parámetro que lo salve. Hay que validarlo contra una lista blanca.
Secretos y contraseñas
Sección titulada «Secretos y contraseñas»- Secretos: variables de entorno o gestor de secretos. Nunca en el repositorio, nunca en el log, nunca en un mensaje de error.
- Contraseñas:
hashlib.scrypt,hashlib.pbkdf2_hmacoargon2. Nuncamd5,sha1nisha256a secas: son rápidos, y eso es exactamente lo malo para almacenar contraseñas. - Comparación de tokens:
hmac.compare_digesten lugar de==, para no filtrar información por el tiempo de comparación.
La trampa
Sección titulada «La trampa»Procesos, tokens y archivos comprimidos
Sección titulada «Procesos, tokens y archivos comprimidos»Tres puertas más pequeñas, cada una con su sustituto:
import secrets, subprocess, tarfile
# Procesos: lista de argumentos, sin shellsubprocess.run(["git", "log", "-n", "5", rama], check=True, timeout=30) # no: f"git log {rama}" con shell=True
# Tokens: el módulo secrets, no randomtoken = secrets.token_urlsafe(32) # 43 caracteres, de la fuente criptográfica del sistema
# Extracción: filtro que rechaza rutas fuera del destino, enlaces peligrosos y permisos raroswith tarfile.open("entrada.tar.gz") as t: t.extractall("destino", filter="data") # filter= existe desde 3.12 (y en parches de 3.8 a 3.11)subprocesssinshell=Truey con lista de argumentos. Conshell=Truey un dato interpolado,; rm -rf ~es parte de la orden. Con lista, cada elemento llega al programa como un argumento y el shell no interviene. Añadetimeout.secretspara tokens.randomes un generador predecible (Mersenne Twister): sirve para simulaciones, no para tokens de sesión ni enlaces de recuperación.- Extraer
tarfileyzipfilecon cuidado. Un archivo malicioso puede traer../../etc/algocomo nombre. Entarfile,filter="data"lo bloquea (lanzaOutsideDestinationError; en Python 3.14 es además el filtro por defecto).zipfile.extractallnormaliza las rutas, pero ninguno de los dos te protege de una bomba de descompresión: comprueba el tamaño total declarado (ZipInfo.file_size) antes de extraer.
Cuándo el riesgo es aceptable
Sección titulada «Cuándo el riesgo es aceptable»evalsobre una expresión que tú escribes en tiempo de desarrollo, no sobre datos.pickleentre procesos tuyos, con permisos de sistema de archivos como frontera.- SQL dinámico con nombres de tabla de una lista blanca.
La regla general: el riesgo se evalúa por quién controla el dato, no por lo que el código parece hacer.
Ejercicio
Sección titulada «Ejercicio»Un endpoint recibe ?formula=precio*1.21 y la evalúa para calcular un total. Funciona y es flexible. Explica el riesgo y escribe una alternativa que mantenga la flexibilidad.
Solución
El riesgo: eval("precio*1.21") ejecuta cualquier expresión. Un usuario puede enviar __import__("os").system("...") y ejecutar comandos en el servidor. También puede leer variables del proceso o provocar una excepción con la traza completa.
Una lista blanca de nodos con eval encima se queda corta: "a" * 100000000 pasa el filtro (sólo hay Mult, Name y Constant) y reserva 100 MB; 9**9**9 o un producto de enteros gigantes bloquean la CPU. La lista blanca decide qué se ejecuta, pero no cuánto cuesta. La alternativa es no usar eval y evaluar el árbol con un ast.NodeVisitor que sólo conoce números, variables y cuatro operadores, con límites de longitud y de valor:
import astimport operator
OPERADORES = {ast.Add: operator.add, ast.Sub: operator.sub, ast.Mult: operator.mul, ast.Div: operator.truediv}MAX_LONGITUD = 200MAX_VALOR = 1e12
class Evaluador(ast.NodeVisitor): def __init__(self, variables): self.variables = variables
def visit_Expression(self, nodo): return self.visit(nodo.body)
def visit_Constant(self, nodo): if type(nodo.value) not in (int, float): raise ValueError("solo números") return self._acotar(nodo.value)
def visit_Name(self, nodo): if nodo.id not in self.variables: raise ValueError(f"variable desconocida: {nodo.id}") return self.variables[nodo.id]
def visit_BinOp(self, nodo): op = OPERADORES.get(type(nodo.op)) if op is None: raise ValueError(f"operador no permitido: {type(nodo.op).__name__}") return self._acotar(op(self.visit(nodo.left), self.visit(nodo.right)))
def generic_visit(self, nodo): raise ValueError(f"no permitido: {type(nodo).__name__}")
@staticmethod def _acotar(valor): if abs(valor) > MAX_VALOR: raise ValueError("valor fuera de rango") return valor
def calcular(formula: str, variables: dict[str, float]) -> float: if len(formula) > MAX_LONGITUD: raise ValueError("fórmula demasiado larga") return Evaluador(variables).visit(ast.parse(formula, mode="eval"))Con ella:
pruebas = [ ("precio*1.21", {"precio": 100.0}), ('"a"*100000000', {}), ("9**9**9", {}), ("__import__('os')", {}), ("precio*1e9*1e9", {"precio": 1.0}),]for formula, variables in pruebas: try: print(f"{formula:<20} -> {calcular(formula, variables)}") except ValueError as e: print(f"{formula:<20} -> ValueError: {e}")precio*1.21 -> 121.0"a"*100000000 -> ValueError: solo números9**9**9 -> ValueError: operador no permitido: Pow__import__('os') -> ValueError: no permitido: Callprecio*1e9*1e9 -> ValueError: valor fuera de rango(Salidas comprobadas en 3.13.7.) El generic_visit rechaza por defecto cualquier nodo que no tenga método propio, así que lo no previsto falla en lugar de pasar. No hay ejecución de código de usuario, pero tampoco «cero riesgo»: quedan los recursos (por eso los dos límites) y los fallos del propio evaluador, que conviene cubrir con pruebas de entradas hostiles. Es el patrón de las hojas de cálculo y de los motores de reglas.
Referencias
Sección titulada «Referencias»- Ramalho, L. Fluent Python, 2ª ed. Capítulo 6.
- CPython 3.13:
Lib/pickle.py,Lib/ast.py,Lib/hmac.py. - Mediciones:
mediciones/07-06-10-servidor-seguridad-debug.py.
Capítulos relacionados
Sección titulada «Capítulos relacionados»- 02 · Configuración: dónde viven los secretos.
- 04 · Logging: lo que no debe aparecer en un log.
- 08 · CI: las comprobaciones que detectan dependencias vulnerables.