Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Ασφάλεια Κλήσεων Συναρτήσεων

Μάθημα 11 / 14 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Μην Εκτελείτε Ποτέ Τυφλά
  2. Επικύρωση Πριν την Εκτέλεση
  3. Όταν το Όρισμα Γίνεται Φορτίο
  4. Περιορισμός του Πεδίου Δυνατοτήτων
  5. Δεν Έχουν Όλες οι Συναρτήσεις το Ίδιο Βάρος
  6. Περιόριση Καταχρήσεων και Ανεξέλεγκτων Εκτελέσεων
  7. Τι Επιστρέφει στο Μοντέλο
  8. Βασικά σημεία

Μην Εκτελείτε Ποτέ Τυφλά

Η κλήση συναρτήσεων (function calling) δίνει στο μοντέλο τη δυνατότητα να ζητήσει την εκτέλεση συναρτήσεων μέσα στο σύστημά σας. Αυτό είναι ισχυρό, αλλά δημιουργεί επίσης μια πιθανή οδό επίθεσης. Ένας κακόβουλος χρήστης δεν μπορεί να εκτελέσει απευθείας τον κώδικά σας· ωστόσο, μπορεί να γράψει οτιδήποτε στο πεδίο της συνομιλίας, επηρεάζοντας έτσι τα ορίσματα που παράγει το μοντέλο. Πρέπει να ανατρέψετε μια άνετη παραδοχή: τα ορίσματα του tool_call δεν είναι εσωτερικά δεδομένα της εφαρμογής σας. Είναι δεδομένα χρήστη που έχουν περάσει μέσα από ένα γλωσσικό μοντέλο. Ο κώδικάς σας πρέπει να είναι η τελευταία γραμμή άμυνας.

Επικύρωση Πριν την Εκτέλεση

Το μοντέλο παράγει ορίσματα JSON όπου εγγυάται τη γραμματική μορφή, ποτέ όμως τη νομιμότητα από επιχειρηματική άποψη. Ένα transaction_id μπορεί συντακτικά να είναι συμβολοσειρά, αλλά να περιέχει οτιδήποτε. Η πειθαρχία, επομένως, είναι να επικυρώνετε κάθε όρισμα πριν κάνετε οτιδήποτε με αυτό και να δομείτε τη συνάρτηση σε τρία διακριτά βήματα: επαλήθευση της μορφής, επαλήθευση της ύπαρξης και μόνο τότε εκτέλεση.

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})

Η κανονική έκφραση ^T\d{4}$ κάνει όλη την αμυντική εργασία εδώ: αγκυρωμένη και στις δύο πλευρές, απορρίπτει οποιαδήποτε συμβολοσειρά περιέχει έστω και έναν επιπλέον χαρακτήρα. Αυτό οδηγεί απευθείας στον λόγο για αυτή την αγκύρωση.

Όταν το Όρισμα Γίνεται Φορτίο

Σκεφτείτε αυτό το αίτημα, που φαίνεται απολύτως αθώο:

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

Το μοντέλο, κάνοντας συνειδητά τη δουλειά εξαγωγής του, μπορεί να παράγει {"transaction_id": "T1001; DROP TABLE payments"}. Δεν έκανε τίποτα λάθος: του δόθηκε ένα αναγνωριστικό και το προώθησε. Αν η συνάρτησή σας εισάγει αυτό το όρισμα σε ένα ερώτημα SQL μέσω συνένωσης (concatenation), μόλις χάσατε τον πίνακά σας. Το πρόβλημα δεν είναι νέο—είναι κλασική ένεση SQL—αλλά η κλήση συναρτήσεων προσθέτει έναν κρίκο που δημιουργεί μια ψευδή εντύπωση φιλτραρίσματος.

Οι τρεις παρακάτω εκδοχές δείχνουν την εξέλιξη: τι δεν πρέπει ποτέ να γράψετε, το απολύτως ελάχιστο αποδεκτό και την πρακτική που πρέπει να υιοθετήσετε.

# 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,))

Το ερώτημα με παραμέτρους (parameterized query) αρκεί για να εξουδετερώσει την ένεση, καθώς ο οδηγός (driver) αντιμετωπίζει το όρισμα ως τιμή και όχι ως SQL. Η επικύρωση upstream προσθέτει ένα δεύτερο εμπόδιο και, παρεμπιπτόντως, παρέχει ένα πολύ πιο καθαρό μήνυμα σφάλματος από ό,τι θα έκανε η βάση δεδομένων.

Περιορισμός του Πεδίου Δυνατοτήτων

