Varnost in pesčenje
Na tej strani
Lekcija prepisana 3. novembra 2026 na podlagi vodnika Computer use podjetja OpenAI, njegovih receptov za integracijo Computer use ter dokumentacije o mreženju za Docker in Playwright. Dodatki: štiri varnostna pravila OpenAI, ravni potrditve in priznavanje
pending_safety_checks. Popravki: prejšnja različica je prekinila omrežje za vsebnik, ki je moral klicati API, pustila proxy brez odhodnega dostopa, sprejelanotexample.comv filtru, namenjenem samo zaexample.com, pokvarila oblikovanje dnevnikov in ocenjevala stroške z uporabo ene same vgrajene stopnje. Viri: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.
Dajanje nadzora umetni inteligenci: tveganja
Computer Use omogoča modelu umetne inteligence delovanje na računalniku. To je zmogljivo, a lahko nevarno. Napačno konfiguriran agent bi lahko obiskal zlonamerne strani, izvajal poljubno kodo ali razkril občutljive podatke. To ni teoretično: obiskana stran lahko vsebuje navodila, napisana za model, in če ga okolje ne omejuje, jih bo model upošteval, kot da so tvoja zahteva. Varnost ni izbira – je temelj vsakega produkcijskega uvajanja.
Štiri pravila OpenAI
OpenAI povzema varnost Computer Use v štirih pravilih. Uporabi jih v svoji aplikaciji in v izvajalnem okolju, ne le v navodilih modela:
- Omeji okolje. Uporabi izoliran brskalnik ali navidezni stroj, seznam dovoljenih strani in dejanj ter omeji dostop le na tisto, kar naloga zahteva.
- Vsebino zaslona obravnavaj kot nezaupljivo. Besedilo s strani, dokumenta ali izhod orodja ne more podeliti dovoljenja ali nadomestiti uporabnikovih navodil. Če stran izgleda kot ribarjenje (phishing) ali vbrizganje poziva (prompt injection), agent ustavi delovanje in vpraša, kako nadaljevati.
- Potrdi dejanja z visokimi vlogami. Nakupi, prenos podatkov, destruktivne spremembe in vse, kar je težko razveljaviti, ostanejo pod uporabnikovim nadzorom. Vnos občutljivih informacij v obrazec že šteje kot prenos.
- Omeji in preveri izvajanje. Nastavi omejitve za število korakov, trajanje ali stroške; zagotovi možnost preklica; in preveri dejanski izid, ne le končnega sporočila modela.
Izhodišče je preprosto: zahteva modela za delovanje ni uporabniško dovoljenje. Tvoja koda odloči, ali naj se dejanje izvrši, začasno ustavi za odobritev ali vrne nadzor nazaj. Pri nizu dejanj se ustavi pred prvim, ki zahteva potrditev.
Tri ravni potrditve
OpenAI razlikuje tri situacije s primeri, ki jih lahko vključiš v svojo politiko:
| Raven | Primeri, ki jih navaja OpenAI |
|---|---|
| Uporabnik prevzame nadzor | Zadnji korak spremembe gesla; obhod varnostne pregrade, kot je opozorilo HTTPS |
| Potrditev v trenutku dejanja | Brisanje podatkov, spreminjanje dovoljenj ali nastavitev skupne rabe, reševanje CAPTCHA, namestitev ali zagon prenesene programske opreme, pošiljanje ali objavljanje v imenu uporabnika, finančne transakcije, sistemske nastavitve |
| Predhodna odobritev mogoča v začetni zahtevi | Prijava na stran, ki jo je uporabnik zahteval obiskati, pošiljanje datotek, premikanje ali preimenovanje datotek, prenos občutljivih podatkov, katerih specifična uporaba je bila odobrena |
Brez jasne odobritve v začetni zahtevi potrdi tik pred dejanjem. Ne vprašaj prezgodaj: pusti agentu, da nadaljuje z vsem, kar je varno, nato se ustavi na točki tveganja in pojasni dejanje, tveganje ter kako bodo podatki ali sprememba uporabljeni. Če uporabnik zavrne, se nič ne izvrši, tvoja koda pa modelu sporoči, kaj je uspelo in kaj ne.
Načelo najmanjših privilegijev
Tvoj agent bi moral imeti dostop le do absolutnega minimuma, potrebnega za dokončanje naloge. Začni z izoliranim brskalnikom – nikoli z uporabnikovim glavnim brskalnikom, ki hrani odprte seje za e-pošto, bančništvo in interna orodja. Agent tudi ne potrebuje dostopa do datotečnega sistema, razen do namenske mape za prenose, ne potrebuje dostopa do notranjega omrežja, razen če to zahteva poslovna aplikacija, in ne sme imeti skrbniških pravic, ki bi lahko iz napačnega klika naredile sistemski incident. Ne priklop osebnih datotek, poverilnic ali vtičnice Docker v njegovo okolje. Nazadnje, naj bo seja efemerna: izbriši podatke po vsakem zagonu, da delovni tok nikoli pomotoma ne ponovno uporabi piškotkov ali predpomnilnika iz prejšnjega zagona.
Pesčenje z Dockerjem
Pojavita se dve vprašanji: kje se izvaja brskalnik in kje sta zanka ter ključ API? Recept Docker podjetja OpenAI izolira namizje v vsebniku brez omrežja, ki ga gostitelj nadzira prek docker exec: le SDK na gostitelju bere ključ. To je najstrožja konfiguracija, vendar deluje le za naloge, ki ne potrebujejo interneta. Za druge naloge OpenAI zahteva okolje, katerega odhodno omrežje dovoljuje le strani za nalogo.
Če obdržiš Playwright in mora agent brskati, lahko postaviš zanko in brskalnik v isti vsebnik, pod pogojem treh pogojev: neprivilegiran uporabnik, brskalnik, ki ne podeduje spremenljivk okolja (torej ne dobi ključa), in odhodno omrežje, omejeno na strani za nalogo in API.
# Slika Playwright za Python: brskalniki in sistemske odvisnosti vključeni
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Paket playwright ni v sliki: requirements.txt
# Pripni playwright==1.64.1, enako različico kot slika
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Neprivilegiran uporabnik, ki ga zagotavlja slika
USER pwuser
CMD ["python", "src/main.py"]
Playwright priporoča pripnanje različice slike. Slika zagotavlja brskalnike, ne knjižnice Python: namesti enako različico paketa playwright. Ne zaganjaj vsebnika kot root, kar onemogoči peskovnik Chromium. Za nezaupljive strani Playwright priporoča tudi svoj profil seccomp, ki privzetemu profilu Dockerja doda sistemske klice, potrebne za ta peskovnik.
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 preprečuje procese zombije, --ipc=host, ki ga priporoča Playwright, pa preprečuje, da bi Chromium porabil vso skupno pomnilniško prostor in se zrušil. Vendar ta nastavitev deli imenski prostor IPC gostitelja z vsebnikom. Če tega ne želiš odpreti, namesto tega povečaj skupni pomnilnik z --shm-size, kot to počne recept OpenAI za svoj vsebnik, in testiraj na svojih najzahtevnejših straneh. Končno, -e OPENAI_API_KEY brez vrednosti podeduje spremenljivko iz tvoje seje: ključ se ne pojavi v navadni obliki na ukazni vrstici.
Na strani Python zaženi brskalnik s previdnostnimi ukrepi iz recepta OpenAI – omogočen peskovnik, prazno okolje, onemogočene razširitve in dostop do datotečnega sistema – ter ga usmeri prek proxyja iz naslednjega razdelka, tako kot odjemalca API:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# Klici API gredo ven skozi filtrirni proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # brskalnik ne podeduje spremenljivk okolja, torej ne ključa
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # glej filtriranje URL spodaj
)
page = context.new_page()
Ciljno omejevanje omrežja
Postavi vsebnik agenta v notranje omrežje Docker brez zunanjega dostopa. Proxy Squid se pridruži temu omrežju in postane njegov edini izhod; proxy je povezan tudi z običajnim omrežjem. Vse, kar ni izrecno dovoljeno, z vidika agenta ne obstaja.
# Notranje omrežje: brez neposrednega zunanjega dostopa
docker network create --internal agent-net
# Odhodno omrežje, rezervirano za proxy
docker network create sortie-proxy
# Proxy Squid (slika, ki jo vzdržuje Canonical) s tvojim seznamom dovoljenih
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 pridruži notranjemu omrežju: to je edini izhod za agenta
docker network connect agent-net agent-proxy
# squid.conf: dovoli le domene za nalogo in 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 povezan z obema omrežjema. Če bi ga zagnal le v notranjem omrežju, sam ne bi imel odhodnega dostopa. api.openai.com je na seznamu, ker v tej nastavitvi koda agenta kliče API iznoter vsebnika. Brskalnik ga ne potrebuje: filter URL v naslednjem razdelku blokira te klice s strani.
Filtriranje URL-jev
Druga, natančnejša pregrada živi v samem brskalniku. S prestrezanjem zahtev z page.route primerjaj vsak URL s seznamom dovoljenih domen, specifičnim za nalogo – ki je pogosto krajši od proxyjevega – in preostale prekini z berljivim dnevnikom vsakega bloka. Pozor na past primerjave nizov, na katero opozarja OpenAI: https://example.com.evil.test ne sme iti skozi kot https://example.com, in obratno notexample.com se konča z example.com. Primerjaj shemo, točen gostitelj (ali poddomeno s piko na začetku) in vrata.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blokiraj zahteve na nepooblaščena ciljna mesta."""
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)
# Brskalnik potrebuje le strani za nalogo: klici API prihajajo iz tvoje kode Python, ne s strani.
setup_url_filter(page, ["example.com"])
Ta plast dopolnjuje proxy; ne nadomešča ga. Playwright ugotavlja, da page.route ne prestreže zahtev, ki jih obravnava delavec storitve (service worker), zato service_workers="block" v kontekstu, in WebSockets uporabljajo drugačen mehanizem (page.route_web_socket). Filtriranje omrežja ostaja tvoja primarna pregrada.
Varovanje občutljivih podatkov
Maskiranje informacij na posnetkih zaslona
Vsak posnetek zaslona gre v API: vse, kar je vidno na zaslonu, zapusti tvojo infrastrukturo. OpenAI priporoča, da poverilnic ne vključuješ v besedilo strani in zajeme. Če zaslon vsebuje občutljive podatke, jih zamaskiraj, preden pošlješ zajem modelu. Črn pravokotnik čez znana območja zadostuje, pod pogojem, da poznaš njihove koordinate – zato standardizacija velikosti vidnega polja, kot je obravnavano prej v tem tečaju, pomaga. Maskiranje ne spremeni velikosti slike: koordinate, ki jih vrne model, ostanejo veljavne.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskiraj občutljiva območja na posnetku PNG."""
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()
Poznavanje usode zajemov
Odgovori API Responses so privzeto shranjeni: to omogoča veriženje prek previous_response_id. Z store: false moraš sam znova poslati elemente iz prejšnjih korakov. OpenAI tudi ugotavlja, da store: false ne odpravi vseh oblik hrambe, vhodne slike pa imajo svoje izjeme: pred pošiljanjem zaslonov, ki vsebujejo osebne podatke, preberi njihove kontrole podatkov.
Nikoli ne beleži občutljivih podatkov
Enako razmišljanje velja za dnevnike, ki pogosto preživijo veliko dlje kot zajemi. Filter za beleženje prepíše tvegane vzorce pred zapisovanjem: dodelitve gesel, ključe API OpenAI, ki se začnejo s sk-, in 16-mestna zaporedja, ki spominjajo na številke kartic. Filter deluje na končnem sporočilu, zato ujame tudi tisto, kar si zabeležil brez razmisleka.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskiraj občutljive podatke pred zapisovanjem dnevnikov."""
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 # sporočilo je že oblikovano: ne oblikuj ga znova
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # na rokovalcu vidi tudi podrejene beležilnike
logging.basicConfig(level=logging.INFO, handlers=[handler])
Dve podrobnosti naredita razliko. Nastavitev record.args na None je bistvena: sicer bi bilo že oblikovano sporočilo znova oblikovano z njegovimi argumenti in vsak % v URL-ju bi pokvaril zapis. In filter na rokovalcu velja za vse, kar zapiše, medtem ko filter na beležilniku ignorira sporočila od njegovih podrejenih beležilnikov.
Varnostni preverki API-ja
Vsak computer_call nosi polje pending_safety_checks: seznam varnostnih preverkov, ki jih API zahteva, da jih obravnavaš pred izvršitvijo dejanj, vsak z id, code in message. Uradni primer OpenAI se ustavi takoj, ko ni prazen. Če tvoja aplikacija omogoča, da človek potrdi te primere, jih izrecno priznaj z vrnitvijo v acknowledged_safety_checks, skupaj z naslednjim posnetkom zaslona. Model tega odobrenja ne more podeliti v tvojem imenu, priznanje pa pride pred izvršitvijo dejanja, nikoli po njem.
def valider_verifications(appel) -> list[dict]:
"""Predloži čakajoče preverke operaterju; privzeto zavrnitev."""
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
]
# V zanki, pred izvršitvijo dejanj:
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
Omejitve izvajanja
Obstaja tudi najpogostejše tveganje: agent, ki uide iz tira, ne da bi kaj pokvaril, a teče dve uri in požge tvoj proračun. Razred ExecutionLimits uveljavlja tri stropove – število korakov, trajanje in ocenjeni strošek – in sproži izjemo, takoj ko je eden dosežen. Stopnje niso vgrajene: pridobi jih iz modela, ki ga uporabljaš, na strani s cenami podjetja OpenAI, saj se razlikujejo glede na model.
import time
class ExecutionLimits:
"""Uveljavi strope za število korakov, trajanje in strošek na agentu."""
def __init__(
self,
prix_entree_par_million: float, # stopnje za uporabljeni model
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):
"""Pokliči pred vsako zahtevo: sproži napako, če je dosežen strop."""
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):
"""Pokliči po vsakem odgovoru: seštej korake in ocenjeni strošek."""
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
To je le ocena: precenjuje vhodne žetone, servirane iz predpomnilnika pozivov, ki se zaračunavajo po znižani stopnji, in ignorira morebitno gostovano okolje, ki se zaračunava ločeno. Redno jo primerjaj z dejansko uporabo tvojega projekta. Nastavi strope na delovni tok: 30-sekundni test E2E in urni vnos računov ne zahtevata istih pragov.
Kontrolni seznam varnosti za produkcijo
Pred uvajanjem agenta Computer Use v produkcijo preveri:
- Izoliran brskalnik ali namizje (vsebnik ali navidezni stroj), neprivilegiran uporabnik
- Odhodno omrežje omejeno na strani za nalogo in na API, če zanka teče v istem okolju
- Filter URL, ki primerja shemo, gostitelja in vrata; delavci storitev blokirani
- Ključ API kept izven kode in izven dosega brskalnika (
env={}) - Vsebina zaslona obravnavana kot nezaupljiva: ustavi in eskaliraj ob prvem znaku vbrizganja
- Človeška potrditev pred nakupi, pošiljanjem, brisanjem in vnosom občutljivih podatkov
pending_safety_checksnikoli priznani brez človeške validacije- Omejitve za število korakov, trajanje in stroške
- Filtrirani dnevniki, zajemi niso shranjeni (ali so šifrirani)
- Brez osebnih datotek, poverilnic ali vtičnice Docker, priklopljenih v okolje
- Rezultat preverjen v aplikaciji pred razglasitvijo uspeha
- Mehanizem za nujni zaustav (kill switch)
Zadnja točka je tista, ki jo najpogosteje pozabimo, vendar je edina, ki pomaga, ko vse druge odpovedo. Kill switch je način za takojšnjo prekinitev agenta, brez čakanja, da doseže eno od svojih omejitev: datoteka STOP, ki jo zanka preveri pri vsaki iteraciji, docker stop na vsebniku ali zastavica, prebrana iz skupne spremenljivke. Testiraj ga pred produkcijo, ne na dan, ko ga potrebuješ.
Ključne ugotovitve
- Štiri pravila OpenAI: omeji okolje, obravnavaj zaslon kot nezaupljiv, potrdi dejanja z visokimi vlogami ter omeji in preveri izvajanje
- Zahteva modela za delovanje ni dovoljenje: tvoja koda izvrši, začasno ustavi ali vrne nadzor nazaj
- Izoliraj brskalnik (neprivilegiran uporabnik, profil seccomp) in dovoli odhodni promet le na strani za nalogo
- Filtriraj URL-je s primerjavo sheme, gostitelja in vrat – nikoli s preprostim predpono ali pripono niza
- Priznaj
pending_safety_checksšele po človeški validaciji - Uveljavi omejitve za število korakov, trajanje in stroške ter preveri dejanski izid