Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Sandboxing a izolácia

Lekcia 7 z 14 Aktualizované 28. júla 2026 Pokročilý
Na tejto strane
  1. Prečo izolovať agentov AI?
  2. Úroveň 1: Obmedzenie prístupu k zdrojom
  3. Úroveň 2: Kontrola odchádzajúcej prevádzky
  4. Úroveň 3: Vykonávanie kódu bez dôvery voči stroju
  5. Výber správnej úrovne
  6. Kľúčové poznatky

Prečo izolovať agentov AI?

Agent AI, ktorý vykonáva kód alebo volá nástroje, sa zásadne líši od bežného chatbota. Kompromitovaný chatbot v najhoršom prípade vygeneruje trápnu odpoveď; kompromitovaný agent koná – dokáže spustiť systémové príkazy, čítať citlivé súbory alebo komunikovať s externými službami. Všetky doteraz prebrané obranné mechanizmy sa snažili predísť kompromitácii. Sandboxing mení prístup: predpokladá, že ku kompromitácii skôr či neskôr dôjde, a sústredí sa na obmedzenie toho, čo môže útočník urobiť po vniknutí do systému. Ide o zásadnú zmenu postoja, a preto sandboxing nenahrádza žiadnu z predchádzajúcich vrstiev ochrany.

Úroveň 1: Obmedzenie prístupu k zdrojom

Prvá úroveň aplikuje princíp najmenších oprávnení na súbory a príkazy. Kľúčovým technickým bodom je použitie funkcie resolve() pred porovnaním: bez nej by cesta ako /data/app/uploads/../../etc/passwd začínala povoleným adresárom a prešla by cez naivnú kontrolu prefixu. Rozlíšenie skutočnej cesty tento typ traversálu zmari, čo zostáva jedným z najčastejších útokov proti agentom manipulujúcim so súbormi.

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

Príkazy fungujú na rovnakom princípe, pričom sa používa whitelist (zoznam povolených) namiesto blacklistu (zoznamu zakázaných). Táto asymetria je rozhodujúca: blacklist ťa núti vymyslieť každý možný nebezpečný príkaz – čo je cvičenie, ktoré prehráš –, zatiaľ čo whitelist si vyžaduje len vymenovať to, čo agent skutočne potrebuje, čo sú často len tri alebo štyri príkazy.

Úroveň 2: Kontrola odchádzajúcej prevádzky

Sieťová izolácia rieši scenár exfiltrácie dát, o ktorom sme hovorili vyššie. Pokiaľ môže agent odoslať HTTP požiadavku na ľubovoľnú doménu, akékoľvek dáta, ktorých sa dotkne, môžu opustiť tvoj perimeter a odchádzajúca prevádzka bude vyzerať ako bežná aplikácia. Obmedzenie cieľových miest na explicitný zoznam zmení pokus o exfiltráciu na zaznamenanú výnimku.

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

Úroveň 3: Vykonávanie kódu bez dôvery voči stroju

Spúšťanie kódu napísaného modelom je najchúlostivejším prípadom. Nižšie uvedená implementácia kombinuje tri ochranné mechanizmy: kontrolu importov pred vykonaním, obmedzenia pamäte a času CPU nastavené priamo v skripte a prostredie redukované na absolútne minimum pri spúšťaní podprocesu.

Je potrebné upozorniť na overovanie importov. Spolieha sa na vyhľadávanie textu a obozretný útočník ho obíde – __import__("os") neobsahuje hľadaný reťazec. Toto overovanie ber ako ochrannú zábranu proti chybám a naivným pokusom, nikdy však ako bezpečnostnú hranicu. Skutočnou hranicou je izolovaný proces so svojimi limitmi zdrojov.

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

Pre produkčné prípady poskytuje Docker robustnejšiu izoláciu, pretože sa už nespolieha na spoluprácu vykonávaného kódu. Každá možnosť príkazu uzatvára konkrétne dvere: --network=none odstraňuje akúkoľvek možnosť sieťovej exfiltrácie, --read-only zabraňuje perzistencii, --memory a --cpus obmedzujú spotrebu, --tmpfs poskytuje volatilný a obmedzený pracovný priestor a --security-opt=no-new-privileges zakazuje eskaláciu počas vykonávania. Príznak --rm zničí kontajner na konci, čím garantuje, že žiadny stav neprežije z jedného vykonania do druhého.

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ýber správnej úrovne

Nakladenie všetkých troch úrovní na jednoduchý chatbot s FAQ je nákladné a zbytočné, zatiaľ čo spoliehanie sa len na prvú úroveň pri agentovi, ktorý vykonáva kód, znamená v podstate nechrániť nič. Nasledujúca tabuľka poskytuje východisko; uprav ju podľa citlivosti prístupných dát, čo často záleží viac než sofistikovanosť samotného agenta.

Scenár Odporúčaná úroveň
Jednoduchý Q&A chatbot Oprávnenia (Úroveň 1)
Agent s prístupom k API Oprávnenia + Sieť (Úrovne 1–2)
Agent vykonávajúci kód Plný Docker (Úroveň 3)
Multi-user agent Docker + izolácia relácií

Bez ohľadu na to, ktorú úroveň si vyberieš, testuj ju tak, ako by si testoval funkciu. Sandbox, ktorý nainštaluješ a potom naň zabudneš, sa časom ticho degraduje – pribudne závislosť, dočasne pripojený zväzok, doména otvorená kvôli riešeniu problémov. Pri každej aktualizácii agenta znovu spusti testy traversálu ciest a zakázaných domén: obídenie sandboxu nie je menšia anomália, je to kritický incident.

Kľúčové poznatky

  • Sandboxing je nevyhnutný hneď, ako má agent prístup k nástrojom alebo vykonáva kód
  • Tri úrovne izolácie: oprávnenia, sieť, kontajner – kombinuj podľa rizika
  • Princíp najmenších oprávnení platí pre každý zdroj: súbory, sieť, príkazy
  • Docker s --network=none a --read-only poskytuje najrobustnejšiu izoláciu
  • Izoláciu treba pravidelne testovať – obídenie sandboxu je kritický incident