Η δεύτερη γραμμή άμυνας είναι η μείωση αυτών που μπορεί να ζητήσει το μοντέλο. Μια ρητή λίστα επιτρεπόμενων (allowlist), ξεχωριστή από το λεξικό διανομής σας, ορίζει με μαύρα γράμματα ποιες συναρτήσεις είναι εξουσιοδοτημένες σε αυτό το πλαίσιο. Ο διαχωρισμός έχει σημασία: το ALLOWED_FUNCTIONS εκφράζει μια απόφαση ασφαλείας, ενώ το available_functions αντικατοπτρίζει μια κατάσταση υλοποίησης. Η σύγχυση των δύο ισοδυναμεί με την εξουσιοδότηση μιας συνάρτησης απλώς και μόνο επειδή την κωδικοποιήσατε.

# 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)

Δεν Έχουν Όλες οι Συναρτήσεις το Ίδιο Βάρος

Η ανάγνωση μιας κατάστασης πληρωμής και η εκκαθάριση παλιών εγγραφών προφανώς δεν φέρουν τον ίδιο κίνδυνο. Η ταξινόμηση των συναρτήσεών σας ανά επίπεδο—μόνο ανάγνωση, εγγραφή, καταστροφικές—σας επιτρέπει να χορηγείτε σε κάθε συνεδρία ή χρήστη το κατάλληλο εύρος. Ένας δημόσιος βοηθός παρακολούθησης παραγγελιών θα λειτουργεί σε λειτουργία read· ένα εργαλείο back-office θα εξουσιοδοτεί εγγραφές. Όσον αφορά τις καταστροφικές ενέργειες, η σωστή απάντηση δεν είναι να τις απαγορεύσετε, αλλά να τις κλιμακώσετε: η συνάρτηση επιστρέφει confirmation_required, το μοντέλο εξηγεί στον χρήστη τι πρόκειται να συμβεί και ένας άνθρωπος παίρνει την τελική απόφαση.

# 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)

Περιόριση Καταχρήσεων και Ανεξέλεγκτων Εκτελέσεων

Ένας κακώς διαχειριζόμενος βρόχος συνομιλίας μπορεί να καλέσει την ίδια συνάρτηση δεκάδες φορές σε λίγα δευτερόλεπτα, είτε λόγω κακοβούλειας είτε λόγω ενός απλού σφάλματος αλυσίδας. Ένας ολισθαίνων μετρητής ανά εξήντα δευτερόλεπτα ανά συνάρτηση κοστίζει λίγες γραμμές κώδικα και αποτρέπει τον κορεσμό ενός API τρίτου μέρους που χρεώνεται ανά κλήση.

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)

Τι Επιστρέφει στο Μοντέλο

Το τελευταίο τυφλό σημείο είναι συχνά το πιο δαπανηρό. Μια συνάρτηση που επιστρέφει μια πλήρη γραμμή βάσης δεδομένων μπορεί να περιλαμβάνει ένα hash κωδικού πρόσβασης, ένα κλειδί API ή έναν αριθμό κάρτας. Ωστόσο, ό,τι τοποθετείτε σε ένα μήνυμα tool εισέρχεται στο πλαίσιο του μοντέλου, πράγμα που σημαίνει ότι θα μπορούσε ενδεχομένως να εμφανιστεί στην απάντησή του στην οθόνη, στα αρχεία καταγραφής (logs) σας και στο τέλος του παρόχου σας. Η απόκρυψη ευαίσθητων πεδίων πριν την αποστολή—αναδρομικά, για να καλυφθούν τα ένθετα αντικείμενα—είναι η προφύλαξη που θα σας γλιτώσει από ένα περιστατικό διαρροής δεδομένων.

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

Βασικά σημεία

  • Επικυρώνετε πάντα τα ορίσματα πριν εκτελέσετε μια συνάρτηση—μορφή, τύπος, επιτρεπτές τιμές
  • Χρησιμοποιείτε ερωτήματα με παραμέτρους για την πρόληψη της ένεσης SQL
  • Υλοποιείτε μια λίστα επιτρεπόμενων (allowlist) εξουσιοδοτημένων συναρτήσεων
  • Ταξινομείτε τις συναρτήσεις ανά επίπεδο κινδύνου (ανάγνωση, εγγραφή, καταστροφικές)
  • Προσθέτετε περιορισμό ρυθμού (rate limiting) για την πρόληψη καταχρήσεων
  • Καθαρίζετε τα αποτελέσματα για να αποφύγετε την έκθεση ευαίσθητων δεδομένων στο μοντέλο