Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Sandboxing en isolatie

Les 7 van 14 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. Waarom AI-agents isoleren?
  2. Niveau 1: Toegang tot bronnen beperken
  3. Niveau 2: Uitgaand verkeer beheersen
  4. Niveau 3: Code uitvoeren zonder deze het systeem te laten vertrouwen
  5. Het juiste niveau kiezen
  6. Belangrijkste punten

Waarom AI-agents isoleren?

Een AI-agent die code uitvoert of tools aanroept, verschilt fundamenteel van een simpele chatbot. Een gehackte chatbot produceert hooguit een gênant antwoord; een gehackte agent onderneemt actie—hij kan systeemcommando’s uitvoeren, gevoelige bestanden lezen of communiceren met externe diensten. Alle tot nu toe behandelde verdedigingsmechanismen hadden als doel compromittering te voorkomen. Sandboxing verandert de strategie: het gaat ervan uit dat compromittering uiteindelijk zal plaatsvinden en richt zich op het beperken van wat een aanvaller kan doen zodra hij binnen is. Dit is een fundamentele verschuiving, en daarom vervangt sandboxing geen van de eerdere lagen.

Niveau 1: Toegang tot bronnen beperken

Het eerste niveau past het principe van de minste bevoegdheid toe op bestanden en commando’s. Het belangrijkste technische punt is het gebruik van resolve() vóór vergelijking: zonder deze methode zou een pad zoals /data/app/uploads/../../etc/passwd beginnen met de toegestane map en een naïeve prefix-controle passeren. Het oplossen van het echte pad verhindert deze traversie, wat nog steeds een van de meest voorkomende aanvallen is tegen agents die bestanden manipuleren.

import os
from pathlib import Path

class SandboxPermissions:
    """Controls access permissions to resources."""

    def __init__(self, allowed_folder: str, allowed_commands: list[str]):
        self.allowed_folder = Path(allowed_folder).resolve()
        self.allowed_commands = set(allowed_commands)

    def verify_path(self, path: str) -> bool:
        """Verifies that a path is within the allowed folder."""
        resolved_path = Path(path).resolve()
        try:
            resolved_path.relative_to(self.allowed_folder)
            return True
        except ValueError:
            return False

    def verify_command(self, command: str) -> bool:
        """Verifies that a command is in the allowlist."""
        cmd_base = command.split()[0] if command else ""
        return cmd_base in self.allowed_commands

    def read_file(self, path: str) -> str:
        """Secure reading with path verification."""
        if not self.verify_path(path):
            raise PermissionError(
                f"Access denied: {path} is outside the allowed folder"
            )
        return Path(path).read_text()

# Usage
sandbox = SandboxPermissions(
    allowed_folder="/data/app/uploads",
    allowed_commands=["ls", "cat", "wc"],
)

# OK: file in allowed folder
try:
    content = sandbox.read_file("/data/app/uploads/report.txt")
except PermissionError as e:
    print(f"Blocked: {e}")

# Blocked: path traversal attempt
try:
    content = sandbox.read_file("/data/app/uploads/../../etc/passwd")
except PermissionError as e:
    print(f"Blocked: {e}")

Commando’s volgen dezelfde logica, waarbij gebruik wordt gemaakt van een allowlist in plaats van een blocklist. De asymmetrie is doorslaggevend: een blocklist dwingt u om elk gevaarlijk commando te bedenken—een oefening die u zult verliezen—terwijl een allowlist alleen vereist dat u opsomt wat de agent daadwerkelijk nodig heeft, vaak slechts drie of vier commando’s.

Niveau 2: Uitgaand verkeer beheersen

Netwerkisolatie pakt het eerder besproken exfiltratiescenario aan. Zolang de agent een HTTP-verzoek naar elk domein kan sturen, kan elke data die hij aanraakt uw perimeter verlaten, en zal het uitgaande verkeer eruitzien als gewoon applicatieverkeer. Het beperken van bestemmingen tot een expliciete lijst verandert een exfiltratiepoging in een gelogde uitzondering.

import subprocess

class NetworkSandbox:
    """Controls the agent's network communications."""

    def __init__(self, allowed_domains: list[str]):
        self.allowed_domains = set(allowed_domains)

    def is_allowed_request(self, url: str) -> bool:
        """Verifies that a URL is in the allowlist."""
        from urllib.parse import urlparse
        domain = urlparse(url).hostname
        return domain in self.allowed_domains

    def secure_fetch(self, url: str) -> str:
        """HTTP request with domain verification."""
        if not self.is_allowed_request(url):
            raise PermissionError(f"Domain not allowed: {url}")
        import urllib.request
        with urllib.request.urlopen(url, timeout=10) as resp:
            return resp.read().decode()

sandbox_net = NetworkSandbox(
    allowed_domains=["api.openai.com", "api.anthropic.com"]
)

# OK
try:
    sandbox_net.secure_fetch("https://api.openai.com/v1/models")
except PermissionError as e:
    print(e)

# Blocked: exfiltration to an external domain
try:
    sandbox_net.secure_fetch("https://attacker.com/collect")
except PermissionError as e:
    print(f"Blocked: {e}")

Niveau 3: Code uitvoeren zonder deze het systeem te laten vertrouwen

Het uitvoeren van code die door een model is geschreven, is het meest delicate geval. De onderstaande implementatie combineert drie beschermingslagen: import-controle vóór uitvoering, geheugen- en CPU-tijdslimieten die binnen het script zelf zijn ingesteld, en een omgeving die tot het absolute minimum is teruggebracht bij het starten van het subprocess.

