Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Sigurtà tas-Sejħiet tal-Funzjonijiet

Lezzjoni 11 / 14 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Qatt Ma Tesegwixxi Blindament
  2. Ivvvalida Qabel Ma Tesegwixxi
  3. Meta l-Argument Isir Payload
  4. Irrestrinġi l-Kamp tal-Possibbiltajiet
  5. Mhux il-Funzjonijiet Kollha Għandhom l-Istess Piż
  6. Ikkontrolla l-Abbuż u r-Runaways
  7. X’Jirritorna lill-Mudell
  8. Punti Ewlenin

Qatt Ma Tesegwixxi Blindament

Is-sejħiet tal-funzjonijiet jagħtu lill-mudell il-kapaċità li jitlob l-eżekuzzjoni ta’ funzjonijiet fis-sistema tiegħek. Dan huwa qawwi, iżda joħloq ukoll vettur ta’ attakk potenzjali. Utent malizzjuż ma jistax jesegwixxi l-kodiċi tiegħek direttament; madankollu, jista’ jikteb kwalunkwe ħaġa fil-qasam taċ-chat, u b’hekk jinfluwenza l-argumenti li jipproduċi l-mudell. Għandek taqleb preżunzjoni komda: l-argumenti ta’ tool_call mhumiex dejta interna mill-applikazzjoni tiegħek. Huma dejta tal-utent li għaddiet minn mudell tal-lingwa. Il-kodiċi tiegħek irid ikun l-aħħar linja ta’ difiża.

Ivvvalida Qabel Ma Tesegwixxi

Il-mudell jiġġenera argumenti JSON fejn jiggarantixxi l-forma grammatikali, qatt mhux il-leġittimità tan-negozju. transaction_id jista’ jkun sintattikament string iżda jkun fih kwalunkwe ħaġa. Għalhekk, id-dixxiplina hija li tivvalida kull argument qabel ma tagħmel xi ħaġa bih, u li tistruttura l-funzjoni f’tliet passi distinti: ivverifika l-format, ivverifika l-eżistenza, u mbagħad biss esegwixxi.

import re

def validate_transaction_id(transaction_id: str) -> bool:
    """Validates the format of a transaction identifier."""
    # Expected format: T followed by 4 digits
    return bool(re.match(r"^T\d{4}$", transaction_id))


def retrieve_payment_status_safe(df, transaction_id: str) -> str:
    """Secure version with validation."""
    # Step 1: Validate format
    if not validate_transaction_id(transaction_id):
        return json.dumps({
            "error": "invalid_format",
            "message": "ID must be in Txxxx format (e.g., T1001)"
        })

    # Step 2: Check existence
    if transaction_id not in df["transaction_id"].values:
        return json.dumps({
            "error": "not_found",
            "message": f"Transaction {transaction_id} not found"
        })

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

L-espressjoni regolari ^T\d{4}$ tagħmel ix-xogħol difensiv kollu hawn: imwaħħla fuq iż-żewġ naħat, tiċħad kwalunkwe string li fiha anke karattru wieħed żejjed. Dan iwassal direttament għar-raġuni għal din il-waħħla.

Meta l-Argument Isir Payload

Ikkunsidra din it-talba, li tidher kompletament innoċenti:

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

Il-mudell, billi jagħmel ix-xogħol ta’ estrazzjoni tiegħu b’mod kuxjenzjuż, jista’ jiġġenera {"transaction_id": "T1001; DROP TABLE payments"}. Ma għamel xejn ħażin: ngħata identifikatur, u għaddieh. Jekk il-funzjoni tiegħek tidħol dan l-argument f’mistoqsija SQL permezz ta’ konkatenażzjoni, għadek kemm tilfet it-tabella tiegħek. Il-problema mhix ġdida—hija SQL injection klassika—iżda s-sejħiet tal-funzjonijiet iżidu rabta li toħloq impressjoni falza ta’ filtrar.

It-tliet verżjonijiet li ġejjin juru l-progressjoni: x’qatt m’għandek tikteb, l-minimu assolut aċċettabbli, u l-prattika li għandek tadotta.

# NEVER do this — direct SQL injection
def bad_query(transaction_id):
    cursor.execute(f"SELECT * FROM payments WHERE id = ' {transaction_id}'")

# ALWAYS do this — parameterized queries
def safe_query(transaction_id):
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

# EVEN BETTER — validation + parameterized query
def best_query(transaction_id):
    if not validate_transaction_id(transaction_id):
        raise ValueError("Invalid ID format")
    cursor.execute("SELECT * FROM payments WHERE id = %s", (transaction_id,))

Il-mistoqsija parametrizzata hija biżżejjed biex tnewtralizza l-injection, peress li s-sewwieq jittratta l-argument bħala valur, mhux bħala SQL. Il-validazzjoni upstream iżżdied bħala t-tieni barriera u, inċidentalment, tipprovdi messaġġ ta’ żball ħafna aktar ċar milli jagħmel id-database.

