Подробные статьи о технологиях, определяющих будущее.

Утечки секретов AI-агентов: сканирование vs изоляция

Утечки секретов AI-агентов через списки разрешений: сравниваем сканирование секретов и изоляцию, плюс правила, которые блокируют закоммиченные ключи.

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

Исследователи безопасности только что нашли пароли, API-токены и облачные учётные данные в более чем тысяче публичных файлов на GitHub. Причём это не небрежно оставленные .env-файлы, а настройки AI-агентов для написания кода. Виновата тихая схема, связанная с утечками секретов из AI-агентов: разработчик одобряет команду вроде curl -H "Authorization: Bearer sk-...", нажимает «Больше не спрашивать», и вся команда, включая токен, записывается в локальный файл настроек. Закоммитьте этот файл, и секрет становится публичным. Я много лет занимаюсь безопасностью инфраструктуры, и это один из самых предотвратимых классов утечек, с которыми я сталкивался. При этом он действительно новый: файла, который её даёт, ещё два года назад не существовало.

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

Сразу оговорюсь: это не аргумент против агентных инструментов для программирования. Я пользуюсь ими каждый день и уже не вернусь назад. Запрос разрешения, когда агент спрашивает «можно ли запустить это?», один из лучших механизмов безопасности, которые эти инструменты вообще предлагают. Проблема возникает именно после того, как вы сказали «да»: где фиксируется это «да» и что в нём содержится.

Как список разрешений превращается в хранилище секретов

Чтобы понять режим отказа, нужно посмотреть, что именно сохраняет «Больше не спрашивать». Когда агентская CLI просит запустить команду, наивная реализация сохраняет в правиле разрешения всю строку команды целиком. Не шаблон. Не хеш. Буквальную строку, которую вы одобрили.

Поэтому одобрение aws s3 cp s3://bucket/backup.sql . --profile prod безвредно. Но если разработчик одобряет psql postgresql://admin:hunter2@db.internal/myapp или curl -u deploy:APIKEY123 https://.../deploy, учётные данные оказываются в .claude/settings.local.json или в эквивалентном конфиге. Файл настроек задуман как локальный: Claude Code даже автоматически добавляет его в .gitignore, если создаёт файл сам. Но если разработчик создал его вручную, добавил принудительно или в его глобальном gitignore его нет, то один git add . и push, и он на GitHub. Именно эта цепочка стоит за 1 122 файлами, которые нашли исследователи.

Обратите внимание, насколько разумно выглядит каждое звено цепочки по отдельности. Одобрять команду с учётными данными прямо в строке разработчики делали интерактивно десятилетиями без последствий: команда выполняется, история shell хранится локально, никто не переживает. Нажать «Больше не спрашивать» рационально: усталость от запросов реальна, а главная ценность таких агентов в меньшем количестве прерываний. Даже git add . оправдан, если инструмент сказал, что файл локальный. Инцидент вызван не одной небрежной ошибкой. Его вызвала система, в которой пять безобидных действий складываются в публичные учётные данные. Такие провалы самые трудные для исправления, потому что ни один человек не видит, что делает что-то неправильное.

Я видел эту ошибку в дикой природе ещё до появления агентов. Тимлид одного финтеха, с которым я консультировал, держал allowed_commands.sh для CI-бота: та же идея, только написанная вручную. Кто-то одобрил разовую команду миграции базы с DSN прямо в строке. Через полгода репозиторий открыли, и DSN оказался в истории git файла, который никто не догадался проверить, потому что он «не был конфигом». Это был конфиг. Просто он не выглядел как конфиг.

В этом суть: списки разрешений — это конфигурационные файлы, которые побочно захватывают операционные секреты. Никто не проверяет их на секреты, потому что никто не считает их содержащими секреты. Ваша политика управления секретами охватывает .env, credentials.yml, возможно, состояние Terraform. Почти наверняка она не покрывает .claude/settings.local.json или конфиги в .cursor/. Похожее слепое пятно мы разбирали в тексте о аудите API-клиентов как хранилищ учётных данных: инструменты, которыми вы пользуетесь каждый день, накапливают секреты в местах, которые ваша политика даже не упоминает.