Een waarschuwing over import-verificatie is op zijn plaats. Deze vertrouwt op tekstzoekopdrachten, en een zorgvuldige aanvaller zal deze omzeilen—__import__("os") bevat de gezochte string niet. Beschouw deze verificatie als een vangrail tegen fouten en naïeve pogingen, nooit als een beveiligingsgrens. De echte grens is het geïsoleerde proces met zijn bronnenlimieten.

import subprocess
import tempfile
import os

class ExecutionSandbox:
    """Executes model-generated code in an isolated environment."""

    def __init__(self, timeout: int = 10, max_memory_mb: int = 256):
        self.timeout = timeout
        self.max_memory = max_memory_mb

    def execute_python(self, code: str) -> dict:
        """Executes Python code in an isolated process."""
        # Security checks before execution
        dangerous_imports = ["os", "subprocess", "shutil", "socket", "requests"]
        for imp in dangerous_imports:
            if f"import {imp}" in code or f"from {imp}" in code:
                return {
                    "success": False,
                    "error": f"Forbidden import: {imp}",
                    "output": "",
                }

        # Create a temporary file
        with tempfile.NamedTemporaryFile(
            mode="w", suffix=".py", delete=False
        ) as f:
            # Add restrictions at the start of the script
            wrapper = f"""
import resource
import sys

# Limit memory
resource.setrlimit(resource.RLIMIT_AS, ({self.max_memory * 1024 * 1024}, {self.max_memory * 1024 * 1024}))

# Limit CPU time
resource.setrlimit(resource.RLIMIT_CPU, ({self.timeout}, {self.timeout}))

# User code
{code}
"""
            f.write(wrapper)
            temp_file = f.name

        try:
            result = subprocess.run(
                ["python3", temp_file],
                capture_output=True,
                text=True,
                timeout=self.timeout,
                env={"PATH": "/usr/bin", "HOME": "/tmp"},
            )
            return {
                "success": result.returncode == 0,
                "output": result.stdout[:5000],
                "error": result.stderr[:2000] if result.returncode != 0 else "",
            }
        except subprocess.TimeoutExpired:
            return {"success": False, "error": "Timeout exceeded", "output": ""}
        finally:
            os.unlink(temp_file)

# Usage
sandbox = ExecutionSandbox(timeout=5, max_memory_mb=128)

# OK: simple calculation
result = sandbox.execute_python("print(sum(range(100)))")
print(result)  # {"success": True, "output": "4950\n", "error": ""}

# Blocked: system access attempt
result = sandbox.execute_python("import os; os.listdir('/')")
print(result)  # {"success": False, "error": "Forbidden import: os"}

Voor productieomgevingen biedt Docker robuustere isolatie omdat het niet langer vertrouwt op de medewerking van de uitgevoerde code. Elke commando-optie sluit een specifieke deur: --network=none verwijdert elke mogelijkheid tot netwerkkexfiltratie, --read-only voorkomt persistentie, --memory en --cpus begrenzen het verbruik, --tmpfs biedt een vluchtige en begrensde werkruimte, en --security-opt=no-new-privileges verbiedt escalatie tijdens uitvoering. De vlag --rm vernietigt de container aan het einde, wat garandeert dat er geen status overblijft van de ene uitvoering naar de andere.

class DockerSandbox:
    """Executes code in an ephemeral Docker container."""

    def __init__(self, image: str = "python:3.12-slim"):
        self.image = image

    def execute(self, code: str, timeout: int = 10) -> dict:
        """Executes code in an isolated container."""
        cmd = [
            "docker", "run", "--rm",
            "--network=none",          # No network
            "--memory=256m",           # Memory limit
            "--cpus=0.5",              # CPU limit
            "--read-only",             # Read-only filesystem
            "--tmpfs=/tmp:size=50m",   # Limited temporary space
            "--security-opt=no-new-privileges",
            self.image,
            "python3", "-c", code,
        ]
        try:
            result = subprocess.run(
                cmd, capture_output=True, text=True, timeout=timeout
            )
            return {
                "success": result.returncode == 0,
                "output": result.stdout[:5000],
                "error": result.stderr[:2000],
            }
        except subprocess.TimeoutExpired:
            return {"success": False, "error": "Timeout", "output": ""}

Het juiste niveau kiezen

Het stapelen van alle drie de niveaus op een simpele FAQ-chatbot is kostbaar en onnodig, terwijl het alleen vertrouwen op het eerste niveau voor een agent die code uitvoert neerkomt op het beschermen van niets. De onderstaande tabel biedt een uitgangspunt; pas deze aan op basis van de gevoeligheid van de toegankelijke data, wat vaak belangrijker is dan de sophisticatie van de agent.

Scenario Aanbevolen niveau
Eenvoudige Q&A-chatbot Machtigingen (Niveau 1)
Agent met API-toegang Machtigingen + Netwerk (Niveau 1-2)
Agent die code uitvoert Volledige Docker (Niveau 3)
Multi-user agent Docker + sessie-isolatie

Welk niveau u ook kiest, test het alsof u een functie test. Een sandbox die u installeert en vervolgens vergeet, degradeert stilletjes in de loop der tijd—een toegevoegde afhankelijkheid, een “tijdelijk” gekoppeld volume, een domein geopend voor probleemoplossing. Voer bij elke agent-update opnieuw tests voor pad-traversie en verboden domeinen uit: een sandbox-omzeiling is geen kleine afwijking, het is een kritiek incident.

Belangrijkste punten

  • Sandboxing is essentieel zodra een agent toegang heeft tot tools of code uitvoert
  • Drie isolatieniveaus: machtigingen, netwerk, container—combineer op basis van risico
  • Het principe van de minste bevoegdheid geldt voor elke bron: bestanden, netwerk, commando’s
  • Docker met --network=none en --read-only biedt de meest robuuste isolatie
  • Isolatie moet regelmatig worden getest—een sandbox-omzeiling is een kritiek incident