Irrestrinġi l-Kamp tal-Possibbiltajiet

It-tieni linja ta’ difiża hija li tnaqqas dak li l-mudell jista’ jitlob. Allowlist espliċita, separata mid-dizzjunarju tad-dispaċċ tiegħek, tiddikjara b’mod ċar u skritt liema funzjonijiet huma awtorizzati f’dan il-kuntest. Is-separazzjoni hija importanti: ALLOWED_FUNCTIONS tesprimi deċiżjoni ta’ sigurtà, filwaqt li available_functions tirrifletti stat ta’ implimentazzjoni. Li tħawwad iż-żewġ affarijiet ifisser li tawtorizza funzjoni sempliċiment għax ikkodifikajtha.

# Explicitly define allowed functions
ALLOWED_FUNCTIONS = {
    "retrieve_payment_status",
    "retrieve_payment_date",
    "search_transactions"
}

def execute_tool_call_safe(tool_call, available_functions):
    """Execution with allowlist verification."""
    function_name = tool_call.function.name

    # Check allowlist
    if function_name not in ALLOWED_FUNCTIONS:
        return json.dumps({
            "error": "forbidden",
            "message": f"Function {function_name} is not authorized."
        })

    if function_name not in available_functions:
        return json.dumps({
            "error": "not_implemented",
            "message": f"Function {function_name} is not implemented."
        })

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

Mhux il-Funzjonijiet Kollha Għandhom l-Istess Piż

Il-qari tal-istatus ta’ ħlas u t-tneħħija ta’ rekords antiki ovvjament ma jġorrux l-istess riskju. Il-klassifikazzjoni tal-funzjonijiet tiegħek skont il-livell—read-only, write, destructive—tippermettilek tagħti lil kull sessjoni jew utent l-ambitu xieraq. Assistent pubbliku għat-traċċar tal-ordnijiet se jaħdem fil-modalità read; għodda back-office tawtorizza l-kitbiet. Għal azzjonijiet distruttivi, it-tweġiba t-tajba mhix li tipprojbixxihom iżda li tiskalahom: il-funzjoni tirritorna confirmation_required, il-mudell jispjega lill-utent x’se jiġri, u bniedem jagħmel is-sejħa finali.

# Risk levels
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"):
    """Executes with permission level verification."""
    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"Only read functions are authorized. "
                       f"{function_name} requires 'write' level."
        })

    if function_name in DESTRUCTIVE:
        return json.dumps({
            "error": "confirmation_required",
            "message": f"Action {function_name} is destructive and "
                       f"requires manual confirmation."
        })

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

Ikkontrolla l-Abbuż u r-Runaways

Loop ta’ konversazzjoni ġestita ħażin tista’ ssejjaħ l-istess funzjoni għexieren ta’ darbiet f’ftit sekondi, kemm jekk minħabba malizzja jew bug sempliċi ta’ katina. Konteur li jiżżerżaq fuq sittin sekonda għal kull funzjoni jiswew ftit linji ta’ kodiċi u jipprevjenu s-saturazzjoni ta’ API ta’ parti terza fatturata għal kull sejħa.

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()
        # Clean up calls older than one minute
        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)

X’Jirritorna lill-Mudell

L-aħħar punt blind spiss ikun l-aktar kostuż. Funzjoni li tirritorna ringiela sħiħa tad-database tista’ tinkludi hash tal-password, API key, jew numru tal-karta. Madankollu, kull ma tqiegħed f’messaġġ tool jidħol fil-kuntest tal-mudell, li jfisser li jista’ potenzjalment jidher fir-rispons tiegħu fuq l-iskrin, fil-logs tiegħek, u fit-tarf tal-fornitur tiegħek. Il-maskra tal-oqsma sensittivi qabel ma tibgħathom—rikorsivament, biex tkopri oġġetti mbejjta—hija l-prekawzjoni li ssalvak minn inċident ta’ tnixxija ta’ dejta.

def sanitize_result(result: dict) -> dict:
    """Removes sensitive fields before returning to the model."""
    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 Ewlenin

  • Dejjem ivvalida l-argumenti qabel ma tesegwixxi funzjoni—format, tip, valuri permessi
  • Uża mistqsijiet parametrizzati biex tipprevjeni SQL injection
  • Implimenta allowlist ta’ funzjonijiet awtorizzati
  • Ikklassifika l-funzjonijiet skont il-livell ta’ riskju (read, write, destructive)
  • Żid limitazzjoni tar-rata biex tipprevjeni l-abbuż
  • Sanitizza ir-riżultati biex tevita li tesponi dejta sensittiva lill-mudell