А категория растёт. Каждый агентный инструмент, запущенный за последние пару лет, имеет какую-то вариацию: списки разрешений, доверенные директории, запомненные одобрения, конфиги MCP-серверов с токенами в открытом виде. Каждый из них создаёт новый путь к файлу, о котором не упоминают ваши политики, .gitignore и конфиги сканеров. Следующая версия этого инцидента будет той же ошибкой, только в файле с другим именем.

Сканирование секретов против изоляции: две защиты

Вот сравнение, которое я буду проходить по ходу текста:

  • Сначала обнаружение (сканирование секретов): pre-commit хуки, сканеры репозиториев вроде gitleaks и trufflehog, push-защита от GitHub или GitLab, а также периодическое сканирование истории. Исходим из того, что секреты утекут; ловим их быстро и перевыпускаем.
  • Сначала изоляция (держим секреты вне): секреты попадают в команды только через переменные окружения, CLI менеджеров паролей или короткоживущие учётные данные; агенты работают в песочницах или эфемерных VM; локальные файлы настроек глобально исключены из git. Система спроектирована так, чтобы утекать было нечему.

Обнаружение — это операция по уборке. Изоляция — это свойство дизайна. Они ломаются в противоположных направлениях: сканирование даёт ложноотрицательные срабатывания и всегда работает постфактум; изоляция требует затрат на внедрение и конфликтует с удобством разработчика. Какая из них выигрывает, зависит от того, какой режим отказа вы можете допустить.

Есть и асимметрия в том, как они деградируют со временем. Сканирование деградирует мягко: пропущенный секрет — это плохо, но уже найденные по-прежнему ловятся, а наборы правил улучшаются. Изоляция деградирует через исключения. Каждый раз, когда разработчик обходит трение («в этот раз вставлю токен напрямую, ничего страшного»), свойство ослабевает, и журнала этого ослабления не остаётся. Вы узнаёте, что изоляция дала сбой, так же, как узнаёте, что замок остался открытым: когда кто-то проверит. Поэтому эти две защиты стоит использовать вместе, а не как конкурентов, но и весят они для меня по-разному. В следующем разделе объясняется, почему сканирование, несмотря на то что оно ответ индустрии по умолчанию, для этого класса утечек слабее из двух.

Сканирование секретов: сильные стороны и жёсткие ограничения

Сканирование побеждает, когда утечка уже случилась или вот-вот случится, а учитывая человеческую природу, так бывает нередко. Push-защита GitHub блокирует известные форматы токенов в момент push. gitleaks в pre-commit хуке ловит удивительно много до того, как код покинет ноутбук. Если из этой статьи вы сделаете только одно, сделайте это:

# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks

Десять минут настройки, и конкретный класс утечек из этой истории, токен в закоммиченном файле настроек, в основном исчезает, потому что gitleaks не волнует, что файл является JSON-настройками. Он сканирует содержимое, а не имена файлов. Если у вас есть внутренние префиксы токенов, добавьте для них регулярное выражение.

Есть ещё один слой, который команды часто забывают: периодическое сканирование вашей собственной локальной машины на незакоммиченные секреты. Хуки уровня репозитория срабатывают только при коммите или push. Файл настроек, который лежит на диске три месяца, прежде чем кто-то выполнит git add ., это трёхмесячное окно, в течение которого секрет находится в одной команде от публичного доступа. Запланированная задача, даже еженедельный cron, который прогоняет gitleaks по dotfiles в домашнем каталоге, сокращает это окно до нескольких дней. Выглядит неказисто, но работает.

Но у сканирования есть три жёстких ограничения, которые история с Claude Code хорошо вскрывает. Во-первых, детекторы на основе энтропии пропускают секреты с низкой энтропией. Пароль вроде Winter2024! в строке подключения psql не вызовет проверку энтропии, а если это не известный формат провайдера, ни одно правило не сработает. Исследователи нашли много обычных паролей, а не только ключи в стиле AWS. Во-вторых, сканирование работает постфактум на уровне push. Push-защита останавливает push, и это здорово, но если она не сработала, секрет уже в истории, а история вечна. Ротация после утечки означает поиск каждого места, где использовались учётные данные, и я ни разу не видел, чтобы такая уборка занимала меньше дня. В-третьих, сканирование создаёт ложное ощущение полноты. Команды видят зелёную галочку и перестают думать о том, как вообще текут секреты. Как мы уже писали в тексте об AI-сканерах безопасности, сканер это страховочная сетка, а не замена тому, чтобы не падать.

