Turvalisus ja liivakastistamine
Sellel lehel
Õppetund kirjutati ümber 3. novembril 2026, tuginedes OpenAI Computer use juhendile, selle *Computer use integration recipes’*ile ning Dockeri ja Playwrighti võrgunduse dokumentatsioonile. Lisatud: OpenAI neli turvareeglit, kinnitustasemed ja
pending_safety_checkstunnustamine. Parandatud: eelmises versioonis katkestati võrk konteinerilt, mis pidi API-t kutsuma, jäeti proksi ilma väljuva ühenduseta, aktsepteeriti filtrisnotexample.com, kuigi lubatud oli ainultexample.com, rikuti logide vormingut ja hinnati kulusid ühe fikseeritud määra alusel. Allikad: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.
Tehisintellekti kontrolli andmine: riskid
Computer Use annab tehisintellekti mudelile võime tegutseda arvutis. See on võimas, kuid võib olla ohtlik. Valesti seadistatud agent võib navigeerida pahatahtlikele saitidele, käivitada suvalist koodi või paljastada tundlikke andmeid. See pole teoreetiline: külastatud leht võib sisaldada mudelile kirjutatud juhiseid ja kui keskkond seda ei piira, järgib mudel neid nii, nagu oleksid need sinu taotlus. Turvalisus pole valikuline – see on iga tootmisse viidud lahenduse alustala.
OpenAI neli reeglit
OpenAI võtab Computer Use’i turvalisuse kokku nelja reegliga. Rakenda neid nii oma rakenduses kui ka käituskeskkonnas, mitte ainult mudeli juhistes:
- Piira keskkonda. Kasuta isoleeritud brauserit või virtuaalmasinat, lubatud saitide ja toimingute nimekirja ning piira juurdepääsu ainult sellele, mida ülesanne nõuab.
- Käsitle ekraanisisu usaldamatusena. Leheküljelt, dokumendist või tööriista väljundist pärit tekst ei saa anda luba ega asendada kasutaja juhiseid. Kui leht näib välja nagu фишинг või sisendi süstimine (prompt injection), peatab agent tegevuse ja küsib, kuidas edasi toimida.
- Kinnita kõrge riskiga toimingud. Ostud, andmeedastus, destruktiivsed muudatused ja kõik, mida on raske tagasi pöörata, jäävad kasutaja kontrolli alla. Tundliku teabe sisestamine vormi loetakse juba edastamiseks.
- Piira ja kontrolli täitmist. Määra piirangud pöörete arvule, kestusele või kulule; võimalda tühistamine; ja kontrolli tegelikku tulemust, mitte ainult mudeli lõppsõnumit.
Lähtepunkt on lihtne: mudeli taotlus tegutseda ei ole kasutaja luba. Sinu kood otsustab, kas käivitada tegevus, oodata kinnitust või anda kontroll tagasi. Mitme toimingu jada puhul peatu enne esimest, mis nõuab kinnitust.
Kolm kinnitustaset
OpenAI eristab kolme olukorda, mille näiteid saad oma poliitikas kasutada:
| Tase | OpenAI poolt toodud näited |
|---|---|
| Kasutaja võtab kontrolli üle | Parooli muutmise viimane samm; turvatõkke ületamine, näiteks HTTPS-hoiatus |
| Kinnita toimingu hetkel | Andmete kustutamine, õiguste või jagamisseadete muutmine, CAPTCHA lahendamine, allalaaditud tarkvara installimine või käivitamine, saatmine või avaldamine kasutaja nimel, finantstehingud, süsteemi seaded |
| Eelkinnitus on võimalik algtaotluses | Sisselogimine saidile, mida kasutaja palus külastada, failide saatmine, failide liigutamine või ümbernimetamine, tundlike andmete edastamine, mille konkreetne kasutusviis oli heaks kiidetud |
Ilma selge kinnituseta algtaotluses kinnita vahetult enne toimingu sooritamist. Ära küsi liiga vara: lase agendil tegutseda kõiges, mis on ohutu, peatu siis riskikohas ja selgita toimingut, riski ning seda, kuidas andmeid või muudatust rakendatakse. Kui kasutaja keeldub, ei toimu midagi ja sinu kood teatab mudelile, mis õnnestus ja mis ebaõnnestus.
Vähimate õiguste printsiip
Sinu agendil peaks olema juurdepääs ainult miinimumile, mis on ülesande täitmiseks vajalik. Alusta isoleeritud brauserist – mitte kunagi kasutaja peamisest brauserist, kus on avatud sessioonid e-posti, panganduse ja siseste tööriistade jaoks. Agendil pole vaja failisüsteemi juurdepääsu, välja arvatud spetsiaalne allalaadimiskaust; tal pole vaja sisese võrgu juurdepääsu, välja arvatud juhul, kui äpirakendus seda nõuab; ja tal ei tohiks olla administraatori õigusi, mis võiksid muuta valeklõpsu süsteemi intsidentiks. Ära haagi oma keskkonda isiklikke faile, mandaate ega Dockeri soklit. Lõpuks tee sessioon lühiajaliseks: kustuta andmed pärast iga käivitamist, et töövoog ei kasutaks kogemata eelmise sessiooni küpsiseid või vahemälu.
Liivakastistamine Dockeriga
Tekib kaks küsimust: kus brauser töötab ja kus elavad tsükkel ning API võti? OpenAI Dockeri retsept isoleerib töölaua võrguta konteineris, mida host juhib käsuga docker exec: ainult SDK hostil loeb võtit. See on kõige rangem konfiguratsioon, kuid toimib ainult ülesannete puhul, mis ei vaja internetti. Muude ülesannete jaoks nõuab OpenAI keskkonda, mille väljuv võrk lubab ainult ülesandega seotud saite.
Kui hoiad Playwrighti ja agent peab sirvima, võid paigutada tsükli ja brauseri samasse konteinerisse, kui on täidetud kolm tingimust: mitte-privilegeeritud kasutaja, brauser, mis ei päri keskkonnamuutujaid (nii et see ei saa võtit), ja väljuv võrk, mis on piiratud ülesande saitide ja API-ga.
# Playwrighti pilt Pythonile: brauserid ja süsteemi sõltuvused kaasas
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# playwright paketti pildil pole: requirements.txt
# Fikseeri playwright==1.64.1, sama versioon mis pildil
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Pildi poolt pakutud mitte-privilegeeritud kasutaja
USER pwuser
CMD ["python", "src/main.py"]
Playwright soovitab fikseerida pildi versiooni. Pilt pakub brausereid, mitte Pythoni teeki: installi playwright paketi sama versioon. Ära käivita konteinerit root-kasutajana, mis lülitaks Chromiumi liivakasti välja. Usaldamatute saitide jaoks soovitab Playwright ka oma seccomp profiili, mis lisab Dockeri vaikimisi profiilile need süsteemikutsed, mida see liivakast vajab.
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 hoiab ära zombiprotsessid ja --ipc=host, mida Playwright soovitab, hoiab ära Chromiumi jagatud mälu otsa saamise ja kokkujooksmise. See säte jagab aga hosti IPC nimeruumi konteineriga. Kui sa ei soovi seda avada, suurenda jagatud mälu asemel --shm-size abil, nagu OpenAI teeb oma retseptis oma konteineri jaoks, ja testi oma kõige raskematel lehtedel. Lõpuks pärib -e OPENAI_API_KEY ilma väärtuseta muutuja sinu sessioonist: võti ei ilmu käsureale selges tekstis.
Pythoni poolel käivita brauser OpenAI retsepti ettevaatusabinõudega – liivakast lubatud, tühi keskkond, laiendused ja failisüsteemi juurdepääs keelatud – ja suuna see läbi järgmises osas kirjeldatud proksi, täpselt nagu API klient:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# API kõned väljuvad läbi filtreeriva proksi
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # brauser ei päri keskkonnamuutujaid, seega mitte võtit
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # vt URL-i filtreerimist allpool
)
page = context.new_page()
Sihtotstarbelised võrgupiirangud
Paiguta agendi konteiner sisemisse Dockeri võrku, millel puudub väline juurdepääs. Squid proksi liitub selle võrguga ja saab selle ainsaks väljapääsuks; proksi on ühendatud ka tavalise võrguga. Kõik, mida pole sõnaselgelt lubatud, agendi seisukohalt ei eksisteeri.
# Sisemine võrk: otsest välist juurdepääsu pole
docker network create --internal agent-net
# Väljuv võrk, reserveeritud proksile
docker network create sortie-proxy
# Squid proksi (Canonicale'i hallatav pilt) koos sinu lubatud nimekirjaga
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
# Proksi liitub sisemise võrguga: see on agendi ainus väljapääs
docker network connect agent-net agent-proxy
# squid.conf: luba ainult ülesande domeenid ja API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Põhipunkt: proksi on ühendatud mõlema võrguga. Kui käivitaksid selle ainult sisemises võrgus, poleks sellel endal väljuvat juurdepääsu. api.openai.com on nimekirjas, sest selles seadistuses kutsub agendi kood API-t konteineri seest. Brauser seda ei vaja: järgmises osas kirjeldatud URL-i filter blokeerib need kõned leheküljelt.
URL-i filtreerimine
Teine, peenem tõke asub brauseris endas. Peatades päringud page.route abil, võrdle iga URL-i ülesandepõhise lubatud nimekirjaga – mis on sageli lühem kui proksi oma – ja katkesta ülejäänud, logides iga blokeerimise loetavalt. Hoia end OpenAI hoiatatud stringivõrdluse lõksu eest: https://example.com.evil.test ei tohi läbida kui https://example.com ja vastupidi, notexample.com lõpeb example.com-iga. Võrdle skeemi, täpset hosti (või punktiga eesliidetud alamdomeeni) ja porti.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blokeeri päringud volitamata sihtkohtadesse."""
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)
# Brauser vajab ainult ülesande saite: API kõned tulevad sinu Pythoni koodist, mitte leheküljelt.
setup_url_filter(page, ["example.com"])
See kiht täiendab proksit; see ei asenda seda. Playwright märgib, et page.route ei peata teenusetöötaja (service worker) hallatavaid päringuid, seega kontekstis service_workers="block", ja WebSocketid kasutavad erinevat mehhanismi (page.route_web_socket). Võrgufiltreerimine jääb sinu peamiseks tõkkeks.
Tundlike andmete kaitsmine
Teabe maskeerimine ekraanitõmmistel
Iga ekraanitõmmis läheb API-le: kõik, mis on ekraanil nähtav, lahkub sinu taristust. OpenAI soovitab hoida mandaadid lehe tekstist ja jäädvustustest eemal. Kui ekraan sisaldab siiski tundlikke andmeid, maskeeri need enne jäädvustuse mudelile saatmist. Must ristkülik teadaolevate alade kohal on piisav, eeldusel et tead nende koordinaate – mistõttu vaateakna suuruse standardiseerimine, mida selles kursuses varem käsitleti, aitab. Maskeerimine ei muuda pildi suurust: mudeli tagastatud koordinaadid jäävad kehtivaks.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskeeri tundlikud alad PNG-jäädvustusel."""
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()
Teadmine, mis jäädvustustega juhtub
Responses API vastused salvestatakse vaikimisi: see võimaldab aheldamist previous_response_id kaudu. Kui store: false, pead eelmiste pöörete elemendid ise uuesti saatma. OpenAI märgib ka, et store: false ei kõrvalda kõiki säilitamise vorme ja sisendpiltidel on oma erandid: loe selle andmekontrolli enne isikuandmeid sisaldavate ekraanide saatmist.
Ära kunagi logi tundlikke andmeid
Sama arutluskäik kehtib logide kohta, mis sageli säilivad palju kauem kui jäädvustused. Logifilter kirjutab riskantsed mustrid enne kirjutamist ümber: parooli määramised, OpenAI API võtmed, mis algavad sk--ga, ja 16-kohalised jadad, mis meenutavad kaardinumbreid. Filter toimib lõppsõnumil, nii et see püüab kinni ka selle, mida logisid mõtlemata.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskeeri tundlikud andmed enne logide kirjutamist."""
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 # sõnum on juba vormindatud: ära vorminda seda uuesti
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # handleril, näeb ka alamlogijaid
logging.basicConfig(level=logging.INFO, handlers=[handler])
Kaks detaili teevad vahet. record.args määramine väärtuseks None on hädavajalik: vastasel juhul vormindataks juba vormindatud sõnum uuesti oma argumentidega ja iga % URL-is rikuks kirjutamise. Ja handleril olev filter kehtib kõigele, mida see kirjutab, samas kui logijal olev filter ignoreerib sõnumeid oma alamlogijatelt.
API turvakontrollid
Iga computer_call kannab välja pending_safety_checks välja: nimekirja turvakontrollidest, mida API palub sul enne toimingute sooritamist käsitleda, ühel id, code ja message. OpenAI ametlik näide peatub kohe, kui see pole tühi. Kui sinu rakendus võimaldab inimesel neid juhtumeid valideerida, tunnusta neid sõnaselgelt, tagastades need acknowledged_safety_checks koos järgmise ekraanitõmmisega. Mudel ei saa seda kinnitust sinu nimel anda ja tunnustamine toimub enne toimingu täitmist, mitte pärast.
def valider_verifications(appel) -> list[dict]:
"""Esita ootel kontrollid operaatorile; keeldu vaikimisi."""
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
]
# Tsüklis, enne toimingute täitmist:
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
Täitmise piirangud
Samuti on olemas kõige levinum risk: agent, mis läheb kontrolli alt välja, midagi katki tegemata, kuid töötab kaks tundi ja põletab sinu eelarve. ExecutionLimits klass jõustab kolm lagi – pöörete arv, kestus ja hinnanguline kulu – ja tõstab erandi niipea, kui üks neist saavutatakse. Määrasid ei fikseerita koodi: too need kasutatavalt mudelilt OpenAI hinnalehelt, kuna need varieeruvad mudeli lõikes.
import time
class ExecutionLimits:
"""Jõusta agendi pöörete, kestuse ja kulu laed."""
def __init__(
self,
prix_entree_par_million: float, # kasutatava mudeli määrad
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):
"""Kutsu enne iga päringut: tõsta viga, kui lagi on saavutatud."""
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):
"""Kutsu pärast iga vastust: kogune pööreid ja hinnangulist kulu."""
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
See on ainult hinnang: see ülehindab prompti vahemälust serveeritud sisendtokeneid, mida arveldatakse vähendatud määraga, ja ignoreerib majutatud keskkonda, mida arveldatakse eraldi. Võrdle seda regulaarselt oma projekti tegeliku kasutusega. Määra laed töövoogu kohta: 30-sekundiline E2E-test ja tunniajaline arve sisestamine ei vaja samu lävendeid.
Tootmise turvalisuse kontrollnimekiri
Enne Computer Use agendi tootmisse viimist kontrolli:
- Isoleeritud brauser või töölaud (konteiner või virtuaalmasin), mitte-privilegeeritud kasutaja
- Väljuv võrk piiratud ülesande saitidega ja API-ga, kui tsükkel töötab samas keskkonnas
- URL-i filter, mis võrdleb skeemi, hosti ja porti; teenusetöötajad blokeeritud
- API võti hoitud koodist ja brauseri ulatusest eemal (
env={}) - Ekraanisisu käsitletud usaldamatusena: peatu ja eskaleeri esimesel sisendi süstimise märgil
- Inimese kinnitus enne oste, saatmisi, kustutamisi ja tundlike andmete sisestamist
pending_safety_checksmitte kunagi tunnustatud ilma inimese valideerimiseta- Pöörete, kestuse ja kulu piirangud
- Filtreeritud logid, jäädvustusi ei säilitata (või krüptitakse)
- Keskkonda pole haagitud isiklikke faile, mandaate ega Dockeri soklit
- Tulemus kontrollitud rakenduses enne edu teatamist
- Hädaolukorra peatamismehhanism (kill switch)
Viimane punkt on see, mida kõige sagedamini unustatakse, ometi on see ainus, mis aitab, kui kõik teised on ebaõnnestunud. Kill switch on viis agendi viivitamatult katkestada, ootamata, kuni see jõuab ühe oma piiranguteni: STOP fail, mida tsükkel igal iteratsioonil kontrollib, docker stop konteineril või lipu lugemine jagatud muutujast. Testi seda enne tootmist, mitte päeval, kui seda vajad.
Peamised punktid
- OpenAI neli reeglit: piira keskkonda, käsitle ekraani usaldamatusena, kinnita kõrge riskiga toimingud ning piira ja kontrolli täitmist
- Mudeli taotlus tegutseda ei ole luba: sinu kood käivitab, peatab või annab kontrolli tagasi
- Isoleeri brauser (mitte-privilegeeritud kasutaja, seccomp profiil) ja luba väljuv liiklus ainult ülesande saitidele
- Filtreeri URL-e, võrreldes skeemi, hosti ja porti – mitte kunagi lihtsa stringi prefiksi või sufiksi abil
- Tunnusta
pending_safety_checksalles pärast inimese valideerimist - Jõusta pöörete, kestuse ja kulu piirangud ning kontrolli tegelikku tulemust