Bezpieczeństwo i piaskownica
Na tej stronie
Lekcja przepisana 3 listopada 2026 na podstawie przewodnika Computer use od OpenAI, jego przepisów integracyjnych Computer use oraz dokumentacji sieciowej Docker i Playwright. Dodatki: cztery zasady bezpieczeństwa OpenAI, poziomy potwierdzeń oraz obsługa
pending_safety_checks. Poprawki: poprzednia wersja odcinała sieć kontenerowi, który musiał wywoływać API, pozostawiała proxy bez dostępu wychodzącego, akceptowałanotexample.comw filtrze mającym przepuszczać tylkoexample.com, psuła formatowanie logów i szacowała koszty przy użyciu jednej sztywnej stawki. Źródła: Computer use · Przepisy integracyjne · Playwright i Docker · Playwright, sieć.
Przyznawanie AI kontroli: ryzyka
Computer Use daje modelowi AI możliwość działania na komputerze. To potężne narzędzie, ale może być niebezpieczne. Źle skonfigurowany agent mógłby przejść na złośliwe strony, wykonać dowolny kod lub ujawnić wrażliwe dane. To nie teoria: odwiedzona strona może zawierać instrukcje napisane dla modelu, a jeśli środowisko go nie ograniczy, model wykona je tak, jakby były Twoim poleceniem. Bezpieczeństwo nie jest opcjonalne – to fundament każdego wdrożenia produkcyjnego.
Cztery zasady OpenAI
OpenAI podsumowuje bezpieczeństwo Computer Use w czterech zasadach. Stosuj je w swojej aplikacji i w środowisku uruchomieniowym, a nie tylko w instrukcjach modelu:
- Ogranicz środowisko. Używaj izolowanej przeglądarki lub maszyny wirtualnej, listy dozwolonych witryn i działań oraz ogranicz dostęp do tego, czego wymaga zadanie.
- Traktuj zawartość ekranu jako niezaufaną. Tekst ze strony, dokumentu lub wynik działania narzędzia nie może nadawać uprawnień ani zastępować instrukcji użytkownika. Jeśli strona wygląda na phishing lub wstrzyknięcie promptu, agent zatrzymuje się i pyta, jak postępować.
- Potwierdzaj działania o wysokim ryzyku. Zakupy, przesyłanie danych, zmiany destrukcyjne i wszystko, czego trudno cofnąć, pozostaje pod kontrolą użytkownika. Wpisanie wrażliwych informacji w formularz już liczy się jako transmisja.
- Ograniczaj i weryfikuj wykonanie. Ustaw limity liczby tur, czasu trwania lub kosztu; zapewnij możliwość anulowania; weryfikuj rzeczywisty wynik, a nie tylko końcową wiadomość modelu.
Punkt wyjścia jest prosty: żądanie działania od modelu nie jest zgodą użytkownika. Twój kod decyduje, czy wykonać akcję, wstrzymać się na zatwierdzenie, czy oddać kontrolę. W przypadku serii działań zatrzymaj się przed pierwszym, które wymaga potwierdzenia.
Trzy poziomy potwierdzeń
OpenAI wyróżnia trzy sytuacje, z przykładami, które możesz przyjąć w swojej polityce:
| Poziom | Przykłady podane przez OpenAI |
|---|---|
| Użytkownik przejmuje kontrolę | Ostatni krok zmiany hasła; obejście bariery bezpieczeństwa, np. ostrzeżenia HTTPS |
| Potwierdź w momencie działania | Usuwanie danych, zmiana uprawnień lub ustawień udostępniania, rozwiązywanie CAPTCHA, instalowanie lub uruchamianie pobranego oprogramowania, wysyłanie lub publikowanie w imieniu użytkownika, transakcje finansowe, ustawienia systemowe |
| Wstępna zgoda możliwa w pierwotnym żądaniu | Logowanie do witryny, którą użytkownik poprosił odwiedzić, wysyłanie plików, przenoszenie lub zmienianie nazw plików, przesyłanie wrażliwych danych, których konkretne użycie zostało zatwierdzone |
Bez wyraźnej zgody w pierwotnym żądaniu potwierdzaj tuż przed działaniem. Nie pytaj zbyt wcześnie: pozwól agentowi działać we wszystkim, co bezpieczne, następnie zatrzymaj się w punkcie ryzyka i wyjaśnij działanie, ryzyko oraz sposób zastosowania danych lub zmiany. Jeśli użytkownik odmówi, nic się nie wykonuje, a Twój kod informuje model, co się powiodło, a co nie.
Zasada najmniejszych uprawnień
Twój agent powinien mieć dostęp tylko do minimum niezbędnego do wykonania zadania. Zacznij od izolowanej przeglądarki – nigdy od głównej przeglądarki użytkownika, która przechowuje otwarte sesje poczty, bankowości i narzędzi wewnętrznych. Agent nie potrzebuje też dostępu do systemu plików poza dedykowanym folderem pobierania, nie potrzebuje dostępu do sieci wewnętrznej, chyba że wymaga tego aplikacja biznesowa, i nie powinien mieć uprawnień administratora, które mogłyby zamienić błędne kliknięcie w incydent systemowy. Nie montuj w jego środowisku plików osobistych, poświadczeń ani gniazda Dockera. Na koniec spraw, by sesja była efemeryczna: usuwaj dane po każdym uruchomieniu, aby przepływ pracy nigdy przypadkowo nie wykorzystał plików cookie ani pamięci podręcznej z poprzedniej sesji.
Piaskownica z Dockerem
Pojawiają się dwa pytania: gdzie działa przeglądarka, a gdzie pętla i klucz API? Przepis Dockera od OpenAI izoluje pulpit w kontenerze bez sieci, sterowanym z hosta przez docker exec: tylko SDK na hoście odczytuje klucz. To najszczelniejsza konfiguracja, ale działa tylko dla zadań niewymagających internetu. W przypadku innych zadań OpenAI wymaga środowiska, którego sieć wychodząca pozwala wyłącznie na witryny związane z zadaniem.
Jeśli używasz Playwright i agent musi przeglądać, możesz umieścić pętlę i przeglądarkę w tym samym kontenerze, pod warunkiem spełnienia trzech warunków: użytkownik nieuprzywilejowany, przeglądarka nie dziedzicząca zmiennych środowiskowych (więc nie otrzyma klucza) oraz sieć wychodząca ograniczona do witryn zadania i API.
# Obraz Playwright dla Pythona: przeglądarki i zależności systemowe włączone
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble
WORKDIR /app
# Pakiet playwright nie ma w obrazie: requirements.txt
# Przypnij playwright==1.64.1, tę samą wersję co obraz
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ ./src/
# Użytkownik nieuprzywilejowany dostarczony przez obraz
USER pwuser
CMD ["python", "src/main.py"]
Playwright zaleca przypinanie wersji obrazu. Obraz dostarcza przeglądarki, nie bibliotekę Pythona: zainstaluj tę samą wersję pakietu playwright. Nie uruchamiaj kontenera jako root, co wyłącza piaskownicę Chromium. Dla niezaufanych witryn Playwright zaleca również swój profil seccomp, który dodaje wywołania systemowe potrzebne tej piaskownicy do domyślnego profilu Dockera.
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 zapobiega procesom zombie, a --ipc=host, zalecane przez Playwright, zapobiega wyczerpaniu pamięci współdzielonej przez Chromium i awarii. Jednak to ustawienie udostępnia przestrzeń nazw IPC hosta kontenerowi. Jeśli wolisz tego nie otwierać, zwiększ pamięć współdzieloną za pomocą --shm-size, tak jak robi to przepis OpenAI dla własnego kontenera, i przetestuj na swoich najcięższych stronach. Na koniec -e OPENAI_API_KEY bez wartości dziedziczy zmienną z Twojej sesji: klucz nie pojawia się jako tekst jawny w wierszu poleceń.
Po stronie Pythona uruchom przeglądarkę z zabezpieczeniami z przepisu OpenAI – włączona piaskownica, puste środowisko, wyłączone rozszerzenia i dostęp do systemu plików – i kieruj ją przez proxy z następnej sekcji, tak jak klienta API:
from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright
PROXY = "http://agent-proxy:3128"
# Wywołania API wychodzą przez filtrujące proxy
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))
pw = sync_playwright().start()
browser = pw.chromium.launch(
headless=True,
chromium_sandbox=True,
env={}, # przeglądarka nie dziedziczy zmiennych środowiskowych, więc nie klucza
args=["--disable-extensions", "--disable-file-system"],
proxy={"server": PROXY},
)
context = browser.new_context(
viewport={"width": 1280, "height": 720},
service_workers="block", # zobacz filtrowanie URL poniżej
)
page = context.new_page()
Ukierunkowane ograniczenia sieciowe
Umieść kontener agenta w wewnętrznej sieci Docker bez dostępu zewnętrznego. Proxy Squid dołącza do tej sieci i staje się jej jedynym wyjściem; proxy jest też podłączone do zwykłej sieci. Wszystko, co nie jest wyraźnie dozwolone, z perspektywy agenta nie istnieje.
# Sieć wewnętrzna: brak bezpośredniego dostępu zewnętrznego
docker network create --internal agent-net
# Sieć wychodząca, zarezerwowana dla proxy
docker network create sortie-proxy
# Proxy Squid (obraz utrzymywany przez Canonical) z Twoją listą dozwolonych
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 dołącza do sieci wewnętrznej: to jedyne wyjście agenta
docker network connect agent-net agent-proxy
# squid.conf: zezwalaj tylko na domeny zadania i API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all
Kluczowy punkt: proxy jest podłączone do obu sieci. Jeśli uruchomiłbyś je tylko w sieci wewnętrznej, samo nie miałoby dostępu wychodzącego. api.openai.com jest na liście, ponieważ w tej konfiguracji kod agenta wywołuje API z wnętrza kontenera. Przeglądarka tego nie potrzebuje: filtr URL w następnej sekcji blokuje te wywołania ze strony.
Filtrowanie URL
Druga, dokładniejsza bariera znajduje się w samej przeglądarce. Przechwytując żądania za pomocą page.route, porównaj każdy URL ze specyficzną dla zadania listą dozwolonych – często krótszą niż lista proxy – i przerywaj resztę, z czytelnym logiem każdego zablokowania. Uważaj na pułapkę porównania ciągów, przed którą ostrzega OpenAI: https://example.com.evil.test nie może przejść jako https://example.com, a odwrotnie notexample.com kończy się na example.com. Porównuj schemat, dokładny host (lub subdomenę z prefiksem kropki) i port.
from urllib.parse import urlparse
def setup_url_filter(page, allowed_domains: list[str]):
"""Blokuj żądania do nieautoryzowanych miejsc docelowych."""
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)
# Przeglądarka potrzebuje tylko witryn zadania: wywołania API pochodzą z kodu Python, nie ze strony.
setup_url_filter(page, ["example.com"])
Ta warstwa uzupełnia proxy; nie zastępuje go. Playwright zauważa, że page.route nie przechwytuje żądań obsługiwanych przez service worker, stąd service_workers="block" w kontekście, a WebSockets używają innego mechanizmu (page.route_web_socket). Filtrowanie sieci pozostaje Twoją główną barierą.
Ochrona wrażliwych danych
Maskowanie informacji na zrzutach ekranu
Każdy zrzut ekranu trafia do API: wszystko widoczne na ekranie opuszcza Twoją infrastrukturę. OpenAI zaleca utrzymywanie poświadczeń poza tekstem strony i przechwyconymi obrazami. Jeśli ekran zawiera dane wrażliwe, zamaskuj je przed wysłaniem przechwytu do modelu. Czarny prostokąt na znanych obszarach wystarczy, pod warunkiem że znasz ich współrzędne – dlatego standaryzacja rozmiaru viewportu, omówiona wcześniej w tym kursie, pomaga. Maskowanie nie zmienia rozmiaru obrazu: współrzędne zwracane przez model pozostają ważne.
import io
from PIL import Image, ImageDraw
def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
"""Maskuj wrażliwe obszary na przechwycie 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()
Wiedza o losie przechwytów
Odpowiedzi Responses API są domyślnie przechowywane: to umożliwia łańcuchowanie przez previous_response_id. Przy store: false musisz samodzielnie resendować elementy z poprzednich tur. OpenAI zauważa również, że store: false nie eliminuje wszystkich form przechowywania, a obrazy wejściowe mają własne wyjątki: przeczytaj jego kontrolki danych przed wysłaniem ekranów zawierających dane osobowe.
Nigdy nie loguj wrażliwych danych
To samo rozumowanie dotyczy logów, które często przetrwają znacznie dłużej niż przechwyty. Filtr logowania przepisuje ryzykowne wzorce przed zapisem: przypisania haseł, klucze API OpenAI zaczynające się od sk- oraz 16-cyfrowe sekwencje przypominające numery kart. Filtr działa na finalnej wiadomości, więc wyłapuje też to, co zalogowałeś bez zastanowienia.
import logging
import re
class SensitiveFilter(logging.Filter):
"""Maskuj wrażliwe dane przed zapisem logów."""
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 # wiadomość już sformatowana: nie formatuj jej ponownie
return True
handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter()) # na handlerze widzi też logery potomne
logging.basicConfig(level=logging.INFO, handlers=[handler])
Dwa szczegóły robią różnicę. Ustawienie record.args na None jest kluczowe: w przeciwnym razie już sformatowana wiadomość zostałaby sformatowana ponownie z argumentami, a każde % w URL zepsułoby zapis. Filtr na handlerze dotyczy wszystkiego, co zapisuje, podczas gdy filtr na loggerze ignoruje wiadomości od jego loggerów potomnych.
Kontrole bezpieczeństwa API
Każde computer_call niesie pole pending_safety_checks: listę kontroli bezpieczeństwa, które API prosi Cię obsłużyć przed wykonaniem działań, każda z id, code i message. Oficjalny przykład OpenAI zatrzymuje się, gdy lista nie jest pusta. Jeśli Twoja aplikacja może mieć człowieka walidującego te przypadki, potwierdź je wyraźnie, zwracając je w acknowledged_safety_checks wraz z następnym zrzutem ekranu. Model nie może nadać tej zgody w Twoim imieniu, a potwierdzenie następuje przed wykonaniem działania, nigdy po.
def valider_verifications(appel) -> list[dict]:
"""Przedstaw oczekujące kontrole operatorowi; domyślnie odmów."""
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
]
# W pętli, przed wykonaniem działań:
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
Limity wykonania
Istnieje też najczęstsze ryzyko: agent, który wymyka się spod kontroli, niczego nie psując, ale działa dwie godziny i przepala budżet. Klasa ExecutionLimits egzekwuje trzy sufity – liczba tur, czas trwania i szacowany koszt – i zgłasza wyjątek, gdy którykolwiek zostanie osiągnięty. Stawki nie są sztywne: pobierz je z modelu, którego używasz, ze strony cennika OpenAI, ponieważ różnią się w zależności od modelu.
import time
class ExecutionLimits:
"""Egzekwuj sufity liczby tur, czasu trwania i kosztu dla agenta."""
def __init__(
self,
prix_entree_par_million: float, # stawki dla używanego modelu
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):
"""Wywołaj przed każdym żądaniem: zgłoś błąd, jeśli osiągnięto sufit."""
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):
"""Wywołaj po każdej odpowiedzi: akumuluj tury i szacowany koszt."""
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 tylko szacunek: zawyża tokeny wejściowe obsługiwane z pamięci podręcznej promptu, które są rozliczane po obniżonej stawce, i ignoruje wszelkie środowiska hostowane, rozliczane osobno. Porównuj go regularnie z rzeczywistym użyciem projektu. Ustawiaj sufity na przepływ pracy: 30-sekundowy test E2E i godzinne wprowadzanie faktur nie wymagają tych samych progów.
Lista kontrolna bezpieczeństwa produkcyjnego
Przed wdrożeniem agenta Computer Use do produkcji sprawdź:
- Izolowana przeglądarka lub pulpit (kontener lub maszyna wirtualna), użytkownik nieuprzywilejowany
- Sieć wychodząca ograniczona do witryn zadania i do API, jeśli pętla działa w tym samym środowisku
- Filtr URL porównujący schemat, host i port; service workery zablokowane
- Klucz API trzymany poza kodem i poza zasięgiem przeglądarki (
env={}) - Zawartość ekranu traktowana jako niezaufana: zatrzymaj i eskaluj przy pierwszym znaku wstrzyknięcia
- Potwierdzenie człowieka przed zakupami, wysyłkami, usunięciami i wprowadzaniem danych wrażliwych
pending_safety_checksnigdy nie potwierdzane bez walidacji człowieka- Limity liczby tur, czasu trwania i kosztu
- Filtrowane logi, przechwyty nieprzechowywane (lub szyfrowane)
- Brak montowania plików osobistych, poświadczeń lub gniazda Dockera w środowisku
- Wynik zweryfikowany w aplikacji przed ogłoszeniem sukcesu
- Mechanizm awaryjnego zatrzymania (kill switch)
Ostatni punkt jest najczęściej zapominany, a jednak to jedyny, który pomaga, gdy wszystkie inne zawiodą. Kill switch to sposób na natychmiastowe przerwanie działania agenta, bez czekania, aż osiągnie któryś z limitów: plik STOP, który pętla sprawdza w każdej iteracji, docker stop na kontenerze lub flaga odczytywana ze zmiennej współdzielonej. Przetestuj go przed produkcją, nie w dniu, gdy go potrzebujesz.
Kluczowe wnioski
- Cztery zasady OpenAI: ogranicz środowisko, traktuj ekran jako niezaufany, potwierdzaj działania o wysokim ryzyku oraz ograniczaj i weryfikuj wykonanie
- Żądanie działania od modelu nie jest zgodą: Twój kod wykonuje, wstrzymuje lub oddaje kontrolę
- Izoluj przeglądarkę (użytkownik nieuprzywilejowany, profil seccomp) i zezwalaj na ruch wychodzący tylko do witryn zadania
- Filtruj URL, porównując schemat, host i port – nigdy przez prosty prefiks lub sufiks ciągu
- Potwierdzaj
pending_safety_checkstylko po walidacji człowieka - Egzekwuj limity liczby tur, czasu trwania i kosztu oraz weryfikuj rzeczywisty wynik