Что касается второго пункта: стоит точно понимать, что на самом деле включает «уборка», когда учётные данные попадают в публичный репозиторий. Команды систематически её недооценивают. Ротация это простая часть: отзываете токен, выпускаете новый, обновляете хранилище секретов. Трудная часть это археология: каждый конвейер деплоя, cron-задачу, ноутбук разработчика и стороннюю интеграцию, которые использовали старые учётные данные, нужно найти и обновить, а пропущенная означает простой в самый неудачный момент. Есть и зеркальная проблема: если репозиторий публичный, нужно считать, что секрет собрали за считанные минуты. Боты, охотящиеся за учётными данными, непрерывно следят за потоком событий GitHub. К моменту, когда ваш сканер поднимет тревогу, секрет, скорее всего, уже скопирован, проиндексирован и, возможно, опробован на ваших боевых эндпоинтах. Обнаружение дало вам осведомлённость, но безопасности не дало.

При этом я хочу быть справедливым к сканированию, потому что в таких спорах его слишком легко отвергают. Для крупных организаций с сотнями репозиториев и тысячами разработчиков сканирование единственный слой, который масштабируется без изменения поведения. На таком масштабе нельзя обучением выйти из утечки, а вот push-защитой можно закрыть большую её часть. Если вы в платформенной команде и решаете, куда потратить первую неделю усилий, ответ сканирование: оно дешёвое, централизованное и ловит высокоэнтропийные токены провайдеров, которые наносят больше всего вреда. Только не принимайте его за полное решение.

Рыболовная сеть с крупными ячейками, которую тянут из тёмной воды: большая часть светящихся рыб уходит через прорехи, а несколько остаются в сетке
Сканирование ловит секреты, которые распознаёт: пароли с низкой энтропией и новые форматы проскальзывают мимо.

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

Изоляция побеждает везде, где секрет иначе был бы записан, и именно здесь живёт этот инцидент. Если учётные данные никогда не появляются в команде как буквальная строка, в списке разрешений просто нечему опасному храниться. Одобренная команда становится curl -H "Authorization: Bearer $DEPLOY_TOKEN" ..., а файл настроек содержит безобидное имя переменной. Два правила покрывают большую часть случаев:

  • Секреты попадают в команды только через переменные окружения или косвенную ссылку ($TOKEN, $(op read ...), конфиг-файл, который агент читает во время работы), но никогда как буквальные значения.
  • Локальные каталоги конфигурации агентов (.claude/, .cursor/, .aider*) добавляйте в глобальный gitignore машины (~/.config/git/ignore), а не только в gitignore отдельного репозитория, чтобы ни один проект не смог их закоммитить.
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF

Почему глобально, а не в каждом репозитории? Две причины. Во-первых, gitignore на уровне репозитория работает, только если кто-то помнит добавить его в каждый новый репозиторий, а новые репозитории создают как раз тогда, когда никто не думает о гигиене безопасности. Во-вторых, глобальный gitignore это политика машины, а не проекта: его нельзя случайно удалить в pull request, который «чистит gitignore», а я такое действительно видел. Репозиторный вариант защищает репозиторий. Глобальный защищает разработчика, а разработчик здесь и есть единица, склонная к утечкам.

Правило с переменными окружения заслуживает такой же проверки, потому что у него есть коварный режим отказа: профили shell. Если разработчик «решает» требование к переменной, выполнив в .bashrc export DEPLOY_TOKEN=sk-..., вы просто перенесли секрет из одного непроверенного dotfile в другой. Правило должно упираться в настоящее хранилище секретов: 1Password CLI, direnv, читающий зашифрованное хранилище, или облачный менеджер секретов с aws ssm или op inject при старте сессии. Агент получает переменную, а диск никогда не получает значение. Это одна лишняя косвенность, и именно она отличает изоляцию от косметики.

Более сильная версия изоляции это то, что я называю настоящей песочницей: запускать агента в эфемерной VM или контейнере на каждую задачу, в изолированной сети, с прокси перед внешними API. Мне нравится одна практическая схема, где между агентом и SaaS-ключом с полными правами стоит API-прокси: чтение проходит свободно, а запись требует подтверждения на телефоне. Это эшелонированная защита, сделанная правильно: даже полностью скомпрометированный агент с --dangerously-skip-permissions может трогать только то, что разрешает прокси. Более широкий компромисс мы разбирали в тексте о изоляции и мониторинге AI-агентов; эта история аргумент в пользу изоляции.

