Премини към основното съдържание
Български— Изберете език
Меню

Сигурност и изолирана среда (sandboxing)

Урок 12 от 14 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Предоставяне на контрол на ИИ: рисковете
  2. Четирите правила на OpenAI
  3. Принципът на най-малките привилегии
  4. Изолиране (Sandboxing) с Docker
  5. Филтриране на URL адреси
  6. Защита на чувствителни данни
  7. Проверки за сигурност на API
  8. Лимити на изпълнение
  9. Контролен списък за сигурност в продукционна среда
  10. Ключови изводи

Урокът е пренаписан на 3 ноември 2026 г. въз основа на ръководството на OpenAI за Computer use, неговите рецепти за интеграция на Computer use и документацията за мрежова работа на Docker и Playwright. Добавки: четирите правила за сигурност на OpenAI, нивата на потвърждение и обработката на pending_safety_checks. Корекции: предишната версия прекъсваше мрежата за контейнер, който трябваше да извика API, оставяше прокси сървъра без изходящ достъп, приемаше notexample.com във филтър, предназначен да позволява само example.com, нарушаваше форматирането на логовете и оценяваше разходите чрез една фиксирана ставка. Източници: Computer use · Рецепти за интеграция · Playwright и Docker · Playwright, мрежова работа.

Предоставяне на контрол на ИИ: рисковете

Computer Use дава възможност на ИИ модел да действа върху компютър. Това е мощно, но може да бъде опасно. Неправилно конфигуриран агент може да навигира до зловредни сайтове, да изпълнява произволен код или да разкрива чувствителни данни. Това не е теоретичен риск: посетената страница може да съдържа инструкции, написани специално за модела, и ако средата не го ограничава, моделът ще ги изпълни така, сякаш са Вашата заявка. Сигурността не е опция – тя е основата на всяко внедряване в продукционна среда.

Четирите правила на OpenAI

OpenAI обобщава сигурността на Computer Use в четири правила. Приложете ги както във Вашето приложение, така и в изпълнителната среда, а не само в инструкциите към модела:

  • Ограничете средата. Използвайте изолиран браузър или виртуална машина, списък с позволени сайтове и действия (allowlist) и ограничете достъпа до необходимото за задачата.
  • Третирайте съдържанието на екрана като недоверено. Текст от страница, документ или изход от инструмент не може да предоставя разрешение или да замества потребителските инструкции. Ако страница прилича на фишинг или опит за инжектиране на промпт (prompt injection), агентът спира и пита как да продължи.
  • Потвърждавайте действия с високи залози. Покупки, предаване на данни, деструктивни промени и всичко, което трудно се отменя, остават под контрола на потребителя. Въвеждането на чувствителна информация във форма вече се счита за предаване.
  • Ограничете и проверете изпълнението. Задайте лимити за брой стъпки (turns), продължителност или разход; осигурете начин за отмяна; и проверете действителния резултат, а не само крайното съобщение на модела.

Отправната точка е проста: искането на модела за действие не е потребителско разрешение. Вашият код решава дали да изпълни действието, да паузира за одобрение или да върне контрола. При пакет от действия спрете преди първото, което изисква потвърждение.

Три нива на потвърждение

OpenAI разграничава три ситуации с примери, които можете да включите във Вашата политика:

НивоПримери, цитирани от OpenAI
Потребителят поема контролаПоследна стъпка при промяна на парола; заобикаляне на защитна бариера, като предупреждение за HTTPS
Потвърждение в момента на действиетоИзтриване на данни, промяна на права или настройки за споделяне, решаване на CAPTCHA, инсталиране или стартиране на изтеглен софтуер, изпращане или публикуване от името на потребителя, финансови транзакции, системни настройки
Предварително одобрение възможно в първоначалната заявкаВлизане в сайт, който потребителят е поискал да посети, изпращане на файлове, преместване или преименуване на файлове, предаване на чувствителни данни, чиято конкретна употреба е одобрена

