Ir al contenido principal
Español— Elegir un idioma
Menú

Seguridad en la llamada a funciones

Lección 11 de 14 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Nunca ejecutes a ciegas
  2. Valida antes de ejecutar
  3. Cuando el argumento se convierte en una carga útil
  4. Restringe el campo de posibilidades
  5. No todas las funciones tienen el mismo peso
  6. Contén abusos y bucles descontrolados
  7. Lo que vuelve al modelo
  8. Puntos clave

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