Homokozózás és elszigetelés
Ezen az oldalon
Miért kell elszigetelni az AI-ügynököket?
Egy kódot futtató vagy eszközöket hívó AI-ügynök alapvetően különbözik egy egyszerű chatbottól. Egy feltört chatbot legrosszabb esetben kínos válaszokat generál; egy feltört ügynök viszont cselekszik – képes rendszerparancsokat futtatni, érzékeny fájlokat olvasni vagy külső szolgáltatásokkal kommunikálni. Az eddig tárgyalt védelmi mechanizmusok mind a kompromittálódás megelőzésére irányultak. A homokozózás (sandboxing) megváltoztatja ezt a hozzáállást: feltételezi, hogy a feltörés előbb-utóbb megtörténik, és arra fókuszál, hogy korlátozza, mit tehet egy támadó, miután bejutott a rendszerbe. Ez alapvető váltás, ezért a homokozózás nem helyettesíti a korábbi rétegeket, hanem kiegészíti azokat.
1. szint: Erőforrás-hozzáférés korlátozása
Az első szint a legkisebb jogosultság elvét alkalmazza a fájlokra és parancsokra. A kulcsfontosságú technikai részlet a resolve() használata az összehasonlítás előtt: enélkül egy olyan útvonal, mint a /data/app/uploads/../../etc/passwd, az engedélyezett könyvtárral kezdődne, és átmenne egy naiv előtag-ellenőrzésen. A valós útvonal feloldása meghiúsítja ezt a traversálást, amely továbbra is az egyik leggyakoribb támadás a fájlokat kezelő ügynökök ellen.
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}")
A parancsok ugyanerre a logikára építenek, engedélyezési listát (allowlist) használva tiltólista helyett. Az aszimmetria döntő: egy tiltólista arra kényszerít, hogy minden veszélyes parancsot előre elképzelj – egy olyan gyakorlat, amit el fogsz veszíteni –, míg egy engedélyezési lista esetén csak azt kell felsorolnod, amire az ügynöknek ténylegesen szüksége van, ami gyakran mindössze három-négy parancs.
2. szint: Kimenő forgalom szabályozása
A hálózati elszigetelés a korábban tárgyalt adatlopási (exfiltration) forgatókönyvet kezeli. Amíg az ügynök képes HTTP-kérést küldeni bármely domainre, addig bármilyen adat, amelyhez hozzáfér, elhagyhatja a perimetert, és a kimenő forgalom közönséges alkalmazásforgalomnak tűnik. A célállomások explicit listára korlátozása az adatlopási kísérletet naplózott kivétellé alakítja.
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}")
3. szint: Kód futtatása anélkül, hogy megbíznál benne a gépen
Egy modell által írt kód futtatása a legkényesebb eset. Az alábbi megvalósítás három védelmet kombinál: importálás-ellenőrzést a végrehajtás előtt, a szkripten belül beállított memória- és CPU-idő korlátokat, valamint a subprocessz indításakor a minimálisra csökkentett környezetet.
Figyelmeztetés szükséges az importálás-ellenőrzéssel kapcsolatban. Ez szöveges keresésen alapul, és egy alapos támadó kijátszhatja – a __import__("os") például nem tartalmazza a keresett karakterláncot. Tekints erre az ellenőrzésre inkább védőkorlátként a hibák és naiv kísérletek ellen, sosem biztonsági határvonalként. Az igazi határvonal az elszigetelt folyamat, a saját erőforrás-korlátaival.
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"}
Éles környezetben a Docker robosztusabb elszigetelést biztosít, mivel nem támaszkodik a futtatott kód együttműködésére. Minden parancsopció egy konkrét ajtót zár be: a --network=none megszünteti a hálózati adatlopás lehetőségét, a --read-only megakadályozza a perzisztenciát, a --memory és --cpus korlátozza a fogyasztást, a --tmpfs illékony és méretezett munkaterületet biztosít, a --security-opt=no-new-privileges pedig megtiltja a jogosultság-emelést végrehajtás közben. A --rm flag a végén megsemmisíti a konténert, garantálva, hogy egyik végrehajtásból se maradjon át állapot a következőbe.
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": ""}
A megfelelő szint kiválasztása
Mindhárom szint ráerőltetése egy egyszerű GYIK-chatbotra költséges és felesleges, míg kizárólag az első szintre hagyatkozni egy kódot futtató ügynök esetében annyit jelent, mint semmit sem védeni. Az alábbi táblázat kiindulópontot ad; igazítsd ezt a hozzáférhető adatok érzékenysége alapján, ami gyakran fontosabb, mint maga az ügynök fejlettsége.
| Forgatókönyv | Ajánlott szint |
|---|---|
| Egyszerű kérdés-felelet chatbot | Jogosultságok (1. szint) |
| API-hozzáféréssel rendelkező ügynök | Jogosultságok + Hálózat (1–2. szint) |
| Kódot futtató ügynök | Teljes Docker (3. szint) |
| Többfelhasználós ügynök | Docker + munkamenet-elszigetelés |
Bármelyik szintet is választod, teszteld úgy, ahogy egy funkciót tesztelnél. Egy homokozó, amelyet telepítesz és aztán elfelejtesz, időben csendben degradálódik – egy hozzáadott függőség, egy „ideiglenesen“ csatlakoztatott kötet, egy hibaelhárítás miatt megnyitott domain. Futtasd újra az útvonal-traverzálási és a tiltott domain teszteket minden ügynök-frissítéskor: egy homokozó-kijátszás nem apró anomália, hanem kritikus incidens.
Főbb megállapítások
- A homokozózás elengedhetetlen, amint egy ügynök hozzáfér eszközökhöz vagy kódot futtat
- Három elszigetelési szint: jogosultságok, hálózat, konténer – kombináld a kockázat alapján
- A legkisebb jogosultság elve minden erőforrásra vonatkozik: fájlok, hálózat, parancsok
- A Docker
--network=noneés--read-onlyopciókkal biztosítja a legrobosztusabb elszigetelést - Az elszigetelést rendszeresen tesztelni kell – egy homokozó-kijátszás kritikus incidens