Без ясно одобрение в първоначалната заявка, потвърждавайте точно преди действието. Не питайте твърде рано: оставете агента да продължи с всичко безопасно, след което спрете в рисковата точка и обяснете действието, риска и начина, по който данните или промяната ще бъдат приложени. Ако потребителят откаже, нищо не се изпълнява, а Вашият код информира модела какво е успешно и какво е неуспешно.

Принципът на най-малките привилегии

Вашият агент трябва да има достъп само до минимума, необходим за изпълнението на задачата. Започнете с изолиран браузър – никога основния браузър на потребителя, който съдържа отворени сесии за имейл, банкиране и вътрешни инструменти. Агентът също така не се нуждае от достъп до файловата система, освен до специализирана папка за изтегляния, не се нуждае от достъп до вътрешната мрежа, освен ако бизнес приложение не го изисква, и не трябва да има администраторски права, които биха могли да превърнат едно грешно кликване в системен инцидент. Не монтирайте лични файлове, удостоверителни данни или Docker сокета в неговата среда. Накрая, направете сесията ефемерна: изтривайте данните след всяко изпълнение, за да не може работен поток случайно да преизползва бисквитки или кеш от предишния.

Изолиране (Sandboxing) с Docker

Възникват два въпроса: къде се изпълнява браузърът и къде живеят цикълът и API ключът? Docker рецептата на OpenAI изолира работна среда в контейнер без мрежов достъп, контролиран от хоста чрез docker exec: само SDK на хоста чете ключа. Това е най-строгата конфигурация, но работи само за задачи, които не изискват интернет. За други задачи OpenAI изисква среда, чийто изходящ мрежов трафик позволява само сайтовете за задачата.

Ако използвате Playwright и агентът трябва да сърфира, можете да поставите цикъла и браузъра в един и същи контейнер, при условие че са изпълнени три условия: непривилегирован потребител, браузър, който не наследява променливи на средата (за да не получи ключа), и изходяща мрежа, ограничена до сайтовете за задачата и API.

# Playwright изображение за Python: браузърите и системните зависимости са включени
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# Пакетът playwright не е в изображението: requirements.txt
# Фиксирайте playwright==1.64.1, същата версия като изображението
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Непривилегирован потребител, предоставен от изображението
USER pwuser

CMD ["python", "src/main.py"]

Playwright препоръчва фиксиране на версията на изображението. Изображението предоставя браузърите, а не Python библиотеката: инсталирайте същата версия на пакета playwright. Не стартирайте контейнера като root, тъй като това деактивира пясъчника (sandbox) на Chromium. За недоверени сайтове Playwright препоръчва също така своя seccomp профил, който добавя необходимите системни извиквания към профила по подразбиране на Docker.

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 предотвратява зомби процеси, а --ipc=host, препоръчано от Playwright, предотвратява изчерпването на споделена памет от Chromium и сривове. Въпреки това, тази настройка споделя IPC пространството на имената на хоста с контейнера. Ако предпочитате да не го отваряте, увеличете споделената памет с --shm-size, както прави рецептата на OpenAI за собствения си контейнер, и тествайте върху най-тежките си страници. Накрая, -e OPENAI_API_KEY без стойност наследява променливата от Вашата сесия: ключът не се появява в чист текст в командния ред.

От страна на Python, стартирайте браузъра с предпазните мерки от рецептата на OpenAI – активиран пясъчник, празна среда, деактивирани разширения и достъп до файлова система – и го насочете през прокси сървъра от следващата секция, точно като API клиента:

from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright

PROXY = "http://agent-proxy:3128"

# API повикванията излизат през филтриращото прокси
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # браузърът не наследява променливи на средата, следователно не и ключа
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # вижте филтрирането на URL по-долу
)
page = context.new_page()

Целеви мрежови ограничения

Поставете контейнера на агента във вътрешна Docker мрежа без външен достъп. Squid прокси сървър се присъединява към тази мрежа и става единственият ѝ изход; прокси сървърът също е свързан с обикновена мрежа. Всичко, което не е изрично разрешено, не съществува от гледна точка на агента.