Короткоживущие учётные данные это вторая половина сильной версии, и их недооценивают, потому что они уменьшают радиус поражения, даже когда сломаны все остальные слои. Статический ключ доступа AWS, утёкший на GitHub, действителен, пока кто-то его не заметит. Учётные данные OIDC с TTL в один час, утёкшие на GitHub, это просто запись в логе. Если ваш облачный провайдер поддерживает федерацию workload identity, а все крупные поддерживают, учётные данные агента должны истекать быстрее, чем процесс реагирования на инциденты успевает собрать совещание.

Честная цена изоляции это трение. CLI менеджеров паролей означают запросы отпечатка пальца посреди задачи. Эфемерные VM требуют времени на настройку и добавляют задержку холодного старта при каждом запуске. Прокси с ограниченными правами требуют, чтобы кто-то его писал и поддерживал. Для соло-разработчика в личном проекте полноценная песочница перебор, и вариант «глобальный gitignore плюс переменные окружения» правильный выбор. Для команды, чьи агенты работают с боевыми учётными данными, трение это цена того, чтобы не стать следующим раскрытым нарушением.

Средний уровень: исправляем сам список разрешений

Есть третий вариант, который контролируют не вы, а вендоры инструментов: не сохранять буквальную команду. Правило разрешения, которое хранит curl -H "Authorization: Bearer *" как шаблон с замаскированными значениями аргументов, так же удобно для сопоставления и не содержит секрета. Команда Claude Code заявляла, что изучает предотвращение именно этого класса проблем, а их рекомендуемое направление это режим автоматических разрешений, который вообще не требует поддерживать списки allow/deny. Это правильная интуиция. Каждый вручную поддерживаемый список разрешений это будущий инцидент с временной меткой, которую вы пока не видите.

Впрочем, сопоставление по шаблону не бесплатный обед. Маска вроде curl * одинаково хорошо подходит и для безобидной команды деплоя, и для вредоносной команды экспорта данных, так что агрессивная маскировка меняет риск утечки на риск слишком широкого одобрения. Правильный дизайн, вероятно, структурный, а не текстовый: сохранять, какой бинарник и какие флаги были одобрены, но никогда не значения аргументов. Так сопоставление остаётся точным (да для curl с заголовками, нет для curl, отправляющего данные на новый домен), и ничего не сохраняется там, где может спрятаться учётные данные. Вендоры к этому придут; стимул теперь больше тысячи публичных файлов в качестве доказательств.

Пока вендоры этого не сделали, можно приблизиться к решению с помощью гигиены: периодически запускать сканер по самим локальным файлам настроек. Однострочник вроде gitleaks detect --no-git --source ~/.claude .claude проверяет именно те файлы, о которых эта история, до того как они окажутся рядом с репозиторием. Добавьте это в скрипт настройки dotfiles, и это ничего не стоит.

Моя рекомендация: изоляция по умолчанию, сканирование как сетка

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

Конкретно, для команды, которая внедряет агентные инструменты для программирования в этом квартале, по возрастанию трудозатрат:

  1. Глобальный gitignore для каталогов конфигурации агентов на каждой машине разработчика: пять минут, полностью убирает утечку через закоммиченные настройки.
  2. Правило: секреты только через переменные окружения или CLI менеджера паролей, никогда не в строке команды. Запишите это в онбординг, а не в вики, которую никто не читает.
  3. gitleaks как pre-commit хук плюс push-защита на платформе хранения кода: страховочная сетка для всего вышеперечисленного.
  4. Короткоживущие, ограниченные по правам учётные данные для всего, к чему прикасается агент (облачные учётные данные через OIDC вместо статических ключей), чтобы утечка истекала за часы.
  5. Для агентов с доступом к продакшену: эфемерная песочница плюс API-прокси, который ограничивает то, что могут делать учётные данные агента.

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

Крепостная стена с небольшими воротами, за которой стоит вторая внутренняя стена и запертое хранилище в центре
Эшелонированная изоляция: даже если внешняя стена падает, в хранилище нет ничего статичного, что стоило бы украсть.

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

Обновите политику. Агенты никуда не денутся, как и кнопка «Больше не спрашивать».