Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Sandboxing a izolace

Lekce 7 z 14 Aktualizováno 28. července 2026 Pokročilý
Na této stránce
  1. Proč izolovat AI agenty?
  2. Úroveň 1: Omezení přístupu ke zdrojům
  3. Úroveň 2: Kontrola odchozího provozu
  4. Úroveň 3: Spouštění kódu bez důvěry vůči stroji
  5. Výběr správné úrovně
  6. Klíčové poznatky

Proč izolovat AI agenty?

AI agent, který spouští kód nebo volá nástroje, je zásadně odlišný od obyčejného chatbota. Kompromitovaný chatbot v nejhorším případě vygeneruje trapnou odpověď; kompromitovaný agent jedná – může spustit systémové příkazy, číst citlivé soubory nebo komunikovat s externími službami. Všechny doposud probírané obranné mechanismy měly za cíl zabránit kompromitaci. Sandboxing mění přístup: předpokládá, že k narušení dříve či později dojde, a soustředí se na omezení toho, co může útočník udělat, jakmile se dostane dovnitř. Jde o zásadní změnu paradigmatu, a proto sandboxing nenahrazuje žádné z předchozích vrstev ochrany.

Úroveň 1: Omezení přístupu ke zdrojům

První úroveň aplikuje princip nejmenších oprávnění na soubory a příkazy. Klíčovým technickým bodem je použití metody resolve() před porovnáním: bez ní by cesta jako /data/app/uploads/../../etc/passwd začínala povoleným adresářem a prošla by naivní kontrolou prefixu. Rozlišení skutečné cesty tento průnik zmaří, což zůstává jedním z nejčastějších útoků proti agentům manipulujícím se soubory.

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

Příkazy fungují na stejném principu, přičemž se používá seznam povolených položek (allowlist) namísto seznamu zakázaných (blocklist). Tato asymetrie je rozhodující: blocklist tě nutí vymyslet každý nebezpečný příkaz – cvičení, které prohraješ –, zatímco allowlist vyžaduje pouze vyjmenovat to, co agent skutečně potřebuje, což jsou často jen tři nebo čtyři příkazy.

Úroveň 2: Kontrola odchozího provozu

Izolace sítě řeší scénář exfiltrace dat diskutovaný dříve. Dokud může agent odeslat HTTP požadavek na jakoukoli doménu, mohou jakákoli data, kterých se dotkne, opustit tvůj perimetr a odchozí provoz bude vypadat jako běžná aplikace. Omezení cílů na explicitní seznam změní pokus o exfiltraci na zaznamenanou výjimku.

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: Spouštění kódu bez důvěry vůči stroji

Spouštění kódu napsaného modelem je nejnáročnější případ. Níže uvedená implementace kombinuje tři ochrany: kontrolu importů před spuštěním, limity paměti a času CPU nastavené přímo ve skriptu a prostředí redukované na absolutní minimum při spuštění podprocesu.

Je nutné upozornit na ověřování importů. Spočívá na textovém vyhledávání a zkušený útočník jej obejde – __import__("os") neobsahuje hledaný řetězec. Považuj toto ověření za ochrannou zábranu proti chybám a naivním pokusům, nikdy však jako bezpečnostní hranici. Skutečnou hranicí je izolovaný proces se svými limity zdrojů.

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

Pro produkční případy poskytuje Docker robustnější izolaci, protože se již nespoléhá na spolupráci spouštěného kódu. Každá volba příkazu zavírá specifické dveře: --network=none odstraňuje jakoukoli možnost exfiltrace po síti, --read-only zabraňuje perzistenci, --memory a --cpus omezují spotřebu, --tmpfs poskytuje volatilní a omezený pracovní prostor a --security-opt=no-new-privileges zakazuje eskalaci oprávnění během běhu. Příznak --rm zničí kontejner na konci, čímž zaručí, že mezi jednotlivými spuštěními nezůstane žádný stav.

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ýběr správné úrovně

Nasazení všech tří úrovní u jednoduchého chatbota s FAQ je nákladné a zbytečné, zatímco spoléhání se pouze na první úroveň u agenta spouštějícího kód znamená v podstatě žádnou ochranu. Následující tabulka poskytuje výchozí bod; uprav ji podle citlivosti přístupných dat, což často záleží více než sofistikovanost samotného agenta.

Scénář Doporučená úroveň
Jednoduchý Q&A chatbot Oprávnění (úroveň 1)
Agent s přístupem k API Oprávnění + síť (úrovně 1–2)
Agent spouštějící kód Plný Docker (úroveň 3)
Víceuzivatelský agent Docker + izolace relací

Ať už zvolíš jakoukoli úroveň, testuj ji stejně jako jakoukoli jinou funkci. Sandbox, který nainstaluješ a pak na něj zapomeneš, se časem tiše degraduje – přidaná závislost, svazek připojený „dočasně“, doména otevřená pro řešení problémů. Při každé aktualizaci agenta znovu spusť testy průniku cestami a testy zakázaných domén: obejití sandboxu není drobná anomálie, je to kritický incident.

Klíčové poznatky

  • Sandboxing je nezbytný, jakmile má agent přístup k nástrojům nebo spouští kód
  • Tři úrovně izolace: oprávnění, síť, kontejner – kombinuj je podle rizika
  • Princip nejmenších oprávnění platí pro každý zdroj: soubory, síť, příkazy
  • Docker s parametry --network=none a --read-only poskytuje nejrobustnější izolaci
  • Izolaci je nutné pravidelně testovat – obejití sandboxu je kritický incident