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

Bezpečnosť a izolácia (sandboxing)

Lekcia 12 z 14 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Poskytnutie kontroly AI: riziká
  2. Štyri pravidlá OpenAI
  3. Princíp najmenších privilégií
  4. Izolácia (Sandboxing) pomocou Dockeru
  5. Filtrovanie URL
  6. Ochrana citlivých údajov
  7. Bezpečnostné kontroly API
  8. Limity vykonávania
  9. Kontrolný zoznam bezpečnosti pre produkciu
  10. Kľúčové poznatky

Lekcia prepísaná 3. novembra 2026 na základe príručky Computer use od OpenAI, jej receptov na integráciu Computer use a dokumentácie k sieťam Docker a Playwright. Doplnenia: štyri bezpečnostné pravidlá OpenAI, úrovne potvrdenia a uznávanie pending_safety_checks. Opravy: predchádzajúca verzia odstrihla sieť pre kontajner, ktorý potreboval volať API, nechala proxy bez prístupu von, akceptovala notexample.com vo filtri určenom len pre example.com, pokazila formátovanie logov a odhadovala náklady pomocou jednej pevnej sadzby. Zdroje: Computer use · Recepty na integráciu · Playwright a Docker · Playwright, networking.

Poskytnutie kontroly AI: riziká

Computer Use dáva modelu AI schopnosť konať na počítači. Je to mocné, ale môže to byť nebezpečné. Nesprávne nakonfigurovaný agent by mohol prechádzať na škodlivé stránky, spúšťať ľubovoľný kód alebo odhaliť citlivé údaje. Nie je to teória: navštívená stránka môže obsahovať inštrukcie napísané pre model a ak ho prostredie neobmedzuje, model ich splní, akoby boli tvojou požiadavkou. Bezpečnosť nie je voliteľná – je základom každého nasadenia do produkcie.

Štyri pravidlá OpenAI

OpenAI zhrňuje bezpečnosť Computer Use do štyroch pravidiel. Aplikuj ich vo svojej aplikácii aj v behovom prostredí, nielen v inštrukciách modelu:

  • Obmedz prostredie. Použi izolovaný prehliadač alebo virtuálny stroj, zoznam povolených stránok a akcií (allowlist) a obmedz prístup len na to, čo úloha vyžaduje.
  • Považuj obsah obrazovky za nedôveryhodný. Text zo stránky, dokumentu alebo výstupu nástroja nemôže udeľovať povolenie ani nahrádzať inštrukcie používateľa. Ak stránka vyzerá ako phishing alebo vstrekovanie promptu (prompt injection), agent sa zastaví a opýta sa, ako pokračovať.
  • Potvrď vysoko rizikové akcie. Nákupy, prenos údajov, deštruktívne zmeny a všetko, čo sa ťaško vracia, zostáva pod kontrolou používateľa. Zadanie citlivých informácií do formulára sa už počíta ako prenos.
  • Ohranič a overuj vykonávanie. Nastav limity na počet krokov (turns), trvanie alebo náklady; poskytni spôsob zrušenia; a over skutočný výsledok, nielen záverečnú správu modelu.

Východiskový bod je jednoduchý: žiadosť modelu o konanie nie je povolením používateľa. Tvoj kód rozhoduje, či akciu vykoná, pozastaví na schválenie, alebo vráti kontrolu späť. Pri dávke akcií sa zastav pred prvou, ktorá vyžaduje potvrdenie.

Tri úrovne potvrdenia

OpenAI rozlišuje tri situácie s príkladmi, ktoré môžeš adoptovať do svojej politiky:

ÚroveňPríklady uvádzané OpenAI
Používateľ preberá kontrolu späťZáverečný krok zmeny hesla; obídenie bezpečnostnej bariéry, napríklad varovania HTTPS
Potvrdenie v momente akcieMazanie údajov, zmena oprávnení alebo nastavení zdieľania, riešenie CAPTCHA, inštalácia alebo spustenie stiahnutého softvéru, odoslanie alebo publikovanie v mene používateľa, finančné transakcie, nastavenia systému
Predbežné schválenie možné v počiatočnej požiadavkePrihlásenie na stránku, ktorú používateľ požiadal navštíviť, odoslanie súborov, presun alebo premenovanie súborov, prenos citlivých údajov, ktorých konkrétne použitie bolo schválené

