Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Beveiliging van Function Calling

Les 11 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Voer nooit blindelings uit
  2. Valideer voordat u uitvoert
  3. Wanneer het argument een payload wordt
  4. Beperk het veld van mogelijkheden
  5. Niet alle functies dragen hetzelfde gewicht
  6. Beperk misbruik en oneindige lussen
  7. Wat er naar het model terugkeert
  8. Belangrijkste punten

Voer nooit blindelings uit

Function calling geeft het model de mogelijkheid om binnen uw systeem de uitvoering van functies aan te vragen. Dit is krachtig, maar creëert ook een potentieel aanvalsvector. Een kwaadwillende gebruiker kan uw code niet direct uitvoeren; echter kan deze alles in het chatveld typen en zo de argumenten beïnvloeden die het model produceert. U moet een comfortabele aanname loslaten: argumenten van tool_call zijn geen interne gegevens van uw applicatie. Het zijn gebruikersgegevens die door een taalmodel zijn gegaan. Uw code moet de laatste verdedigingslinie zijn.

Valideer voordat u uitvoert

Het model genereert JSON-argumenten waarbij het alleen de grammaticale vorm garandeert, nooit de zakelijke legitimiteit. Een transaction_id kan syntactisch een string zijn, maar toch alles bevatten. De discipline is daarom om elk argument te valideren voordat u er iets mee doet, en de functie op te bouwen in drie duidelijke stappen: controleer het formaat, controleer het bestaan, en voer pas daarna uit.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Valideert het formaat van een transactie-identificatie."""
    # Verwacht formaat: T gevolgd door 4 cijfers
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Veilige versie met validatie."""
    # Stap 1: Valideer formaat
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID moet in Txxxx-formaat zijn (bijv. T1001)"
        })

    # Stap 2: Controleer bestaan
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Transactie {transaction_id} niet gevonden"
        })

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

De reguliere expressie ^T\d{4}$ doet hier al het defensieve werk: aan beide zijden verankerd, wijst deze elke string af die zelfs maar één extra teken bevat. Dit leidt direct naar de reden voor deze verankering.

Wanneer het argument een payload wordt

Beschouw dit verzoek, dat volkomen onschuldig lijkt:

User: "Find the payment with ID: T1001; DROP TABLE payments"

Het model, dat consciëntieus zijn extractiewerk doet, zou {"transaction_id": "T1001; DROP TABLE payments"} kunnen genereren. Het heeft niets verkeerd gedaan: het kreeg een identificatie en gaf deze door. Als uw functie dit argument via concatenatie in een SQL-query invoegt, bent u zojuist uw tabel kwijt. Het probleem is niet nieuw—het is klassieke SQL-injectie—maar function calling voegt een schakel toe die een valse indruk van filtering wekt.

De volgende drie versies tonen de evolutie: wat u nooit mag schrijven, het absolute minimum dat acceptabel is, en de praktijk die u moet hanteren.

# NOOIT doen — directe SQL-injectie
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# ALTIJD doen — geparametriseerde queries
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# NOG BETER — validatie + geparametriseerde query
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Ongeldig ID-formaat")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

De geparametriseerde query is voldoende om injectie te neutraliseren, aangezien de driver het argument als een waarde behandelt en niet als SQL. Validatie upstream voegt een tweede barrière toe en levert bovendien een veel duidelijkere foutmelding op dan de database zou doen.

Beperk het veld van mogelijkheden

De tweede verdedigingslinie is het beperken van wat het model kan aanvragen. Een expliciete allowlist, gescheiden van uw dispatch-woordenboek, stelt zwart op wit welke functies in deze context geautoriseerd zijn. De scheiding is belangrijk: ALLOWED_FUNCTIONS drukt een beveiligingsbeslissing uit, terwijl available_functions een implementatiestatus weergeeft. De twee verwarren komt neer op het autoriseren van een functie simpelweg omdat u deze hebt gecodeerd.

# Definieer expliciet toegestane functies
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Uitvoering met allowlist-verificatie."""
    function_name = tool_call.function.name

    # Controleer allowlist
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Functie {function_name} is niet geautoriseerd."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Functie {function_name} is niet geïmplementeerd."
        })

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

Niet alle functies dragen hetzelfde gewicht

Het lezen van een betalingsstatus en het wissen van oude records dragen uiteraard niet hetzelfde risico. Door uw functies te classificeren per niveau—alleen-lezen, schrijven, destructief—kunt u elke sessie of gebruiker het juiste bereik toekennen. Een openbare assistent voor ordertracking draait in read-modus; een backoffice-tool autoriseert schrijfbewerkingen. Wat destructieve acties betreft, is het juiste antwoord niet ze te verbieden, maar ze te escaleren: de functie retourneert confirmation_required, het model legt aan de gebruiker uit wat er gaat gebeuren, en een mens neemt de uiteindelijke beslissing.

# Risiconiveaus
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"):
    """Voert uit met verificatie van machtigingsniveau."""
    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"Alleen leesfuncties zijn geautoriseerd. "
                       f"{function_name} vereist niveau 'write'."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Actie {function_name} is destructief en "
                       f"vereist handmatige bevestiging."
        })

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

Beperk misbruik en oneindige lussen

Een slecht beheerde conversatielus kan dezelfde functie tientallen keren in een paar seconden aanroepen, hetzij door kwaadwillendheid, hetzij door een simpele kettingfout. Een glijdende teller over zestig seconden per functie kost een paar regels code en voorkomt dat een API van derden, die per aanroep wordt gefactureerd, overbelast raakt.

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()
        # Verwijder aanroepen ouder dan één minuut
        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)

Wat er naar het model terugkeert

De laatste blinde vlek is vaak de duurste. Een functie die een complete databaserij retourneert, kan een wachtwoordhash, een API-sleutel of een creditcardnummer bevatten. Toch komt alles wat u in een tool-bericht plaatst in de context van het model, wat betekent dat het potentieel kan verschijnen in de reactie op het scherm, in uw logs en bij uw provider. Het maskeren van gevoelige velden voordat u ze verzendt—recursief, om geneste objecten te dekken—is de voorzorgsmaatregel die u redt van een datalekincident.

def sanitize_result(result: dict) -> dict:
    """Verwijdert gevoelige velden voordat ze naar het model worden teruggestuurd."""
    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

Belangrijkste punten

  • Valideer altijd argumenten voordat u een functie uitvoert—formaat, type, toegestane waarden
  • Gebruik geparametriseerde queries om SQL-injectie te voorkomen
  • Implementeer een allowlist van geautoriseerde functies
  • Classificeer functies op risiconiveau (lezen, schrijven, destructief)
  • Voeg rate limiting toe om misbruik te voorkomen
  • Saniteer resultaten om te voorkomen dat gevoelige gegevens aan het model worden blootgesteld