Sikkerhed og sandboxing
På denne side
Lektion omskrevet 3. november 2026 baseret på OpenAIs guide til Computer use, deres opskrifter til integration af Computer use samt dokumentation for Docker og Playwright-netværk. Tilføjelser: OpenAIs fire sikkerhedsregler, deres bekræftelsesniveauer og anerkendelse af
pending_safety_checks. Rettelser: Den tidligere version afbrød netværket for en container, der skulle kalde API’et, efterlod proxyen uden udgående adgang, accepteredenotexample.comi et filter, der kun skulle tilladeexample.com, ødelagde logformatering og estimerede omkostninger ved hjælp af én hardcodet sats. Kilder: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.
Når en AI får kontrol: Risiciene
Computer Use giver en AI-model evnen til at handle på en computer. Det er kraftfuldt, men det kan være farligt. En forkert konfigureret agent kunne navigere til ondsindede sider, udføre vilkårlig kode eller afsløre følsomme data. Dette er ikke teoretisk: En besøgt side kan indeholde instruktioner skrevet specifikt til modellen, og hvis miljøet ikke begrænser den, vil modellen følge dem, som var det din anmodning. Sikkerhed er ikke valgfrit – det er fundamentet for enhver produktionsoverførsel.
OpenAIs fire regler
OpenAI opsummerer sikkerheden for Computer Use i fire regler. Anvend dem både i din applikation og i runtime-miljøet, ikke kun i modellens instrukser:
- Begræns miljøet. Brug en isoleret browser eller virtuel maskine, en liste over tilladte sider og handlinger (allowlist), og begræns adgangen til det, opgaven kræver.
- Behandle skærmindhold som ikke-betroet. Tekst fra en side, et dokument eller et værktøjsoutput kan ikke give tilladelse eller erstatte brugerinstruktioner. Hvis en side ligner phishing eller prompt injection, stopper agenten og spørger, hvordan den skal fortsætte.
- Bekræft højrisikohandlinger. Køb, dataoverførsel, destruktive ændringer og alt, der er svært at fortryde, forbliver under brugerkontrol. At indtaste følsomme oplysninger i en formular tæller allerede som dataoverførsel.
- Afgræns og verificér udførelse. Sæt grænser for antal ture, varighed eller omkostninger; sørg for en måde at annullere på; og verificér det faktiske resultat, ikke kun modellens sidste besked.
Udgangspunktet er simpelt: Modellens anmodning om at handle er ikke brugertilladelse. Din kode beslutter, om handlingen skal udføres, pauses til godkendelse, eller om kontrollen skal gives tilbage. Ved en række handlinger skal du stoppe før den første, der kræver bekræftelse.
Tre bekræftelsesniveauer
OpenAI skelner mellem tre situationer med eksempler, du kan adoptere i din politik:
| Niveau | Eksempler nævnt af OpenAI |
|---|---|
| Brugeren tager kontrollen tilbage | Sidste trin i en adgangskodeændring; omgåelse af en sikkerhedsbarriere, f.eks. en HTTPS-advarsel |
| Bekræft i øjeblikket handlingen udføres | Sletning af data, ændring af tilladelser eller delingsindstillinger, løsning af en CAPTCHA, installation eller kørsel af downloadet software, afsendelse eller publicering på brugerens vegne, finansielle transaktioner, systemindstillinger |
| Forhåndsgodkendelse mulig i den oprindelige anmodning | Login på en side, brugeren bad om at besøge, afsendelse af filer, flytning eller omdøbning af filer, overførsel af følsomme data, hvis specifikke brug blev godkendt |
Uden klar godkendelse i den oprindelige anmodning skal du bekræfte lige før handlingen. Spørg ikke for tidligt: Lad agenten fortsætte med alt, der er sikkert, stop så ved risikopunktet og forklar handlingen, risikoen, og hvordan dataene eller ændringen vil blive anvendt. Hvis brugeren afviser, udføres intet, og din kode fortæller modellen, hvad der lykkedes, og hvad der fejlede.
Princippet om mindste privilegium
Din agent bør kun have adgang til det absolut nødvendige for at fuldføre sin opgave. Start med en isoleret browser – aldrig brugerens primære browser, som har åbne sessioner til e-mail, bank og interne værktøjer. Agenten har heller ikke brug for filsystemadgang udover en dedikeret downloadmappe, har ikke brug for adgang til det interne netværk, medmindre en forretningsapplikation kræver det, og bør ikke have administratorrettigheder, der kunne gøre et fejlklik til en systemhændelse. Mount ikke personlige filer, legimitationsoplysninger eller Docker-socketet ind i dens miljø. Gør endelig sessionen flygtig: Slet data efter hver kørsel, så et workflow aldrig utilsigtet genbruger cookies eller cache fra den forrige.
Sandboxing med Docker
To spørgsmål opstår: Hvor kører browseren, og hvor bor løkken og API-nøglen? OpenAIs Docker-opskrift isolerer et skrivebord i en netværksløs container, styret fra værten via docker exec: Kun SDK’et på værten læser nøglen. Dette er den strammeste konfiguration, men det fungerer kun for opgaver, der ikke har brug for internettet. Til andre opgaver kræver OpenAI et miljø, hvis udgående netværk kun tillader opgavens sider.
Hvis du beholder Playwright, og agenten skal browse, kan du placere løkken og browseren i samme container, forudsat tre betingelser: En ikke-privilegeret bruger, en browser, der ikke arver miljøvariabler (så den ikke får nøglen), og udgående netværk begrænset til opgavens sider og API’et.
# Playwright-image til Python: Browsere og systemafhængigheder inkluderet
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Playwright-pakken er ikke i image'et: requirements.txt
# Pin playwright==1.64.1, samme version som image'et
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Ikke-privilegeret bruger leveret af image'et
USER pwuser
CMD ["python", "src/main.py"]
Playwright anbefaler at pinne image-versionen. Image’et leverer browserne, ikke Python-biblioteket: Installer samme version af playwright-pakken. Kør ikke containeren som root, hvilket deaktiverer Chromiu’s sandbox. Til ikke-betroede sider anbefaler Playwright også deres seccomp-profil, som tilføjer de systemkald, denne sandbox har brug for, til Dockers standardprofil.
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 forhindrer zombie-processer, og --ipc=host, anbefalet af Playwright, forhindrer Chromium i at løbe tør for delt hukommelse og crashe. Denne indstilling deler dog værtens IPC-navnerum med containeren. Hvis du foretrækker ikke at åbne dette, kan du øge den delte hukommelse med --shm-size i stedet, som OpenAIs opskrift gør for sin egen container, og teste på dine tungeste sider. Endelig arver -e OPENAI_API_KEY uden en værdi variablen fra din session: Nøglen vises ikke som klartekst på kommandolinjen.
På Python-siden skal du starte browseren med forholdsreglerne fra OpenAIs opskrift – sandbox aktiveret, tomt miljø, udvidelser og filsystemadgang deaktiveret – og rute den gennem proxyen fra næste afsnit, ligesom API-klienten:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# API-kald går ud gennem den filtrerende proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # browseren arver ingen miljøvariabler, så ikke nøglen
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # se URL-filtrering nedenfor
)
page = context.new_page()
Målrettede netværksbegrænsninger
Placer agent-containeren på et internt Docker-netværk uden ekstern adgang. En Squid-proxy tilslutter sig dette netværk og bliver dens eneste udgang; proxyen er også forbundet til et almindeligt netværk. Alt, der ikke eksplicit er tilladt, eksisterer ikke fra agentens perspektiv.
# Internt netværk: Ingen direkte ekstern adgang
docker network create --internal agent-net
# Udgående netværk, reserveret til proxyen
docker network create sortie-proxy
# Squid-proxy (image vedligeholdt af Canonical) med din 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
# Proxyen tilslutter det interne netværk: Dette er agentens eneste udgang
docker network connect agent-net agent-proxy
# squid.conf: Tillad kun opgavens domæner og API'et
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Det vigtigste punkt: Proxyen er forbundet til begge netværk. Hvis du startede den kun på det interne netværk, ville den ikke selv have udgående adgang. api.openai.com er på listen, fordi agentkoden i denne opsætning kalder API’et indefra containeren. Browseren har ikke brug for det: URL-filteret i næste afsnit blokerer disse kald fra siden.
URL-filtrering
En anden, finere barriere findes i selve browseren. Ved at aflytte anmodninger med page.route sammenligner du hver URL med den opgavespecifikke allowlist – ofte kortere end proxyens – og afbryder resten med en læsbar log over hver blokering. Pas på den fælde ved strengsammenligning, som OpenAI advarer om: https://example.com.evil.test må ikke passere som https://example.com, og omvendt slutter notexample.com på example.com. Sammenlign skemaet, det nøjagtige værtsnavn (eller et underdomæne med et punktum foran) og porten.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blokér anmodninger til ikke-autoriserede destinationer."""
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)
# Browseren har kun brug for opgavens sider: API-kald kommer fra din Python-kode, ikke siden.
setup_url_filter(page, ["example.com"])
Dette lag supplerer proxyen; det erstatter den ikke. Playwright bemærker, at page.route ikke aflytter anmodninger håndteret af en service worker, derfor service_workers="block" i konteksten, og WebSockets bruger en anden mekanisme (page.route_web_socket). Netværksfiltrering forbliver din primære barriere.
Beskyttelse af følsomme data
Maskering af oplysninger i skærmbilleder
Hvert skærmbillede sendes til API’et: Alt, der er synligt på skærmen, forlader din infrastruktur. OpenAI anbefaler at holde legimitationsoplysninger ude af sidetekst og captures. Hvis skærmen alligevel indeholder følsomme data, skal du maskere dem, før du sender capturen til modellen. En sort rektangel over kendte områder er nok, forudsat at du kender deres koordinater – hvilket er grunden til, at standardisering af viewport-størrelse, som dækket tidligere i dette kursus, hjælper. Maskering ændrer ikke billedstørrelsen: Koordinater returneret af modellen forbliver gyldige.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskér følsomme områder i en 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()
Viden om, hvad der sker med captures
Responses API-responser gemmes som standard: Det er det, der muliggør kædning via previous_response_id. Med store: false skal du selv videresende elementer fra tidligere ture. OpenAI bemærker også, at store: false ikke eliminerer alle former for opbevaring, og inputbilleder har deres egne undtagelser: Læs deres data controls, før du sender skærme, der indeholder personlige data.
Log aldrig følsomme data
Den samme ræsonnement gælder for logs, som ofte overlever meget længere end captures. Et logfilter omskriver risikable mønstre, før der skrives: Adgangskodetildelinger, OpenAI API-nøgler, der starter med sk-, og 16-cifrede sekvenser, der ligner kortnumre. Filteret virker på den endelige besked, så det fanger også det, du loggede uden at tænke over det.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskér følsomme data før logs skrives."""
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 # beskeden er allerede formateret: Genformatér den ikke
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # på handleren ser den også child-loggere
logging.basicConfig(level=logging.INFO, handlers=[handler])
To detaljer gør forskellen. At sætte record.args til None er afgørende: Ellers ville den allerede formaterede besked blive genformateret med sine argumenter, og ethvert % i en URL ville ødelægge skrivningen. Og et filter på handleren gælder for alt, den skriver, hvorimod et filter på en logger ignorerer beskeder fra dens child-loggere.
API-sikkerhedstjek
Hvert computer_call indeholder et felt pending_safety_checks: Listen over sikkerhedstjek, API’et beder dig håndtere, før handlingerne udføres, hver med en id, code og message. OpenAIs officielle eksempel stopper, så snart listen ikke er tom. Hvis din applikation kan få et menneske til at validere disse tilfælde, skal du anerkende dem eksplicit ved at returnere dem i acknowledged_safety_checks sammen med det følgende skærmbillede. Modellen kan ikke give denne godkendelse på dine vegne, og anerkendelsen sker før udførelsen af handlingen, aldrig efter.
def valider_verifications(appel) -> list[dict]:
"""Indsend ventende tjek til en operatør; afvis som standard."""
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
]
# I løkken, før handlinger udføres:
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
Udførelsesgrænser
Der er også den mest almindelige risiko: En agent, der løber løbsk uden at ødelægge noget, men kører i to timer og brænder dit budget af. Klassen ExecutionLimits håndhæver tre lofter – antal ture, varighed og estimerede omkostninger – og rejser en undtagelse, så snart én nås. Satser er ikke hardcodet: Hent dem fra den model, du bruger, på OpenAIs prisside, da de varierer efter model.
import time
class ExecutionLimits:
"""Håndhæv lofter for antal ture, varighed og omkostninger på agenten."""
def __init__(
self,
prix_entree_par_million: float, # satser for modellen i brug
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):
"""Kald før hver anmodning: Rejs en fejl, hvis et loft nås."""
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):
"""Kald efter hvert svar: Akkumuler antal ture og estimerede omkostninger."""
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
Dette er kun et estimat: Det overdriver input-tokens serveret fra prompt-cachen, som faktureres til en reduceret sats, og ignorerer ethvert hostet miljø, der faktureres separat. Sammenlign det regelmæssigt med dit projekts faktiske forbrug. Sæt lofter pr. workflow: En 30-sekunders E2E-test og en times lang fakturaindtastning kræver ikke de samme tærskler.
Sikkerhedstjekliste til produktion
Før du overfører en Computer Use-agent til produktion, skal du verificere:
- Isoleret browser eller skrivebord (container eller virtuel maskine), ikke-privilegeret bruger
- Udgående netværk begrænset til opgavens sider og til API’et, hvis løkken kører i samme miljø
- URL-filter, der sammenligner skema, vært og port; service workers blokeret
- API-nøgle holdt ude af kode og ude af browserens rækkevidde (
env={}) - Skærmindhold behandlet som ikke-betroet: Stop og eskalér ved første tegn på injection
- Menneskelig bekræftelse før køb, afsendelser, sletninger og indtastning af følsomme data
pending_safety_checksaldrig anerkendt uden menneskelig validering- Grænser for antal ture, varighed og omkostninger
- Filtrerede logs, captures ikke gemt (eller krypteret)
- Ingen personlige filer, legimitationsoplysninger eller Docker-socket mountet ind i miljøet
- Resultat verificeret i applikationen, før succes annonceres
- Mekanisme til nødstop (kill switch)
Det sidste punkt er det, der oftest glemmes, men det er det eneste, der hjælper, når alle de andre har fejlet. En kill switch er en måde at afbryde agenten øjeblikkeligt på uden at vente på, at den rammer en af sine grænser: En STOP-fil, som løkken tjekker hver iteration, en docker stop på containeren eller et flag læst fra en delt variabel. Test den før produktion, ikke den dag du får brug for den.
Vigtige pointer
- OpenAIs fire regler: Begræns miljøet, behandl skærmen som ikke-betroet, bekræft højrisikohandlinger, og afgræns og verificér udførelse
- Modellens anmodning om at handle er ikke tilladelse: Din kode udfører, suspenderer eller giver kontrollen tilbage
- Isolér browseren (ikke-privilegeret bruger, seccomp-profil) og tillad kun udgående trafik til opgavens sider
- Filtrér URL’er ved at sammenligne skema, vært og port – aldrig ved et simpelt strengpræfiks eller -suffix
- Anerkend kun
pending_safety_checksefter menneskelig validering - Håndhæv grænser for antal ture, varighed og omkostninger, og verificér det faktiske resultat