Bez jasného schválenia v počiatočnej požiadavke potvrď tesne pred akciou. Nepýtaj sa príliš skoro: nechaj agenta postupovať vo všetkom, čo je bezpečné, potom sa zastav v bode rizika a vysvetli akciu, riziko a spôsob aplikácie údajov alebo zmeny. Ak používateľ odmietne, nič sa nevykoná a tvoj kód oznámi modelu, čo uspelo a čo zlyhalo.

Princíp najmenších privilégií

Tvoj agent by mal mať prístup len k minimu potrebnému na splnenie úlohy. Začni izolovaným prehliadačom – nikdy nie hlavným prehliadačom používateľa, ktorý obsahuje otvorené relácie pre e-mail, bankovníctvo a interné nástroje. Agent tiež nepotrebuje prístup k súborovému systému okrem vyhradenej priečinka na sťahovanie, nepotrebuje prístup do internej siete, pokiaľ to nevyžaduje business aplikácia, a nemal by mať práva administrátora, ktoré by mohli zmeniť preklik na systémový incident. Nepripájaj osobné súbory, poverenia (credentials) ani Docker socket do jeho prostredia. Nakoniec urob reláciu efemérnou: po každom behu údaje zmaž, aby workflow nikdy náhodou nepoužilo cookies alebo cache z predchádzajúceho behu.

Izolácia (Sandboxing) pomocou Dockeru

Vynárajú sa dve otázky: kde beží prehliadač a kde beží slučka a kde je API kľúč? Recept OpenAI pre Docker izoluje pracovnú plochu v kontajnere bez siete, ovládanom z hostiteľa cez docker exec: kľúč číta len SDK na hostiteľovi. Toto je najtesnejšia konfigurácia, ale funguje len pre úlohy, ktoré nepotrebujú internet. Pre ostatné úlohy OpenAI vyžaduje prostredie, ktorého odchádzajúca sieť povoľuje len stránky úlohy.

Ak ponecháš Playwright a agent musí prehliadať, môžeš dať slučku aj prehliadač do rovnakého kontajnera, za predpokladu troch podmienok: neprivilegovaný používateľ, prehliadač, ktorý nededi premenné prostredia (aby nezískal kľúč), a odchádzajúca sieť obmedzená na stránky úlohy a API.

# Playwright image for Python: browsers and system dependencies included
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# The playwright package isn't in the image: requirements.txt
# Pin playwright==1.64.1, the same version as the image
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Non-privileged user provided by the image
USER pwuser

CMD ["python", "src/main.py"]

Playwright odporúča pripnúť verziu obrazu. Obraz poskytuje prehliadače, nie knižnicu Python: nainštaluj rovnakú verziu balíka playwright. Nespúšťaj kontajner ako root, čo deaktivuje sandbox Chromium. Pre nedôveryhodné stránky Playwright odporúča aj svoj seccomp profil, ktorý pridáva systémové volania potrebné pre tento sandbox k predvolenému profilu Dockeru.

docker run --rm --init \
  --network agent-net \
  --security-opt seccomp=seccomp_profile.json \
  --ipc=host \
  --memory=2g --cpus=1.5 --pids-limit=256 \
  -e OPENAI_API_KEY \
  computer-use-agent

--init zabraňuje zombie procesom a --ipc=host, odporúčané Playwrightom, zabraňuje vyčerpaniu zdieľanej pamäte Chromiumom a jeho pádu. Toto nastavenie však zdieľa IPC namespace hostiteľa s kontajnerom. Ak to nechceš otvárať, zvýš zdieľanú pamäť namiesto toho pomocou --shm-size, ako to robí recept OpenAI pre svoj vlastný kontajner, a otestuj to na svojich najnáročnejších stránkach. Nakoniec, -e OPENAI_API_KEY bez hodnoty dedí premennú z tvojej relácie: kľúč sa neobjaví v plain texte v príkazovom riadku.

Na strane Pythonu spusti prehliadač s opatreniami z receptu OpenAI – povolený sandbox, prázdne prostredie, deaktivované rozšírenia a prístup k súborovému systému – a smeruj ho cez proxy z ďalšej sekcie, rovnako ako klienta API:

from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright

PROXY = "http://agent-proxy:3128"

# API calls go out through the filtering proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # the browser inherits no environment variables, so not the key
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # see URL filtering below
)
page = context.new_page()

Cielené obmedzenia siete

Umiestni kontajner agenta do internej siete Docker bez externého prístupu. Proxy Squid sa pripojí do tejto siete a stane sa jej jediným východom; proxy je tiež pripojené k bežnej sieti. Všetko, čo nie je explicitne povolené, z pohľadu agenta neexistuje.

# Internal network: no direct external access
docker network create --internal agent-net
# Outbound network, reserved for the proxy
docker network create sortie-proxy

# Squid proxy (image maintained by Canonical) with your allowlist
docker run -d --name agent-proxy --network sortie-proxy \
  -v "$PWD/squid.conf:/etc/squid/squid.conf:ro" \
  ubuntu/squid:6.6-24.04_beta

# The proxy joins the internal network: this is the agent's only exit
docker network connect agent-net agent-proxy
# squid.conf: allow only the task's domains and the API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Kľúčový bod: proxy je pripojené k obom sieťam. Ak by si ho spustil len v internej sieti, nemalo by samo žiadny odchádzajúci prístup. api.openai.com je na zozname, pretože v tomto nastavení volá kód agenta API zvnútra kontajnera. Prehliadač ho nepotrebuje: filter URL v ďalšej sekcii blokuje tieto volania zo stránky.

Filtrovanie URL

Druhá, jemnejšia bariéra žije priamo v prehliadači. Zachytením požiadaviek pomocou page.route porovnaj každú URL so zoznamom povolených domén špecifickým pre úlohu – často kratším ako ten v proxy – a ostatné zruš s čitateľným logom každého blokovania. Daj si pozor na pascu porovnávania reťazcov, na ktorú upozorňuje OpenAI: https://example.com.evil.test nesmie prejsť ako https://example.com a naopak notexample.com končí na example.com. Porovnávaj schému, presného hostiteľa (alebo subdoménu s predponou bodky) a port.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Block requests to unauthorized destinations."""

    def autorisee(url: str) -> bool:
        parties = urlparse(url)
        hote = parties.hostname or ""
        return (
            parties.scheme == "https"
            and parties.port in (None, 443)
            and any(hote == d or hote.endswith("." + d) for d in allowed_domains)
        )

    def check_navigation(route):
        if autorisee(route.request.url):
            route.continue_()
        else:
            print(f"  BLOQUÉ : {route.request.url}")
            route.abort()

    page.route("**/*", check_navigation)


# The browser only needs the task's sites: API calls come from your Python code, not the page.
setup_url_filter(page, ["example.com"])

Táto vrstva dopĺňa proxy; nenahrádza ju. Playwright poznamenáva, že page.route nezachytáva požiadavky vybavované service workerom, preto service_workers="block" v kontexte, a WebSockets používajú iný mechanizmus (page.route_web_socket). Filtrovanie siete zostáva tvojou primárnou bariérou.

Ochrana citlivých údajov

Maskovanie informácií na snímkach obrazovky

