Sandboxning och isolering
På denna sida
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=noneoch--read-onlyerbjuder den mest robusta isoleringen - Isolering måste testas regelbundet – en kringgången sandbox är en kritisk incident