Saltearse al contenido

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.

Si un dato externo se convierte en código, en SQL o en un objeto deserializado, ya tienes una vulnerabilidad.

Evaluar una expresión
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
# mal
cursor.execute(f"SELECT * FROM usuarios WHERE email = '{email}'")
# bien
cursor.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: 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_hmac o argon2. Nunca md5, sha1 ni sha256 a secas: son rápidos, y eso es exactamente lo malo para almacenar contraseñas.
  • Comparación de tokens: hmac.compare_digest en lugar de ==, para no filtrar información por el tiempo de comparación.

Tres puertas más pequeñas, cada una con su sustituto:

import secrets, subprocess, tarfile
# Procesos: lista de argumentos, sin shell
subprocess.run(["git", "log", "-n", "5", rama], check=True, timeout=30) # no: f"git log {rama}" con shell=True
# Tokens: el módulo secrets, no random
token = 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 raros
with 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)
  • subprocess sin shell=True y con lista de argumentos. Con shell=True y 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ñade timeout.
  • secrets para tokens. random es un generador predecible (Mersenne Twister): sirve para simulaciones, no para tokens de sesión ni enlaces de recuperación.
  • Extraer tarfile y zipfile con cuidado. Un archivo malicioso puede traer ../../etc/algo como nombre. En tarfile, filter="data" lo bloquea (lanza OutsideDestinationError; en Python 3.14 es además el filtro por defecto). zipfile.extractall normaliza 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.
  • eval sobre una expresión que tú escribes en tiempo de desarrollo, no sobre datos.
  • pickle entre 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.

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 ast
import operator
OPERADORES = {ast.Add: operator.add, ast.Sub: operator.sub,
ast.Mult: operator.mul, ast.Div: operator.truediv}
MAX_LONGITUD = 200
MAX_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úmeros
9**9**9 -> ValueError: operador no permitido: Pow
__import__('os') -> ValueError: no permitido: Call
precio*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.

  • 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.
  • 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.