Každá snímka obrazovky ide do API: všetko viditeľné na obrazovke opúšťa tvoju infraštruktúru. OpenAI odporúča udržiavať poverenia mimo textu stránky a zachytávaných oblastí. Ak obrazovka obsahuje citlivé údaje, zamaskuj ich pred odoslaním zachytenia modelu. Čierny obdĺžnik cez známe oblasti stačí, za predpokladu, že poznáš ich súradnice – preto pomáha štandardizácia veľkosti viewportu, ako bolo pokryté skôr v tomto kurze. Maskovanie nemení veľkosť obrázka: súradnice vrátené modelom zostávajú platné.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Mask sensitive areas in a PNG capture."""
    img = Image.open(io.BytesIO(screenshot_bytes))
    draw = ImageDraw.Draw(img)

    for x, y, w, h in regions:
        draw.rectangle([x, y, x + w, y + h], fill="black")

    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return buffer.getvalue()

Vedomie o osude zachytení

Odpovede API sa predvolene ukladajú: to umožňuje reťazenie cez previous_response_id. S store: false musíš prvky z predchádzajúcich krokov odosielať sám. OpenAI tiež poznamenáva, že store: false neodstraňuje všetky formy uchovávania a vstupné obrázky majú vlastné výnimky: pred odoslaním snímok obsahujúcich osobné údaje si prečítaj jej ovládanie údajov.

Nikdy neloguj citlivé údaje

Rovnaké úvahy platia pre logy, ktoré často prežívajú oveľa dlhšie ako zachytenia. Filter logov prepisuje rizikové vzory pred zápisom: priradenia hesiel, API kľúče OpenAI začínajúce na sk- a 16-miestne sekvencie pripomínajúce čísla kariet. Filter pôsobí na konečnú správu, takže zachytí aj to, čo si zalogoval bez rozmýšľania.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Mask sensitive data before writing logs."""

    PATTERNS = [
        (re.compile(r"password['\"]?\s*[:=]\s*['\"]?[^\s,}]+", re.IGNORECASE), "password=***"),
        (re.compile(r"\bsk-[A-Za-z0-9_-]{20,}"), "sk-***"),
        (re.compile(r"\b\d{16}\b"), "****-****-****-****"),
    ]

    def filter(self, record):
        msg = record.getMessage()
        for pattern, replacement in self.PATTERNS:
            msg = pattern.sub(replacement, msg)
        record.msg = msg
        record.args = None  # message is already formatted: don't reformat it
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # on the handler, it also sees child loggers
logging.basicConfig(level=logging.INFO, handlers=[handler])

Dva detaily robia rozdiel. Nastavenie record.args na None je nevyhnutné: inak by sa už naformátovaná správa formátovala znova s jej argumentmi a akékoľvek % v URL by pokazilo zápis. A filter na handleri sa aplikuje na všetko, čo zapisuje, zatiaľ čo filter na loggeri ignoruje správy od jeho detských loggerov.

Bezpečnostné kontroly API

Každý computer_call nesie pole pending_safety_checks: zoznam bezpečnostných kontrol, ktoré API žiada vybaviť pred vykonaním akcií, každá s id, code a message. Oficiálny príklad OpenAI sa zastaví hneď, keď nie je prázdny. Ak tvoja aplikácia umožňuje človeku validovať tieto prípady, uznaj ich explicitne vrátením v acknowledged_safety_checks spolu s nasledujúcou snímkou obrazovky. Model nemôže udeliť toto schválenie v tvojom mene a uznanie prichádza pred vykonaním akcie, nikdy nie po.

def valider_verifications(appel) -> list[dict]:
    """Submit pending checks to an operator; refuse by default."""
    if not appel.pending_safety_checks:
        return []
    for verification in appel.pending_safety_checks:
        print(f"Vérification de sécurité [{verification.code}] : {verification.message}")
    if input("Autoriser ces actions ? [o/N] ").strip().lower() != "o":
        raise RuntimeError("Actions refusées par l'opérateur")
    return [
        {"id": v.id, "code": v.code, "message": v.message}
        for v in appel.pending_safety_checks
    ]


# In the loop, before executing actions:
acquittees = valider_verifications(appel)
executer_actions(page, appel.actions)
sortie = {
    "type": "computer_call_output",
    "call_id": appel.call_id,
    "output": {
        "type": "computer_screenshot",
        "image_url": f"data:image/png;base64,{capturer_ecran(page)}",
        "detail": "original",
    },
}
if acquittees:
    sortie["acknowledged_safety_checks"] = acquittees

Limity vykonávania

Existuje aj najčastejšie riziko: agent, ktorý sa vymkne kontrole bez toho, aby niečo pokazil, ale beží dve hodiny a spáli tvoj rozpočet. Trieda ExecutionLimits vynucuje tri stropy – počet krokov, trvanie a odhadované náklady – a vyhodí výnimku hneď, ako sa jeden dosiahne. Sadzby nie sú natvrdo zakódované: stiahni ich z modelu, ktorý používaš, zo stránky s cenami OpenAI, keďže sa líšia podľa modelu.

import time

