Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Sandboxing i izolacija

Lekcija 7 od 14 Ažurirano 28. srpnja 2026. Napredno
Na ovoj stranici
  1. Zašto izolirati AI agente?
  2. Razina 1: Ograniči pristup resursima
  3. Razina 2: Kontroliraj odlazni promet
  4. Razina 3: Izvršavaj kod bez povjerenja u stroj
  5. Odabir prave razine
  6. Ključne točke

Zašto izolirati AI agente?

AI agent koji izvršava kod ili poziva alate temeljno se razlikuje od običnog chatbota. Kompromitirani chatbot u najgorem slučaju proizvede neugodan odgovor; kompromitirani agent djeluje – može pokrenuti sistemske naredbe, čitati osjetljive datoteke ili komunicirati s vanjskim uslugama. Sve dosad obrađene obrambene mjere ciljale su spriječiti kompromitaciju. Sandboxing mijenja pristup: pretpostavlja da će do kompromitacije eventualno doći i fokusira se na ograničavanje štete koju napadač može nanijeti jednom kad se probije unutra. To je temeljni zaokret, zbog čega sandboxing ne zamjenjuje nijedan od prethodnih slojeva zaštite.

Razina 1: Ograniči pristup resursima

Prva razina primjenjuje načelo najmanjih privilegija na datoteke i naredbe. Ključna tehnička točka je korištenje resolve() prije usporedbe: bez toga, putanja poput /data/app/uploads/../../etc/passwd započinje dopuštenim direktorijem i prošla bi naivnu provjeru prefiksa. Razrješivanje stvarne putanje osujećuje ovu vrstu napada traversala, koji ostaje jedan od najčešćih protiv agenata koji manipuliraju datotekama.

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

Naredbe slijede istu logiku, koristeći popis dopuštenih (allowlist) umjesto popisa blokiranih (blocklist). Asimetrija je odlučujuća: blocklist te prisiljava da zamisliš svaku opasnu naredbu – vježbu u kojoj ćeš izgubiti – dok allowlist zahtijeva samo da nabrojiš ono što agentu stvarno treba, često tek tri ili četiri naredbe.

Razina 2: Kontroliraj odlazni promet

Mrežna izolacija rješava scenarij eksfiltracije podataka o kojem smo ranije raspravljali. Sve dok agent može poslati HTTP zahtjev bilo kojoj domeni, svi podaci kojih se dotakne mogu napustiti tvoj perimetar, a odlazni promet izgledat će kao običan aplikacijski promet. Ograničavanje odredišta na eksplicitni popis pretvara pokušaj eksfiltracije u zabilježenu iznimku.

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

Razina 3: Izvršavaj kod bez povjerenja u stroj

Pokretanje koda koji je napisao model najdelikatniji je slučaj. Implementacija u nastavku kombinira tri zaštite: provjeru uvoza (import) prije izvršavanja, ograničenja memorije i CPU vremena postavljena unutar samog skripta te okruženje svedeno na najmanju moguću mjeru pri pokretanju podprocesa.

Nužno je upozorenje vezano uz provjeru uvoza. Ona se oslanja na pretraživanje teksta, a pažljivi napadač će je zaobići – __import__("os") ne sadrži traženi niz. Tu provjeru tretiraj kao zaštitnu ogradu protiv grešaka i naivnih pokušaja, nikada kao sigurnosnu granicu. Stvarna granica je izolirani proces sa svojim ograničenjima resursa.

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

Za produkcijske slučajeve, Docker pruža robusniju izolaciju jer se više ne oslanja na suradnju izvršavanog koda. Svaka opcija naredbe zatvara specifična vrata: --network=none uklanja svaku mogućnost mrežne eksfiltracije, --read-only sprječava trajnost (persistence), --memory i --cpus ograničavaju potrošnju, --tmpfs dodjeljuje volatilni i ograničeni radni prostor, a --security-opt=no-new-privileges zabranjuje eskalaciju tijekom izvršavanja. Zastavica --rm uništava kontejner na kraju, jamčeći da nikakvo stanje ne preživi od jednog izvršavanja do drugog.

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

Odabir prave razine

Slaganje sve tri razine na jednostavan chatbot s često postavljanim pitanjima (FAQ) skupo je i nepotrebno, dok se oslanjanje samo na prvu razinu za agenta koji izvršava kod svodi na to da ne štitiš ništa. Tablica u nastavku pruža polazište; prilagodi je na temelju osjetljivosti podataka kojima se pristupa, što je često važnije od sofisticiranosti samog agenta.

Scenario Preporučena razina
Jednostavan chatbot za pitanja i odgovore Dozvole (Razina 1)
Agent s pristupom API-ju Dozvole + Mreža (Razine 1-2)
Agent koji izvršava kod Puni Docker (Razina 3)
Agent za više korisnika Docker + izolacija sesije

Koju god razinu odabrao, testiraj je kao da testiraš funkcionalnost. Sandbox koji instaliraš i onda zaboraviš tiho degradira tijekom vremena – dodana ovisnost, volumen montiran „privremeno“, domena otvorena radi rješavanja problema. Ponovno pokreni testove traversala putanje i zabranjenih domena sa svakim ažuriranjem agenta: zaobilaženje sandboxa nije manja anomalija, već kritičan incident.

Ključne točke

  • Sandboxing je ključan čim agent ima pristup alatima ili izvršava kod
  • Tri razine izolacije: dozvole, mreža, kontejner – kombiniraj ih prema riziku
  • Načelo najmanjih privilegija primjenjuje se na svaki resurs: datoteke, mrežu, naredbe
  • Docker s --network=none i --read-only pruža najrobusniju izolaciju
  • Izolaciju treba redovito testirati – zaobilaženje sandboxa je kritičan incident