Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Sandboxing u iżolament

Lezzjoni 7 / 14 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Għaliex tiżola l-aġenti tal-AI?
  2. Livell 1: Irrestrinġi l-aċċess għar-riżorsi
  3. Livell 2: Ikkontrolla t-traffiku ‘l barra
  4. Livell 3: Esegwixxi kodiċi mingħajr ma tifdaħ bil-magna
  5. L-għażla tal-livell it-tajjeb
  6. Punti Ewlenin

Għaliex tiżola l-aġenti tal-AI?

Aġent tal-AI li jesegwixxi kodiċi jew isejjaħ għodod huwa fundamentalment differenti minn chatbot sempliċi. Chatbot kompromess jipproduċi, fl-agħar każ, tweġiba imbarazzanti; aġent kompromess jaġixxi—jista’ jħaddem kumandi tas-sistema, jaqra fajls sensittivi, jew jikkomunika ma’ servizzi esterni. Id-difiżi kollha koperti s’issa kellhom l-għan li jipprevjenu l-kompromess. Is-sandboxing ibiddel l-approċċ: jassumi li l-kompromess se jseħħ eventwalment u jiffoka fuq il-limitazzjoni ta’ dak li attakkant jista’ jagħmel ladarba jkun ġewwa. Dan huwa bidla fundamentali, u għalhekk is-sandboxing ma jissostitwixxi l-ebda wieħed mis-saffi preċedenti.

Livell 1: Irrestrinġi l-aċċess għar-riżorsi

L-ewwel livell japplika l-prinċipju tal-inqas privileġġ għal fajls u kumandi. Il-punt tekniku ewlieni huwa l-użu ta’ resolve() qabel il-konfront: mingħajru, mogħdija bħal /data/app/uploads/../../etc/passwd tibda bid-direttorju permess u tgħaddi minn kontroll tan-naiv ta’ prefiss. Ir-riżoluzzjoni tal-mogħdija reali tgħeleb din it-traversata, li tibqa’ waħda mill-aktar attakki komuni kontra aġenti li jimmanipulaw fajls.

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

Il-kumandi jsegwu l-istess loġika, billi jużaw lista ta’ permessi (allowlist) minflok lista ta’ projbizzjonijiet (blocklist). L-asimetrija hija deċiżiva: lista ta’ projbizzjonijiet tifforzalek timmaġina kull kumand perikoluż—eżerċizzju li se titlef—filwaqt li lista ta’ permessi teħtieġ biss li telenka dak li l-aġent verament jeħtieġ, spiss biss tlieta jew erba’ kumandi.

Livell 2: Ikkontrolla t-traffiku ‘l barra

L-iżolament tan-netwerk jindirizza x-xenarju ta’ eżfiltrazzjoni diskuss qabel. Sakemm l-aġent ikun jista’ jibgħat talba HTTP lil kwalunkwe dominju, kwalunkwe data li jmiss tista’ toħroġ mill-perimetru tiegħek, u t-traffiku ‘l barra jidher bħal traffiku ordinarju tal-applikazzjoni. Ir-restrizzjoni tad-destinazzjonijiet għal lista espliċita tbiddel tentattiv ta’ eżfiltrazzjoni f’eċċezzjoni rreġistrata.

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

Livell 3: Esegwixxi kodiċi mingħajr ma tifdaħ bil-magna

It-tħaddim ta’ kodiċi miktub minn mudell huwa l-aktar każ delikat. L-implimentazzjoni hawn taħt tgħaqqad tliet protezzjonijiet: verifika tal-import qabel l-eżekuzzjoni, limiti ta’ memorja u ħin tal-CPU stabbiliti fi ħdan l-iskritt innifsu, u ambjent imnaqqas għall-minimu assolut meta tniedi s-subproċess.

Twissija hija meħtieġa rigward il-verifika tal-import. Tiddependi fuq tfittxija fit-test, u attakkant attenti se jevadiha—__import__("os") ma fihx il-katina mfittxija. Itratta din il-verifika bħala gwida kontra żbalji u tentattivi naivi, qatt mhux bħala fruntiera tas-sigurtà. Il-fruntiera vera hija l-proċess iżolat bil-limiti tar-riżorsi tiegħu.

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

Għal każijiet ta’ produzzjoni, Docker jipprovdi iżolament aktar robust peress li ma jiddependix aktar fuq il-kooperazzjoni tal-kodiċi eżegwit. Kull għażla ta’ kumand tagħlaq bieb speċifiku: --network=none ineħħi kwalunkwe possibbiltà ta’ eżfiltrazzjoni tan-netwerk, --read-only jipprevjeni l-persistenza, --memory u --cpus jillimitaw il-konsum, --tmpfs jagħti spazju ta’ ħidma volatili u limitat, u --security-opt=no-new-privileges jipprojbixxi l-iskalata waqt l-eżekuzzjoni. Il-flag --rm jeqred il-kontenitur fl-aħħar, u jiggarantixxi li l-ebda stat ma jibqa’ ħaj minn eżekuzzjoni għall-oħra.

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

L-għażla tal-livell it-tajjeb

Li tpoġġi t-tliet livelli kollha fuq chatbot sempliċi ta’ FAQ huwa għali u mhux meħtieġ, filwaqt li tiddependi biss fuq l-ewwel livell għal aġent li jesegwixxi kodiċi tfisser li ma tipproteġi xejn. It-tabella hawn taħt tipprovdi punt tat-tluq; aġġustaha abbażi tas-sensittività tad-data aċċessibbli, li spiss tkun aktar importanti mis-sofistikazzjoni tal-aġent.

Xenarju Livell rakkomandat
Chatbot sempliċi ta' Mistoqsijiet u Tweġibiet Permessi (Livell 1)
Aġent b'aċċess għall-API Permessi + Network (Livelli 1-2)
Aġent li jesegwixxi kodiċi Docker sħiħ (Livell 3)
Aġent multi-utent Docker + iżolament tas-sessjoni

Ikun xi jkun il-livell li tagħżel, ittestjah kif tittestja karatteristika. Sandbox li tinstalla u mbagħad tinsa tiddeterjora silenzjożament maż-żmien—dipendenza miżjuda, volum immuntat “temporanjament”, dominju miftuħ għas-soluzzjoni tal-problemi. Erġa’ ġġib it-testijiet ta’ traversata tal-mogħdija u d-dominji pprojbiti ma’ kull aġġornament tal-aġent: evażjoni tas-sandbox mhix anomalija minuri, hija inċident kritiku.

Punti Ewlenin

  • Is-sandboxing huwa essenzjali hekk kif aġent ikollu aċċess għal għodod jew jesegwixxi kodiċi
  • Tliet livelli ta’ iżolament: permessi, network, kontejner—għaqqadhom abbażi tar-riskju
  • Il-prinċipju tal-inqas privileġġ japplika għal kull riżorsa: fajls, network, kumandi
  • Docker b’--network=none u --read-only jipprovdi l-aktar iżolament robust
  • L-iżolament irid jiġi ttestjat regolarment—eważjoni tas-sandbox hija inċident kritiku