class ExecutionLimits:
    """Enforce turn, duration, and cost ceilings on the agent."""

    def __init__(
        self,
        prix_entree_par_million: float,  # rates for the model in use
        prix_sortie_par_million: float,
        max_tours: int = 50,
        max_duree_s: int = 300,
        max_cout_usd: float = 5.0,
    ):
        self.prix_entree = prix_entree_par_million
        self.prix_sortie = prix_sortie_par_million
        self.max_tours = max_tours
        self.max_duree = max_duree_s
        self.max_cout = max_cout_usd
        self.debut = time.monotonic()
        self.tours = 0
        self.cout = 0.0

    def verifier(self):
        """Call before each request: raise an error if a ceiling is reached."""
        if self.tours >= self.max_tours:
            raise RuntimeError(f"Limite de tours atteinte ({self.max_tours})")
        if time.monotonic() - self.debut >= self.max_duree:
            raise RuntimeError(f"Durée maximale dépassée ({self.max_duree} s)")
        if self.cout >= self.max_cout:
            raise RuntimeError(f"Budget dépassé ({self.cout:.2f} $)")

    def compter(self, response):
        """Call after each response: accumulate turns and estimated cost."""
        self.tours += 1
        self.cout += response.usage.input_tokens / 1_000_000 * self.prix_entree
        self.cout += response.usage.output_tokens / 1_000_000 * self.prix_sortie

Toto je len odhad: nadhodnocuje vstupné tokeny obsluhované z cache promptu, ktoré sa fakturujú zníženou sadzbou, a ignoruje akékoľvek hostované prostredie, fakturované osobitne. Pravidelne to porovnávaj so skutočným využitím tvojho projektu. Nastav stropy pre každý workflow samostatne: 30-sekundový E2E test a hodinové zadávanie faktúr si nevyžadujú rovnaké prahy.

Kontrolný zoznam bezpečnosti pre produkciu

Pred nasadením agenta Computer Use do produkcie over:

  • Izolovaný prehliadač alebo pracovná plocha (kontajner alebo virtuálny stroj), neprivilegovaný používateľ
  • Odchádzajúca sieť obmedzená na stránky úlohy a na API, ak slučka beží v rovnakom prostredí
  • Filter URL, ktorý porovnáva schému, hostiteľa a port; service workery blokované
  • API kľúč mimo kódu a mimo dosahu prehliadača (env={})
  • Obsah obrazovky považovaný za nedôveryhodný: zastavenie a eskalácia pri prvom náznaku vstrekovania
  • Ľudské potvrdenie pred nákupmi, odoslaním, mazaním a zadávaním citlivých údajov
  • pending_safety_checks nikdy neuznané bez ľudskej validácie
  • Limity na počet krokov, trvanie a náklady
  • Filtrované logy, zachytenia neuchovávané (alebo šifrované)
  • Žiadne osobné súbory, poverenia ani Docker socket pripojené do prostredia
  • Výsledok overený v aplikácii pred oznámením úspechu
  • Mechanizmus núdzového zastavenia (kill switch)

Posledný bod je ten, na ktorý sa najčastejšie zabúda, no je jediný, ktorý pomôže, keď všetky ostatné zlyhali. Kill switch je spôsob, ako okamžite prerušiť agenta bez čakania, kým narazí na jeden zo svojich limitov: súbor STOP, ktorý slučka kontroluje v každej iterácii, docker stop na kontajnere, alebo vlajka čítaná zo zdieľanej premennej. Otestuj to pred produkciou, nie v deň, keď to budeš potrebovať.

Kľúčové poznatky

  • Štyri pravidlá OpenAI: obmedz prostredie, považuj obrazovku za nedôveryhodnú, potvrď vysoko rizikové akcie a ohranič a overuj vykonávanie
  • Žiadosť modelu o konanie nie je povolenie: tvoj kód vykonáva, pozastavuje alebo vracia kontrolu späť
  • Izoluj prehliadač (neprivilegovaný používateľ, seccomp profil) a povoľ odchádzajúcu premávku len na stránky úlohy
  • Filtruj URL porovnaním schémy, hostiteľa a portu – nikdy nie jednoduchou prefixovou alebo suffixovou zhodou reťazca
  • Uznávaj pending_safety_checks až po ľudskej validácii
  • Vynucuj limity na počet krokov, trvanie a náklady a overuj skutočný výsledok