Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Sandboxing og isolering

Lektion 7 af 14 Opdateret 28. juli 2026 Avanceret
På denne side
  1. Hvorfor isolere AI-agenter?
  2. Niveau 1: Begræns adgang til ressourcer
  3. Niveau 2: Kontrol af udgående trafik
  4. Niveau 3: Udfør kode uden at stole på den med maskinen
  5. Valg af det rette niveau
  6. Vigtige pointer

Hvorfor isolere AI-agenter?

En AI-agent, der udfører kode eller kalder værktøjer, er fundamentalt anderledes end en simpel chatbot. En kompromitteret chatbot producerer i værste fald et pinligt svar; en kompromitteret agent handler – den kan køre systemkommandoer, læse følsomme filer eller kommunikere med eksterne tjenester. Alle de forsvar, vi har dækket hidtil, havde til formål at forhindre kompromittering. Sandboxing ændrer tilgangen: den antager, at kompromittering før eller siden vil ske, og fokuserer på at begrænse, hvad en angriber kan gøre, når først vedkommende er inde i systemet. Dette er et fundamentalt skift, og derfor erstatter sandboxing ikke nogen af de tidligere lag.

Niveau 1: Begræns adgang til ressourcer

Det første niveau anvender princippet om mindste privilegium på filer og kommandoer. Det centrale tekniske punkt er at bruge resolve() før sammenligning: uden dette vil en sti som /data/app/uploads/../../etc/passwd starte med den tilladte mappe og bestå en naiv præfiks-tjek. Opløsning af den virkelige sti afværger denne traversal, som fortsat er en af de mest almindelige angreb mod agenter, der manipulerer filer.

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

Kommandoer følger samme logik ved at bruge en tilladelsesliste (allowlist) frem for en blokeringsliste (blocklist). Asymmetrien er afgørende: en blokeringsliste tvinger dig til at forestille dig enhver farlig kommando – en øvelse du vil tabe – hvorimod en tilladelsesliste kun kræver, at du opregner, hvad agenten faktisk har brug for, ofte blot tre eller fire kommandoer.

Niveau 2: Kontrol af udgående trafik

Netværksisolering adresserer det exfiltration-scenarie, vi diskuterede tidligere. Så længe agenten kan sende en HTTP-anmodning til ethvert domæne, kan alle data, den rører ved, forlade din perimeter, og den udgående trafik vil se ud som almindelig applikationstrafik. Ved at begrænse destinationerne til en eksplicit liste bliver et exfiltrationsforsøg til en logget undtagelse.

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: Udfør kode uden at stole på den med maskinen

At køre kode skrevet af en model er det mest delikate tilfælde. Implementeringen nedenfor kombinerer tre beskyttelser: import-tjek før udførelse, grænser for hukommelse og CPU-tid sat inde i selve scriptet, og et miljø reduceret til det absolut nødvendige ved start af underprocessen.

En advarsel er nødvendig vedrørende import-verifikation. Den stole på tekstsøgning, og en omhyggelig angriber vil omgå den – __import__("os") indeholder ikke den søgte streng. Betragt denne verifikation som en værn mod fejl og naive forsøg, aldrig som en sikkerhedsgrænse. Den virkelige grænse er den isolerede proces med sine ressourcebegrænsninger.

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

I produktionssituationer giver Docker mere robust isolering, fordi det ikke længere stole på samarbejde fra den udførte kode. Hver kommandooption lukker en specifik dør: --network=none fjerner enhver mulighed for netværks-exfiltration, --read-only forhindrer persistens, --memory og --cpus sætter loft over forbrug, --tmpfs giver flygtig og begrænset arbejdsplads, og --security-opt=no-new-privileges forbyder eskalering under udførelse. Flaget --rm ødelægger containeren til sidst og garanterer, at ingen tilstand overlever fra én udførelse til den næste.

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": ""}

Valg af det rette niveau

At stable alle tre niveauer på en simpel FAQ-chatbot er dyrt og unødvendigt, mens det kun at stole på det første niveau for en agent, der udfører kode, svarer til at beskytte ingenting. Tabellen nedenfor giver et udgangspunkt; justér den baseret på følsomheden af de tilgængelige data, hvilket ofte betyder mere end agentens sofistikering.

Scenario Anbefalet niveau
Simpel Q&A-chatbot Tilladelser (Niveau 1)
Agent med API-adgang Tilladelser + Netværk (Niveau 1-2)
Agent der udfører kode Fuld Docker (Niveau 3)
Multi-bruger agent Docker + sessionsisolering

Uanset hvilket niveau du vælger, skal du teste det, som du ville teste en funktion. En sandbox, du installerer og derefter glemmer, forringes stille og roligt over tid – en tilføjet afhængighed, et volumen monteret „midlertidigt”, et domæne åbnet til fejlfinding. Genkør tests for path traversal og forbudte domæner ved hver agentopdatering: en sandbox-omgåelse er ikke en mindre anomali, det er en kritisk hændelse.

Vigtige pointer

  • Sandboxing er essentiel, så snart en agent har adgang til værktøjer eller udfører kode
  • Tre niveauer af isolering: tilladelser, netværk, container – kombinér baseret på risiko
  • Princippet om mindste privilegium gælder for hver ressource: filer, netværk, kommandoer
  • Docker med --network=none og --read-only giver den mest robuste isolering
  • Isolering skal testes regelmæssigt – en sandbox-omgåelse er en kritisk hændelse