Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Sicurezza del Function Calling

Lezione 11 di 14 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Non eseguire mai alla cieca
  2. Convalida prima di eseguire
  3. Quando l’argomento diventa un payload
  4. Restringi il campo delle possibilità
  5. Non tutte le funzioni hanno lo stesso peso
  6. Contieni abusi ed esecuzioni fuori controllo
  7. Cosa ritorna al modello
  8. Punti chiave

Non eseguire mai alla cieca

Il function calling conferisce al modello la capacità di richiedere l’esecuzione di funzioni all’interno del tuo sistema. Questa è una funzionalità potente, ma crea anche un potenziale vettore di attacco. Un utente malintenzionato non può eseguire direttamente il tuo codice; tuttavia, può scrivere qualsiasi cosa nel campo della chat, influenzando così gli argomenti prodotti dal modello. Devi ribaltare un’assunzione comoda: gli argomenti di tool_call non sono dati interni della tua applicazione. Sono dati utente che hanno attraversato un modello linguistico. Il tuo codice deve essere l’ultima linea di difesa.

Convalida prima di eseguire

Il modello genera argomenti JSON garantendone la forma grammaticale, mai la legittimità aziendale. Un transaction_id potrebbe essere sintatticamente una stringa eppure contenere qualsiasi cosa. La disciplina, pertanto, consiste nel convalidare ogni argomento prima di farne qualcosa e strutturare la funzione in tre passaggi distinti: verificare il formato, verificare l’esistenza e solo allora eseguire.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Convalida il formato di un identificatore di transazione."""
    # Formato atteso: T seguito da 4 cifre
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Versione sicura con convalida."""
    # Passaggio 1: Convalida del formato
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "L'ID deve essere nel formato Txxxx (es. T1001)"
        })

    # Passaggio 2: Verifica dell'esistenza
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Transazione {transaction_id} non trovata"
        })

    # Passaggio 3: Esecuzione
    status = df[df["transaction_id"] == transaction_id]["payment_status"].values[0]
    return json.dumps({"status": status})

L’espressione regolare ^T\d{4}$ svolge qui tutto il lavoro difensivo: ancorata su entrambi i lati, rifiuta qualsiasi stringa contenente anche un solo carattere extra. Questo conduce direttamente alla ragione di tale ancoraggio.

Quando l’argomento diventa un payload

Considera questa richiesta, che appare perfettamente innocua:

Utente: "Trova il pagamento con ID: T1001; DROP TABLE payments"

Il modello, svolgendo coscienziosamente il suo lavoro di estrazione, potrebbe generare {"transaction_id": "T1001; DROP TABLE payments"}. Non ha fatto nulla di sbagliato: gli è stato fornito un identificatore e lo ha trasmesso. Se la tua funzione inserisce questo argomento in una query SQL tramite concatenazione, hai appena perso la tua tabella. Il problema non è nuovo: è la classica SQL injection — ma il function calling aggiunge un anello che crea la falsa impressione di un filtraggio.

Le seguenti tre versioni mostrano la progressione: cosa non devi mai scrivere, il minimo accettabile e la pratica da adottare.

# MAI fare così — SQL injection diretta
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# SEMPRE fare così — query parametrizzate
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# ANCORA MEGLIO — convalida + query parametrizzata
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Formato ID non valido")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

La query parametrizzata è sufficiente a neutralizzare l’injection, poiché il driver tratta l’argomento come un valore e non come SQL. La convalida a monte aggiunge una seconda barriera e, incidentalmente, fornisce un messaggio di errore molto più chiaro rispetto a quello del database.

Restringi il campo delle possibilità

La seconda linea di difesa consiste nel ridurre ciò che il modello può richiedere. Una allowlist esplicita, separata dal tuo dizionario di dispatch, stabilisce nero su bianco quali funzioni sono autorizzate in questo contesto. La separazione è importante: ALLOWED_FUNCTIONS esprime una decisione di sicurezza, mentre available_functions riflette uno stato di implementazione. Confondere i due equivale ad autorizzare una funzione semplicemente perché l’hai codificata.

# Definisci esplicitamente le funzioni consentite
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Esecuzione con verifica della allowlist."""
    function_name = tool_call.function.name

    # Controlla la allowlist
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"La funzione {function_name} non è autorizzata."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"La funzione {function_name} non è implementata."
        })

    # Esegui
    function_params = json.loads(tool_call.function.arguments)
    return available_functions[function_name](**function_params)

Non tutte le funzioni hanno lo stesso peso

Leggere lo stato di un pagamento ed eliminare vecchi record ovviamente non comportano lo stesso rischio. Classificare le tue funzioni per livello — sola lettura, scrittura, distruttivo — ti consente di concedere a ciascuna sessione o utente l’ambito appropriato. Un assistente pubblico per il tracciamento degli ordini funzionerà in modalità read; uno strumento di back-office autorizzerà le scritture. Per quanto riguarda le azioni distruttive, la risposta giusta non è vietarle, ma escalare: la funzione restituisce confirmation_required, il modello spiega all’utente cosa sta per accadere e un umano prende la decisione finale.

# Livelli di rischio
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"):
    """Esegue con verifica del livello di autorizzazione."""
    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"Sono autorizzate solo le funzioni di lettura. "
                       f"{function_name} richiede il livello 'write'."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"L'azione {function_name} è distruttiva e "
                       f"richiede conferma manuale."
        })

    function_params = json.loads(tool_call.function.arguments)
    return available_functions[function_name](**function_params)

Contieni abusi ed esecuzioni fuori controllo

Un ciclo di conversazione gestito male può chiamare la stessa funzione decine di volte in pochi secondi, sia per malizia che per un semplice bug di concatenazione. Un contatore scorrevole su sessanta secondi per funzione costa poche righe di codice e previene la saturazione di un’API di terze parti fatturata a chiamata.

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()
        # Pulisci le chiamate più vecchie di 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)

Cosa ritorna al modello

L’ultimo punto cieco è spesso il più costoso. Una funzione che restituisce un’intera riga di database potrebbe includere un hash della password, una chiave API o un numero di carta di credito. Eppure, tutto ciò che inserisci in un messaggio tool entra nel contesto del modello, il che significa che potrebbe potenzialmente apparire nella sua risposta sullo schermo, nei tuoi log e presso il tuo provider. Mascherare i campi sensibili prima dell’invio — ricorsivamente, per coprire oggetti nidificati — è la precauzione che ti salverà da un incidente di fuga di dati.

def sanitize_result(result: dict) -> dict:
    """Rimuove i campi sensibili prima di restituire al modello."""
    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

Punti chiave

  • Convalida sempre gli argomenti prima di eseguire una funzione: formato, tipo, valori consentiti
  • Usa query parametrizzate per prevenire la SQL injection
  • Implementa una allowlist di funzioni autorizzate
  • Classifica le funzioni per livello di rischio (lettura, scrittura, distruttivo)
  • Aggiungi il rate limiting per prevenire abusi
  • Sanifica i risultati per evitare di esporre dati sensibili al modello