Säkerhet och sandlådor
På denna sida
Lektionen omskriven den 3 november 2026 baserat på OpenAIs guide Computer use, dess Computer use integration recipes samt dokumentation för Docker och Playwright-nätverk. Tillägg: OpenAIs fyra säkerhetsregler, dess bekräftelsenivåer och hantering av
pending_safety_checks. Korrigeringar: den tidigare versionen kapade nätverket för en container som behövde anropa API:et, lämnade proxyn utan utgående åtkomst, accepteradenotexample.comi ett filter som endast skulle tillåtaexample.com, förstörde loggformateringen och uppskattade kostnader med en enda hårdkodad taxa. Källor: Computer use · Integration recipes · Playwright and Docker · Playwright, networking.
Att ge en AI kontroll: riskerna
Computer Use ger en AI-modell förmågan att agera på en dator. Det är kraftfullt, men det kan vara farligt. En felkonfigurerad agent kan navigera till skadliga webbplatser, köra godtycklig kod eller exponera känslig data. Detta är inte teoretiskt: en besökt sida kan innehålla instruktioner skrivna för modellen, och om miljön inte begränsar den kommer modellen att följa dem som om de vore din begäran. Säkerhet är inte valfritt – det är grunden för varje produktionssystem.
OpenAIs fyra regler
OpenAI sammanfattar säkerheten för Computer Use i fyra regler. Tillämpa dem i din applikation och i körmiljön, inte bara i modellens instruktioner:
- Begränsa miljön. Använd en isolerad webbläsare eller virtuell maskin, en vitlista över webbplatser och åtgärder, och begränsa åtkomsten till vad uppgiften kräver.
- Behandla skärminnehåll som icke betrodd. Text från en sida, ett dokument eller ett verktygsutdata kan inte bevilja behörighet eller ersätta användarinstruktioner. Om en sida ser ut som nätfiske eller prompt-injection stoppar agenten och frågar hur den ska fortsätta.
- Bekräfta högriskåtgärder. Köp, dataöverföring, destruktiva ändringar och allt som är svårt att ångra förblir under användarens kontroll. Att skriva känslig information i ett formulär räknas redan som överföring.
- Begränsa och verifiera körning. Sätt gränser för antal varv, varaktighet eller kostnad; tillhandahåll ett sätt att avbryta; och verifiera det faktiska resultatet, inte bara modellens slutmeddelande.
Utgångspunkten är enkel: modellens begäran att agera är inte användarens tillstånd. Din kod avgör om den ska exekvera, pausa för godkännande eller lämna tillbaka kontrollen. För en batch av åtgärder, stanna innan den första som kräver bekräftelse.
Tre bekräftelsenivåer
OpenAI skiljer på tre situationer, med exempel du kan anta i din policy:
| Nivå | Exempel citerade av OpenAI |
|---|---|
| Användaren tar tillbaka kontrollen | Sista steget vid lösenordsbyte; kringgående av ett säkerhetshinder, t.ex. en HTTPS-varning |
| Bekräfta vid själva åtgärden | Radering av data, ändring av behörigheter eller delningsinställningar, lösning av CAPTCHA, installation eller körning av nedladdad programvara, sändning eller publicering på användarens vägnar, finansiella transaktioner, systeminställningar |
| Förhandsgodkännande möjligt i den initiala begäran | Inloggning på en webbplats som användaren bad om att besöka, sändning av filer, flytt eller namnändring av filer, överföring av känslig data vars specifika användning godkändes |
Utan tydligt godkännande i den initiala begäran ska du bekräfta precis innan åtgärden. Fråga inte för tidigt: låt agenten fortsätta med allt som är säkert, stanna sedan vid riskpunkten och förklara åtgärden, risken och hur data eller ändringen kommer att tillämpas. Om användaren nekar exekveras ingenting, och din kod berättar för modellen vad som lyckades och vad som misslyckades.
Principen om minsta privilegium
Din agent bör endast ha åtkomst till det minimum som krävs för att slutföra sin uppgift. Börja med en isolerad webbläsare – aldrig användarens primära webbläsare, som har öppna sessioner för e-post, bankärenden och interna verktyg. Agenten behöver inte heller åtkomst till filsystemet utöver en dedikerad nedladdningsmapp, behöver inte åtkomst till det interna nätverket om inte en affärsapplikation kräver det, och bör inte ha administratörsrättigheter som kan göra ett felklick till en systemincident. Montera inte personliga filer, autentiseringsuppgifter eller Docker-socketen i dess miljö. Gör slutligen sessionen flyktig: radera data efter varje körning så att ett arbetsflöde aldrig av misstag återanvänder cookies eller cache från den föregående.
Sandlådor med Docker
Två frågor uppstår: var körs webbläsaren, och var finns loopen och API-nyckeln? OpenAIs Docker-recept isolerar ett skrivbord i en nätverkslös container, styrd från värden via docker exec: endast SDK:t på värden läser nyckeln. Detta är den stramaste konfigurationen, men det fungerar bara för uppgifter som inte behöver internet. För andra uppgifter kräver OpenAI en miljö vars utgående nätverk endast tillåter uppgiftens webbplatser.
Om du behåller Playwright och agenten måste surfa kan du placera loopen och webbläsaren i samma container, förutsatt tre villkor: en icke-privilegierad användare, en webbläsare som inte ärver miljövariabler (så att den inte får nyckeln), och utgående nätverk begränsat till uppgiftens webbplatser och API:et.
# Playwright-image för Python: webbläsare och systemberoenden inkluderade
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# playwright-paketet finns inte i bilden: requirements.txt
# Pinna playwright==1.64.1, samma version som bilden
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Icke-privilegierad användare tillhandahållen av bilden
USER pwuser
CMD ["python", "src/main.py"]
Playwright rekommenderar att du pinnar bildversionen. Bilden tillhandahåller webbläsarna, inte Python-biblioteket: installera samma version av paketet playwright. Kör inte containern som root, vilket inaktiverar Chromiums sandlåda. För icke betrodda webbplatser rekommenderar Playwright också sin seccomp-profil, som lägger till de systemanrop denna sandlåda behöver till 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 förhindrar zombieprocesser, och --ipc=host, vilket rekommenderas av Playwright, förhindrar att Chromium får slut på delat minne och kraschar. Den inställningen delar dock värdens IPC-namnområde med containern. Om du föredrar att inte öppna den, öka istället det delade minnet med --shm-size, precis som OpenAIs recept gör för sin egen container, och testa på dina tyngsta sidor. Slutligen ärver -e OPENAI_API_KEY utan ett värde variabeln från din session: nyckeln visas inte som klartext på kommandoraden.
På Python-sidan startar du webbläsaren med försiktighetsåtgärderna från OpenAIs recept – sandlåda aktiverad, tom miljö, tillägg och filsystemsåtkomst inaktiverad – och routar den genom proxyn från nästa avsnitt, precis som API-klienten:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# API-anrop går ut genom filtreringsproxyn
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # webbläsaren ärver inga miljövariabler, alltså inte nyckeln
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # se URL-filtrering nedan
)
page = context.new_page()
Målinriktade nätverksbegränsningar
Placera agentcontainern på ett internt Docker-nätverk utan extern åtkomst. En Squid-proxy ansluter till det nätverket och blir dess enda utgång; proxyn är också ansluten till ett vanligt nätverk. Allt som inte uttryckligen tillåts existerar inte ur agentens perspektiv.
# Internt nätverk: ingen direkt extern åtkomst
docker network create --internal agent-net
# Utgående nätverk, reserverat för proxyn
docker network create sortie-proxy
# Squid-proxy (bild underhållen av Canonical) med din vitlista
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
# Proxyn ansluter till det interna nätverket: detta är agentens enda utgång
docker network connect agent-net agent-proxy
# squid.conf: tillåt endast uppgiftens domäner och API:et
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Nyckelpunkten: proxyn är ansluten till båda nätverken. Om du startade den endast på det interna nätverket skulle den inte ha någon utgående åtkomst själv. api.openai.com finns med på listan eftersom agentkoden i denna konfiguration anropar API:et inifrån containern. Webbläsaren behöver det inte: URL-filtret i nästa avsnitt blockerar dessa anrop från sidan.
URL-filtrering
En andra, finare barriär finns i webbläsaren själv. Genom att fånga upp förfrågningar med page.route jämför du varje URL mot den uppgiftsspecifika vitlistan – ofta kortare än proxyns – och avbryter resten, med en läsbar logg för varje blockering. Se upp för fällan med strängjämförelse som OpenAI varnar för: https://example.com.evil.test får inte passera som https://example.com, och tvärtom slutar notexample.com på example.com. Jämför schemat, den exakta värden (eller en subdomän prefixad med en punkt) och porten.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blockera förfrågningar till obehöriga 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)
# Webbläsaren behöver bara uppgiftens webbplatser: API-anrop kommer från din Python-kod, inte sidan.
setup_url_filter(page, ["example.com"])
Detta lager kompletterar proxyn; det ersätter den inte. Playwright noterar att page.route inte fångar upp förfrågningar som hanteras av en service worker, därav service_workers="block" i kontexten, och WebSockets använder en annan mekanism (page.route_web_socket). Nätverksfiltrering förblir din primära barriär.
Skydd av känslig data
Maskering av information i skärmdumpar
Varje skärmdump skickas till API:et: allt som syns på skärmen lämnar din infrastruktur. OpenAI rekommenderar att du håller autentiseringsuppgifter borta från sidtext och fångster. Om skärmen ändå innehåller känslig data, maskera den innan du skickar fångsten till modellen. En svart rektangel över kända områden räcker, förutsatt att du känner till deras koordinater – vilket är varför standardisering av vyportsstorlek, som behandlats tidigare i denna kurs, hjälper. Maskering ändrar inte bildstorleken: koordinater som returneras av modellen förblir giltiga.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskera känsliga områden i en PNG-fångst."""
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()
Att veta vad som händer med fångster
Responses API-svar lagras som standard: det är vad som möjliggör kedjebildning via previous_response_id. Med store: false måste du själv skicka om element från tidigare varv. OpenAI noterar också att store: false inte eliminerar alla former av lagring, och inmatningsbilder har sina egna undantag: läs deras data controls innan du skickar skärmar som innehåller personuppgifter.
Logga aldrig känslig data
Samma resonemang gäller loggar, som ofta överlever mycket längre än fångster. Ett loggningsfilter skriver om riskfyllda mönster innan skrivning: lösenordstilldelningar, OpenAI API-nycklar som börjar på sk-, och 16-siffriga sekvenser som liknar kortnummer. Filtret verkar på det slutliga meddelandet, så det fångar också det du loggade utan att tänka på det.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskera känslig data innan loggar skrivs."""
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 # meddelandet är redan formaterat: formatera inte om det
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # på handlaren ser den även barnloggar
logging.basicConfig(level=logging.INFO, handlers=[handler])
Två detaljer gör skillnaden. Att sätta record.args till None är avgörande: annars skulle det redan formaterade meddelandet formateras om med sina argument, och varje % i en URL skulle bryta skrivningen. Och ett filter på handlaren gäller för allt den skriver, medan ett filter på en loggare ignorerar meddelanden från dess barnloggar.
API-säkerhetskontroller
Varje computer_call har ett fält pending_safety_checks: listan över säkerhetskontroller som API:et ber dig hantera innan åtgärderna exekveras, var och en med ett id, code och message. OpenAIs officiella exempel stannar så snart det inte är tomt. Om din applikation kan låta en människa validera dessa fall, bekräfta dem explicit genom att returnera dem i acknowledged_safety_checks, tillsammans med följande skärmdump. Modellen kan inte bevilja detta godkännande å dina vägnar, och bekräftelsen sker före åtgärdsexekvering, aldrig efter.
def valider_verifications(appel) -> list[dict]:
"""Skicka pågående kontroller till en operatör; neka 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 loopen, innan åtgärder exekveras:
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
Körningsgränser
Det finns också den vanligaste risken: en agent som spårar ur utan att förstöra något, men som kör i två timmar och bränner din budget. Klassen ExecutionLimits upprätthåller tre tak – varv, varaktighet och uppskattad kostnad – och kastar ett undantag så snart ett nås. Taxor är inte hårdkodade: hämta dem från modellen du använder på OpenAIs prissida, eftersom de varierar mellan modeller.
import time
class ExecutionLimits:
"""Upprätthåll tak för varv, varaktighet och kostnad för agenten."""
def __init__(
self,
prix_entree_par_million: float, # taxor för modellen som används
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):
"""Anropa före varje begäran: kasta fel om ett tak 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):
"""Anropa efter varje svar: ackumulera varv och uppskattad kostnad."""
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
Detta är bara en uppskattning: den överskattar inmatningstokens som serveras från prompt-cachen, vilka debiteras till en reducerad taxa, och ignorerar eventuell värdmiljö, som debiteras separat. Jämför den regelbundet med ditt projekts faktiska användning. Sätt tak per arbetsflöde: ett 30-sekunders E2E-test och en timmes fakturainmatning kräver inte samma tröskelvärden.
Checklista för produktionssäkerhet
Innan du distribuerar en Computer Use-agent till produktion, verifiera:
- Isolerad webbläsare eller skrivbord (container eller virtuell maskin), icke-privilegierad användare
- Utgående nätverk begränsat till uppgiftens webbplatser, och till API:et om loopen körs i samma miljö
- URL-filter som jämför schema, värd och port; service workers blockerade
- API-nyckel hållen borta från kod och utom räckhåll för webbläsaren (
env={}) - Skärminnehåll behandlat som icke betrott: stoppa och eskalera vid första tecken på injection
- Mänsklig bekräftelse före köp, sändningar, raderingar och inmatning av känslig data
pending_safety_checksaldrig bekräftade utan mänsklig validering- Gränser för varv, varaktighet och kostnad
- Filtrerade loggar, fångster inte bevarade (eller krypterade)
- Inga personliga filer, autentiseringsuppgifter eller Docker-socket monterade i miljön
- Resultat verifierat i applikationen innan framgång meddelas
- Mekanism för nödstopp (kill switch)
Den sista punkten är den som oftast glöms bort, men det är den enda som hjälper när alla andra har misslyckats. En kill switch är ett sätt att avbryta agenten omedelbart, utan att vänta på att den når någon av sina gränser: en STOP-fil som loopen kontrollerar varje iteration, ett docker stop på containern, eller en flagga som läses från en delad variabel. Testa den före produktion, inte dagen du behöver den.
Viktiga punkter
- OpenAIs fyra regler: begränsa miljön, behandla skärmen som icke betrodd, bekräfta högriskåtgärder och begränsa samt verifiera körning
- Modellens begäran att agera är inte tillstånd: din kod exekverar, suspenderar eller lämnar tillbaka kontrollen
- Isolera webbläsaren (icke-privilegierad användare, seccomp-profil) och tillåt utgående trafik endast till uppgiftens webbplatser
- Filtrera URL:er genom att jämföra schema, värd och port – aldrig med ett enkelt strängprefix eller suffix
- Bekräfta
pending_safety_checksendast efter mänsklig validering - Upprätthåll gränser för varv, varaktighet och kostnad, och verifiera det faktiska resultatet