Sigurnost i izolacija (sandboxing)
Na ovoj stranici
Lekcija prepisana 3. studenog 2026. na temelju OpenAI-jevog vodiča Computer use, njegovih recepata za integraciju Computer use te dokumentacije o mrežnom radu za Docker i Playwright. Dodaci: četiri sigurnosna pravila OpenAI-ja, razine potvrde i priznavanje
pending_safety_checks. Ispravci: prethodna verzija je prekinula mrežu za kontejner koji je morao zvati API, ostavila proxy bez izlaznog pristupa, prihvatilanotexample.comu filteru namijenjenom samo zaexample.com, pokvarila formatiranje zapisa i procijenila troškove koristeći jednu fiksnu stopu. Izvori: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.
Davanje kontrole AI-u: rizici
Computer Use daje AI modelu mogućnost djelovanja na računalu. To je moćno, ali može biti opasno. Pogrešno konfiguriran agent mogao bi navigirati na zlonamjerne stranice, izvršavati proizvoljni kod ili otkriti osjetljive podatke. Ovo nije teorija: posjećena stranica može sadržavati upute napisane za model, a ako ga okruženje ne ograniči, model će ih slijediti kao da su tvoj zahtjev. Sigurnost nije opcija – ona je temelj svake produkcijske implementacije.
Četiri pravila OpenAI-ja
OpenAI sažima sigurnost Computer Usea u četiri pravila. Primijeni ih u svojoj aplikaciji i u runtime okruženju, a ne samo u uputama modela:
- Ograniči okruženje. Koristi izolirani preglednik ili virtualno računalo, popis dopuštenih stranica i radnji te ograniči pristup onome što zadatak zahtijeva.
- Tretiraj sadržaj zaslona kao nepouzdan. Tekst sa stranice, dokumenta ili izlaz alata ne može odobriti dopuštenje niti zamijeniti korisničke upute. Ako stranica izgleda kao phishing ili injiciranje upita (prompt injection), agent staje i pita kako nastaviti.
- Potvrdi kritične radnje. Kupnje, prijenos podataka, destruktivne promjene i sve što je teško poništiti ostaju pod korisničkom kontrolom. Upisivanje osjetljivih informacija u obrazac već se računa kao prijenos.
- Ograniči i verificiraj izvršavanje. Postavi limite na broj poteza, trajanje ili trošak; omogući način za otkazivanje; i verificiraj stvarni ishod, a ne samo završnu poruku modela.
Polazište je jednostavno: zahtjev modela za djelovanje nije korisničko dopuštenje. Tvoj kod odlučuje hoće li izvršiti radnju, pauzirati radi odobrenja ili vratiti kontrolu. Za skupinu radnji, stani prije prve one koja zahtijeva potvrdu.
Tri razine potvrde
OpenAI razlikuje tri situacije, s primjerima koje možeš usvojiti u svojoj politici:
| Razina | Primjeri koje navodi OpenAI |
|---|---|
| Korisnik preuzima kontrolu | Završni korak promjene lozinke; zaobilaženje sigurnosne barijere, poput HTTPS upozorenja |
| Potvrda u trenutku radnje | Brisanje podataka, promjena dopuštenja ili postavki dijeljenja, rješavanje CAPTCHE, instalacija ili pokretanje preuzetog softvera, slanje ili objavljivanje u korisnikovo ime, financijske transakcije, postavke sustava |
| Prethodno odobrenje moguće u početnom zahtjevu | Prijava na stranicu koju je korisnik tražio posjetiti, slanje datoteka, premještanje ili preimenovanje datoteka, prijenos osjetljivih podataka čija je specifična uporaba odobrena |
Bez jasnog odobrenja u početnom zahtjevu, potvrdi neposredno prije radnje. Ne pitaj prerano: pusti agenta da nastavi sa svime što je sigurno, zatim stani na točki rizika i objasni radnju, rizik te kako će se podaci ili promjena primijeniti. Ako korisnik odbije, ništa se ne izvršava, a tvoj kod govori modelu što je uspjelo, a što nije.
Načelo najmanjih povlastica
Tvoj agent trebao bi imati pristup samo onome što je nužno za izvršenje zadatka. Kreni s izoliranim preglednikom – nikada s korisnikovim primarnim preglednikom koji drži otvorene sesije za e-poštu, bankarstvo i interne alate. Agentu također ne treba pristup datotečnom sustavu osim za namjensku mapu za preuzimanje, ne treba pristup internoj mreži osim ako to poslovna aplikacija zahtijeva, i ne bi trebao imati administratorska prava koja bi pogrešan klik mogla pretvoriti u incident na sustavu. Ne montiraj osobne datoteke, vjerodajnice ili Docker socket u njegovo okruženje. Naposljetku, učini sesiju prolaznom: briši podatke nakon svakog pokretanja kako radni tijek nikada ne bi slučajno ponovno upotrijebio kolačiće ili predmemoriju iz prethodnog.
Izolacija (Sandboxing) s Dockerom
Postavljaju se dva pitanja: gdje se preglednik pokreće, a gdje žive petlja i API ključ? OpenAI-jev Docker recept izolira radnu površinu u kontejneru bez mreže, kojim se upravlja s hosta putem docker exec: samo SDK na hostu čita ključ. Ovo je najstroža konfiguracija, ali funkcionira samo za zadatke kojima ne treba internet. Za druge zadatke, OpenAI zahtijeva okruženje čiji izlazni mrežni promet dopušta samo stranice zadatka.
Ako zadržiš Playwright i agent mora pregledavati, možeš staviti petlju i preglednik u isti kontejner, pod uvjetom da su ispunjena tri uvjeta: neprivilegirani korisnik, preglednik koji ne nasljeđuje varijable okruženja (kako ne bi dobio ključ) i izlazna mreža ograničena na stranice zadatka i API.
# Playwright slika za Python: preglednici i sistemske ovisnosti uključeni
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Playwright paket nije u slici: requirements.txt
# Fiksiraj playwright==1.64.1, istu verziju kao slika
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Neprivilegirani korisnik kojeg osigurava slika
USER pwuser
CMD ["python", "src/main.py"]
Playwright preporučuje fiksiranje verzije slike. Slika osigurava preglednike, a ne Python biblioteku: instaliraj istu verziju paketa playwright. Ne pokreći kontejner kao root, jer to onemogućuje Chromiumov sandbox. Za nepouzdane stranice, Playwright također preporučuje svoj seccomp profil, koji dodaje sistemske pozive potrebne ovom sandboxu Dockerovom zadanom profilu.
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 sprječava zombie procese, a --ipc=host, što preporučuje Playwright, sprječava da Chromium potroši dijeljenu memoriju i sruši se. Međutim, ta postavka dijeli IPC namespace hosta s kontejnerom. Ako to ne želiš otvoriti, umjesto toga povećaj dijeljenu memoriju s --shm-size, kao što OpenAI-jev recept čini za svoj kontejner, i testiraj na svojim najzahtjevnijim stranicama. Konačno, -e OPENAI_API_KEY bez vrijednosti nasljeđuje varijablu iz tvoje sesije: ključ se ne pojavljuje kao običan tekst u naredbenom retku.
Na strani Pythona, pokreni preglednik s mjerama opreza iz OpenAI-jevog recepta – sandbox uključen, prazno okruženje, proširenja i pristup datotečnom sustavu onemogućeni – i usmjeri ga kroz proxy iz sljedećeg odjeljka, baš kao i API klijent:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# API pozivi izlaze kroz filtrirajući proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # preglednik ne nasljeđuje varijable okruženja, dakle ni ključ
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # vidi filtriranje URL-ova u nastavku
)
page = context.new_page()
Ciljana mrežna ograničenja
Stavi kontejner agenta na internu Docker mrežu bez vanjskog pristupa. Squid proxy se spaja na tu mrežu i postaje njegov jedini izlaz; proxy je također spojen na regularnu mrežu. Sve što nije eksplicitno dopušteno ne postoji iz perspektive agenta.
# Interna mreža: nema izravnog vanjskog pristupa
docker network create --internal agent-net
# Izlazna mreža, rezervirana za proxy
docker network create sortie-proxy
# Squid proxy (slika koju održava Canonical) s tvojim popisom dopuštenih
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
# Proxy se spaja na internu mrežu: ovo je jedini izlaz za agenta
docker network connect agent-net agent-proxy
# squid.conf: dopusti samo domene zadatka i API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Ključna točka: proxy je spojen na obje mreže. Da si ga pokrenuo samo na internoj mreži, on sam ne bi imao izlazni pristup. api.openai.com je na popisu jer u ovoj postavci kod agenta zove API iznutra kontejnera. Pregledniku to ne treba: URL filter u sljedećem odjeljku blokira te pozive sa stranice.
Filtriranje URL-ova
Druga, finija barijera živi u samom pregledniku. Presretanjem zahtjeva s page.route, usporedi svaki URL s popisom dopuštenih specifičnih za zadatak – često kraćim od onog na proxyju – i prekini ostale, s čitljivim zapisom svakog blokiranja. Pazi na zamku usporedbe nizova na koju OpenAI upozorava: https://example.com.evil.test ne smije proći kao https://example.com, i obrnuto notexample.com završava s example.com. Usporedi shemu, točan host (ili poddomenu s točkom ispred) i port.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blokiraj zahtjeve prema neovlaštenim odredištima."""
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)
# Pregledniku trebaju samo stranice zadatka: API pozivi dolaze iz tvog Python koda, a ne sa stranice.
setup_url_filter(page, ["example.com"])
Ovaj sloj nadopunjuje proxy; ne zamjenjuje ga. Playwright napominje da page.route ne presreće zahtjeve kojima upravlja service worker, otuda service_workers="block" u kontekstu, a WebSocketi koriste drugačiji mehanizam (page.route_web_socket). Mrežno filtriranje ostaje tvoja primarna barijera.
Zaštita osjetljivih podataka
Maskiranje informacija na snimkama zaslona
Svaka snimka zaslona ide na API: sve što je vidljivo na zaslonu napušta tvoju infrastrukturu. OpenAI preporučuje držanje vjerodajnica izvan teksta i snimki stranice. Ako zaslon ipak sadrži osjetljive podatke, maskiraj ih prije slanja snimke modelu. Crni pravokutnik preko poznatih područja dovoljan je, pod uvjetom da znaš njihove koordinate – zato standardiziranje veličine viewporta, kako je ranije obrađeno u ovom tečaju, pomaže. Maskiranje ne mijenja veličinu slike: koordinate koje vrati model ostaju valjane.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskiraj osjetljiva područja u PNG snimci."""
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()
Znanje o tome što se događa sa snimkama
Odgovori Responses API-ja prema zadanim postavkama se pohranjuju: to omogućuje lančanje putem previous_response_id. S store: false, moraš sam ponovno poslati elemente iz prethodnih poteza. OpenAI također napominje da store: false ne eliminira sve oblike zadržavanja, a ulazne slike imaju vlastite iznimke: pročitaj njihove kontrole podataka prije slanja zaslona koji sadrže osobne podatke.
Nikada ne bilježi osjetljive podatke
Isto razmišljanje vrijedi za zapise (logove), koji često prežive mnogo dulje od snimki. Filter za bilježenje prepisuje rizične uzorke prije pisanja: dodjele lozinki, OpenAI API ključeve koji počinju s sk- i sekvence od 16 znamenki koje nalikuju brojevima kartica. Filter djeluje na konačnu poruku, pa hvata i ono što si zabilježio bez razmišljanja.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskiraj osjetljive podatke prije pisanja zapisa."""
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 # poruka je već formatirana: ne formatiraj je ponovno
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # na handleru, vidi i dječje logger-e
logging.basicConfig(level=logging.INFO, handlers=[handler])
Dva detalja čine razliku. Postavljanje record.args na None je ključno: inače bi se već formatirana poruka ponovno formatirala sa svojim argumentima, a svaki % u URL-u bi srušio pisanje. I filter na handleru primjenjuje se na sve što piše, dok filter na loggeru ignorira poruke od svojih dječjih loggera.
Sigurnosne provjere API-ja
Svaki computer_call nosi polje pending_safety_checks: popis sigurnosnih provjera koje API traži da riješiš prije izvršavanja radnji, svaka s id, code i message. Službeni primjer OpenAI-ja staje čim ono nije prazno. Ako tvoja aplikacija može imati čovjeka koji validira ove slučajeve, eksplicitno ih priznaj vraćanjem u acknowledged_safety_checks, zajedno sa sljedećom snimkom zaslona. Model ne može dati ovo odobrenje u tvoje ime, a priznanje dolazi prije izvršenja radnje, nikada poslije.
def valider_verifications(appel) -> list[dict]:
"""Podnesi čekajuće provjere operatoru; odbij prema zadanim postavkama."""
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
]
# U petlji, prije izvršavanja radnji:
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
Ograničenja izvršavanja
Postoji i najčešći rizik: agent koji izađe iz tračnica ništa ne slomeći, ali radi dva sata i sagorijeva tvoj budžet. Klasa ExecutionLimits nameće tri stropa – broj poteza, trajanje i procijenjeni trošak – i podiže iznimku čim se jedan dosegne. Stope nisu fiksne u kodu: povuci ih iz modela koji koristiš na OpenAI-jevoj stranici s cijenama, jer variraju ovisno o modelu.
import time
class ExecutionLimits:
"""Nameći stropove za poteze, trajanje i trošak na agentu."""
def __init__(
self,
prix_entree_par_million: float, # stope za model u uporabi
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):
"""Pozovi prije svakog zahtjeva: podigni grešku ako je strop dosegnut."""
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):
"""Pozovi nakon svakog odgovora: akumuliraj poteze i procijenjeni trošak."""
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
Ovo je samo procjena: precjenjuje ulazne tokene servirane iz predmemorije upita (prompt cache), koji se naplaćuju po smanjenoj stopi, i ignorira bilo koje hostano okruženje, koje se naplaćuje odvojeno. Redovito to uspoređuj sa stvarnom uporabom tvog projekta. Postavi stropove po radnom tijeku: 30-sekundni E2E test i unos računa koji traje sat vremena ne zahtijevaju iste pragove.
Kontrolni popis sigurnosti za produkciju
Prije deployanja Computer Use agenta u produkciju, provjeri:
- Izolirani preglednik ili radna površina (kontejner ili virtualno računalo), neprivilegirani korisnik
- Izlazna mreža ograničena na stranice zadatka i na API ako petlja radi u istom okruženju
- URL filter koji uspoređuje shemu, host i port; service workeri blokirani
- API ključ držan izvan koda i izvan dosega preglednika (
env={}) - Sadržaj zaslona tretiran kao nepouzdan: stani i eskaliraj pri prvom znaku injiciranja
- Ljudska potvrda prije kupnji, slanja, brisanja i unosa osjetljivih podataka
pending_safety_checksnikada priznati bez ljudske validacije- Limiti za poteze, trajanje i trošak
- Filtrirani zapisi, snimke se ne zadržavaju (ili su šifrirane)
- Nema osobnih datoteka, vjerodajnica ili Docker socketa montiranih u okruženje
- Rezultat verificiran u aplikaciji prije najave uspjeha
- Mehanizam za hitno zaustavljanje (kill switch)
Posljednja točka je ona koja se najčešće zaboravlja, a ipak je jedina koja pomaže kada sve ostale zakažu. Kill switch je način da se agent trenutno prekine, bez čekanja da udari u jedan od svojih limita: datoteka STOP koju petlja provjerava svaku iteraciju, docker stop na kontejneru ili zastavica koja se čita iz dijeljene varijable. Testiraj ga prije produkcije, a ne onog dana kada ti zatreba.
Ključne točke
- Četiri pravila OpenAI-ja: ograniči okruženje, tretiraj zaslon kao nepouzdan, potvrdi kritične radnje te ograniči i verificiraj izvršavanje
- Zahtjev modela za djelovanje nije dopuštenje: tvoj kod izvršava, suspendira ili vraća kontrolu
- Izoliraj preglednik (neprivilegirani korisnik, seccomp profil) i dopusti izlazni promet samo na stranice zadatka
- Filtriraj URL-ove usporedbom sheme, hosta i porta – nikada jednostavnim prefiksom ili sufiksom niza
- Priznaj
pending_safety_checkssamo nakon ljudske validacije - Nameći limite za poteze, trajanje i trošak te verificiraj stvarni ishod