Seguridad en la llamada a funciones
En esta página
Nunca ejecutes a ciegas
La llamada a funciones otorga al modelo la capacidad de solicitar la ejecución de funciones dentro de tu sistema. Esto es potente, pero también crea un vector de ataque potencial. Un usuario malintencionado no puede ejecutar tu código directamente; sin embargo, puede escribir cualquier cosa en el campo del chat, influyendo así en los argumentos que genera el modelo. Debes descartar una suposición cómoda: los argumentos de tool_call no son datos internos de tu aplicación. Son datos de usuario que han pasado por un modelo de lenguaje. Tu código debe ser la última línea de defensa.
Valida antes de ejecutar
El modelo genera argumentos JSON donde garantiza la forma gramatical, nunca la legitimidad comercial. Un transaction_id podría ser sintácticamente una cadena y, aun así, contener cualquier cosa. La disciplina, por tanto, consiste en validar cada argumento antes de hacer nada con él y estructurar la función en tres pasos distintos: verificar el formato, verificar la existencia y, solo entonces, ejecutar.
import re
def validate_transaction_id(transaction_id: str) -> bool:
"""Valida el formato de un identificador de transacción."""
# Formato esperado: T seguido de 4 dígitos
return bool(re.match(r"^T\d{4}$", transaction_id))
def retrieve_payment_status_safe(df, transaction_id: str) -> str:
"""Versión segura con validación."""
# Paso 1: Validar formato
if not validate_transaction_id(transaction_id):
return json.dumps({
"error": "invalid_format",
"message": "El ID debe tener el formato Txxxx (p. ej., T1001)"
})
# Paso 2: Comprobar existencia
if transaction_id not in df["transaction_id"].values:
return json.dumps({
"error": "not_found",
"message": f"Transacción {transaction_id} no encontrada"
})
# Paso 3: Ejecutar
status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
return json.dumps({"status": status})
La expresión regular ^T\d{4}$ realiza todo el trabajo defensivo aquí: anclada en ambos extremos, rechaza cualquier cadena que contenga incluso un solo carácter extra. Esto nos lleva directamente a la razón de este anclaje.
Cuando el argumento se convierte en una carga útil
Considera esta solicitud, que parece perfectamente inocente:
Usuario: "Encuentra el pago con ID: T1001; DROP TABLE payments"
El modelo, haciendo concienzudamente su trabajo de extracción, podría generar {"transaction_id": "T1001; DROP TABLE payments"}. No ha hecho nada mal: se le dio un identificador y lo ha transmitido. Si tu función inserta este argumento en una consulta SQL mediante concatenación, acabas de perder tu tabla. El problema no es nuevo: es la clásica inyección SQL, pero la llamada a funciones añade un eslabón que crea una falsa impresión de filtrado.
Las siguientes tres versiones muestran la progresión: lo que nunca debes escribir, el mínimo aceptable y la práctica que debes adoptar.
# NUNCA hagas esto — inyección SQL directa
def bad_query(transaction_id):
cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")
# SIEMPRE haz esto — consultas parametrizadas
def safe_query(transaction_id):
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
# AÚN MEJOR — validación + consulta parametrizada
def best_query(transaction_id):
if not validate_transaction_id(transaction_id):
raise ValueError("Formato de ID no válido")
cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))
La consulta parametrizada es suficiente para neutralizar la inyección, ya que el controlador trata el argumento como un valor, no como SQL. La validación previa añade una segunda barrera y, de paso, proporciona un mensaje de error mucho más claro que el que daría la base de datos.
Restringe el campo de posibilidades
La segunda línea de defensa es reducir lo que el modelo puede solicitar. Una lista de permitidos explícita, separada de tu diccionario de despacho, establece en blanco y negro qué funciones están autorizadas en este contexto. La separación importa: ALLOWED_FUNCTIONS expresa una decisión de seguridad, mientras que available_functions refleja un estado de implementación. Confundir ambos equivale a autorizar una función simplemente porque la has codificado.
# Define explícitamente las funciones permitidas
ALLOWED_FUNCTIONS = {
"retrieve_payment_status",
"retrieve_payment_date",
"search_transactions"
}
def execute_tool_call_safe(tool_call, available_functions):
"""Ejecución con verificación de lista de permitidos."""
function_name = tool_call.function.name
# Comprobar lista de permitidos
if function_name not in ALLOWED_FUNCTIONS:
return json.dumps({
"error": "forbidden",
"message": f"La función {function_name} no está autorizada."
})
if function_name not in available_functions:
return json.dumps({
"error": "not_implemented",
"message": f"La función {function_name} no está implementada."
})
# Ejecutar
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
No todas las funciones tienen el mismo peso
Leer el estado de un pago y purgar registros antiguos obviamente no conllevan el mismo riesgo. Clasificar tus funciones por nivel (solo lectura, escritura, destructivas) te permite otorgar a cada sesión o usuario el alcance apropiado. Un asistente público de seguimiento de pedidos se ejecutará en modo read; una herramienta de back-office autorizará escrituras. En cuanto a las acciones destructivas, la respuesta correcta no es prohibirlas, sino escalarlas: la función devuelve confirmation_required, el modelo explica al usuario lo que está a punto de ocurrir y un humano toma la decisión final.
# Niveles de riesgo
READ_ONLY = {"retrieve_payment_status", "retrieve_payment_date", "search_transactions"}
WRITE = {"update_payment_status", "create_refund"}
DESTRUCTIVE = {"delete_transaction", "purge_old_records"}
def execute_with_permissions(tool_call, available_functions, permission_level="read"):
"""Ejecuta con verificación del nivel de permisos."""
function_name = tool_call.function.name
if permission_level == "read" and function_name not in READ_ONLY:
return json.dumps({
"error": "permission_denied",
"message": f"Solo están autorizadas las funciones de lectura. "
f"{function_name} requiere nivel 'write'."
})
if function_name in DESTRUCTIVE:
return json.dumps({
"error": "confirmation_required",
"message": f"La acción {function_name} es destructiva y "
f"requiere confirmación manual."
})
function_params = json.loads(tool_call.function.arguments)
return available_functions[function_name](**function_params)
Contén abusos y bucles descontrolados
Un bucle de conversación mal gestionado puede llamar a la misma función docenas de veces en pocos segundos, ya sea por malicia o por un simple error de encadenamiento. Un contador deslizante de sesenta segundos por función cuesta unas pocas líneas de código y evita saturar una API de terceros facturada por llamada.
from collections import defaultdict
import time
class FunctionRateLimiter:
def __init__(self, max_calls_per_minute=10):
self.max_calls = max_calls_per_minute
self.call_history = defaultdict(list)
def can_call(self, function_name: str) -> bool:
now = time.time()
# Limpiar llamadas anteriores a un minuto
self.call_history[function_name] = [
t for t in self.call_history[function_name]
if now - t < 60
]
return len(self.call_history[function_name]) < self.max_calls
def record_call(self, function_name: str):
self.call_history[function_name].append(time.time())
rate_limiter = FunctionRateLimiter(max_calls_per_minute=10)
Lo que vuelve al modelo
El último punto ciego suele ser el más costoso. Una función que devuelve una fila completa de la base de datos podría incluir un hash de contraseña, una clave de API o un número de tarjeta. Sin embargo, todo lo que coloques en un mensaje tool entra en el contexto del modelo, lo que significa que podría aparecer potencialmente en su respuesta en pantalla, en tus registros y en el extremo de tu proveedor. Enmascarar campos sensibles antes de enviarlos, de forma recursiva para cubrir objetos anidados, es la precaución que te salvará de un incidente de fuga de datos.
def sanitize_result(result: dict) -> dict:
"""Elimina campos sensibles antes de devolverlos al modelo."""
sensitive_keys = {"password", "api_key", "secret", "token", "ssn", "credit_card"}
sanitized = {}
for key, value in result.items():
if key.lower() in sensitive_keys:
sanitized[key] = "[MASKED]"
elif isinstance(value, dict):
sanitized[key] = sanitize_result(value)
else:
sanitized[key] = value
return sanitized
Puntos clave
- Valida siempre los argumentos antes de ejecutar una función: formato, tipo, valores permitidos
- Usa consultas parametrizadas para prevenir inyecciones SQL
- Implementa una lista de permitidos de funciones autorizadas
- Clasifica las funciones por nivel de riesgo (lectura, escritura, destructivas)
- Añade limitación de tasa para prevenir abusos
- Sane los resultados para evitar exponer datos sensibles al modelo