# Вътрешна мрежа: няма директен външен достъп
docker network create --internal agent-net
# Изходяща мрежа, запазена за прокси сървъра
docker network create sortie-proxy

# Squid прокси (изображение, поддържано от Canonical) с Вашия списък с позволени
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

# Прокси сървърът се присъединява към вътрешната мрежа: това е единственият изход на агента
docker network connect agent-net agent-proxy
# squid.conf: позволява само домейните за задачата и API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

Ключовият момент: прокси сървърът е свързан и към двете мрежи. Ако го стартирате само във вътрешната мрежа, той самият няма да има изходящ достъп. api.openai.com е в списъка, защото в тази настройка кодът на агента извиква API от вътрешността на контейнера. Браузърът не се нуждае от него: URL филтърът в следващата секция блокира тези повиквания от страницата.

Филтриране на URL адреси

Втора, по-фин бариера съществува в самия браузър. Чрез прихващане на заявките с page.route, сравнявайте всеки URL със специфичния за задачата списък с позволени (allowlist) – често по-кратък от този на прокси сървъра – и прекъсвайте останалите, с четим запис за всяко блокиране. Внимавайте за капана със сравнението на низове, за който предупреждава OpenAI: https://example.com.evil.test не трябва да минава като https://example.com, и обратно, notexample.com завършва на example.com. Сравнявайте схемата, точния хост (или поддомейн с префикс точка) и порта.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Блокира заявките към неразрешени дестинации."""

    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)


# Браузърът се нуждае само от сайтовете за задачата: API повикванията идват от Вашия Python код, а не от страницата.
setup_url_filter(page, ["example.com"])

Този слой допълва прокси сървъра; не го замества. Playwright отбелязва, че page.route не прихваща заявки, обработвани от service worker, оттук и service_workers="block" в контекста, а WebSocket използват различен механизъм (page.route_web_socket). Мрежовото филтриране остава Вашата основна бариера.

Защита на чувствителни данни

Маскиране на информация в екранни снимки

Всяка екранна снимка отива към API: всичко видимо на екрана напуска Вашата инфраструктура. OpenAI препоръчва да държите удостоверителни данни извън текста на страницата и заснеманията. Ако екранът все пак съдържа чувствителни данни, маскирайте ги, преди да изпратите заснемането на модела. Черен правоъгълник върху известни зони е достатъчен, стига да знаете техните координати – затова стандартизирането на размера на viewport, разгледано по-рано в този курс, помага. Маскирането не променя размера на изображението: координатите, върнати от модела, остават валидни.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Маскира чувствителни зони в 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()

Знание за съдбата на заснеманията

Отговорите на Responses API се съхраняват по подразбиране: това позволява верижност чрез previous_response_id. С store: false, трябва сами да изпратите отново елементи от предишни стъпки. OpenAI също така отбелязва, че store: false не елиминира всички форми на съхранение, а входните изображения имат свои собствени изключения: прочетете техните контроли на данните, преди да изпращате екрани, съдържащи лични данни.

Никога не записвайте чувствителни данни в логове

Същата логика важи и за логовете, които често оцеляват много по-дълго от заснеманията. Филтър за логиране презаписва рисковите шаблони преди записване: присвоявания на пароли, API ключове на OpenAI, започващи с sk-, и 16-цифрени последователности, наподобяващи номера на карти. Филтърът действа върху крайното съобщение, така че улавя и това, което сте записали без да помислите.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Маскира чувствителни данни преди записване на логове."""

    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  # съобщението вече е форматирано: не го форматирайте отново
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # върху handler-а, той вижда и дъщерните logger-и
logging.basicConfig(level=logging.INFO, handlers=[handler])

Два детайла правят разликата. Задаването на record.args на None е от съществено значение: в противен случай вече форматираното съобщение би било форматирано отново с неговите аргументи и всяко % в URL би счупило записването. И филтър върху handler се прилага към всичко, което той записва, докато филтър върху logger игнорира съобщенията от неговите дъщерни logger-и.

Проверки за сигурност на API

Всяко computer_call носи поле pending_safety_checks: списък с проверки за сигурност, които API иска да обработите преди изпълнението на действията, всяко с id, code и message. Официалният пример на OpenAI спира веднага щом той не е празен. Ако Вашето приложение позволява човек да валидира тези случаи, потвърдете ги изрично, като ги върнете в acknowledged_safety_checks, заедно със следващата екранна снимка. Моделът не може да предостави това одобрение от Ваше име, а потвърждението идва преди изпълнението на действието, никога след него.

def valider_verifications(appel) -> list[dict]:
    """Изпраща чакащите проверки на оператор; отказва по подразбиране."""
    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
    ]


# В цикъла, преди изпълнението на действията:
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

Лимити на изпълнение

Съществува и най-честият риск: агент, който излиза от релсите, без да счупи нищо, но работи два часа и изгаря бюджета Ви. Класът ExecutionLimits налага три тавана – брой стъпки, продължителност и оценен разход – и хвърля изключение веднага щом един от тях бъде достигнат. Ставките не са фиксирани в кода: вземете ги от модела, който използвате, от страницата с цени на OpenAI, тъй като те варират според модела.

import time

class ExecutionLimits:
    """Налага тавани за брой стъпки, продължителност и разход на агента."""

    def __init__(
        self,
        prix_entree_par_million: float,  # ставки за използвания модел
        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):
        """Извиква се преди всяка заявка: хвърля грешка, ако е достигнат таван."""
        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):
        """Извиква се след всеки отговор: натрупва стъпки и оценен разход."""
        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

Това е само оценка: тя надценява входните токени, обслужвани от кеша на промпта, които се таксуват с намалена ставка, и игнорира всяка хоствана среда, която се таксува отделно. Сравнявайте я редовно с действителното използване на Вашия проект. Задавайте тавани за работен поток: 30-секунден E2E тест и еднократното въвеждане на фактура от един час не изискват едни и същи прагове.

Контролен списък за сигурност в продукционна среда

Преди да внедрите агент за Computer Use в продукционна среда, проверете:

  • Изолиран браузър или работна среда (контейнер или виртуална машина), непривилегирован потребител
  • Изходяща мрежа, ограничена до сайтовете за задачата и до API, ако цикълът работи в същата среда
  • URL филтър, който сравнява схема, хост и порт; service workers блокирани
  • API ключ, държан извън кода и извън обсега на браузъра (env={})
  • Съдържанието на екрана се третира като недоверено: спиране и ескалация при първи признак на инжектиране
  • Човешко потвърждение преди покупки, изпращания, изтривания и въвеждане на чувствителни данни
  • pending_safety_checks никога не се потвърждават без човешка валидация
  • Лимити за брой стъпки, продължителност и разход
  • Филтрирани логове, заснемания, които не се съхраняват (или са криптирани)
  • Никакви лични файлове, удостоверителни данни или Docker сокет, монтирани в средата
  • Резултатът се проверява в приложението преди обявяване на успех
  • Механизъм за аварийно спиране (kill switch)

Последната точка е тази, която най-често се забравя, въпреки че е единствената, която помага, когато всички други са се провалили. Kill switch е начин за незабавно прекъсване на агента, без да чакате да достигне някой от лимитите си: файл STOP, който цикълът проверява на всяка итерация, docker stop на контейнера или флаг, четен от споделена променлива. Тествайте го преди продукционната среда, а не в деня, в който ще Ви потрябва.

Ключови изводи

  • Четирите правила на OpenAI: ограничете средата, третирайте екрана като недоверен, потвърждавайте действия с високи залози и ограничете и проверете изпълнението
  • Искането на модела за действие не е разрешение: Вашият код изпълнява, спира или връща контрола
  • Изолирайте браузъра (непривилегирован потребител, seccomp профил) и позволявайте изходящ трафик само до сайтовете за задачата
  • Филтрирайте URL адресите, като сравнявате схема, хост и порт – никога чрез прост префикс или суфикс на низ
  • Потвърждавайте pending_safety_checks само след човешка валидация
  • Налагайте лимити за брой стъпки, продължителност и разход и проверявайте действителния резултат