Как сделать так, чтобы секреты не утекали: дуэт Secret Manager и сканера. codescoring.. codescoring. deckhouse.. codescoring. deckhouse. deckhouse stronghold.. codescoring. deckhouse. deckhouse stronghold. DevOps.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management. Блог компании CodeScoring.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management. Блог компании CodeScoring. Блог компании Флант.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management. Блог компании CodeScoring. Блог компании Флант. Информационная безопасность.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management. Блог компании CodeScoring. Блог компании Флант. Информационная безопасность. секреты.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management. Блог компании CodeScoring. Блог компании Флант. Информационная безопасность. секреты. Системное администрирование.. codescoring. deckhouse. deckhouse stronghold. DevOps. DevSecOps. gitleaks. hashicorp vault. secret management. Блог компании CodeScoring. Блог компании Флант. Информационная безопасность. секреты. Системное администрирование. утечка секретов.

TL;DR: Находить утекшие секреты в коде важно, но это лишь реакция на уже случившийся инцидент. В этой статье мы показываем, как перейти от «тушения пожаров» к системной защите. Разбираем жизненный цикл секрета по этапам, находим точки, где чаще всего происходят сбои, и показываем, как органично связать Secret Manager и автоматизированный сканер, чтобы ключи перестали попадать наружу в принципе.

Почему тушение пожаров не тушит пожары до конца

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

Через месяц всё повторяется: другой разработчик спешит с хотфиксом, подкладывает временный credential в .env, забывает добавить его в .gitignore — и токен снова улетает на GitHub или во внутренний GitLab.

В одной из предыдущих статей мы подробно разбирали способы потери секретов: почему разработчики с завидным упорством продолжают коммитить секреты, как боты парсят ключи за 2–3 минуты и почему один забытый токен приводит к катастрофам уровня Trivy или Code Spaces.

Всем привет! Я Натан, техлид модуля Secrets в CodeScoring. В этой статье разберу жизненный цикл секрета по четырём этапам, покажу, где именно ломаются процессы, и дам рабочие архитектурные связки, которые можно внедрить у себя.

Как сделать так, чтобы секреты не утекали: дуэт Secret Manager и сканера - 1

Жизнь и смерть секрета

Главная причина, по которой секреты продолжают утекать, заключается в том, что к ним часто относятся как к статичным текстовым константам. На самом деле секрет — это живая сущность, у которой есть свой жизненный цикл.

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

Представим жизненный цикл секрета так:

  1. Создание и генерация.

  2. Хранение.

  3. Использование.

  4. Ротация/уничтожение.

Рассмотрим реальный пример. Команда разработки микросервисов решила внедрить интеграцию с новым платёжным шлюзом. Разработчик зашёл в личный кабинет провайдера, сгенерировал статический API-ключ со сроком действия на 5 лет, скопировал его в текстовый файл и отправил в мессенджере коллегам. Затем этот ключ попал в CI-конфиг, пролежал там год, а при увольнении одного из инженеров остался валидным.

Где произошел сбой? На каждом из этапов.

Этап 1. Создание и генерация секретов

На этапе генерации закладываются базовые параметры безопасности: срок жизни ключа (TTL) и область его прав (Scope). Если сгенерировать статический токен вручную, дать ему избыточные права на несколько лет и сохранить в блокноте, вы закладываете уязвимость в саму основу — и её потом не исправить никакими сканерами.

Какие проблемы и ошибки могут происходить на этом этапе: 

  • Секреты создаются вручную. Полное отсутствие прозрачности для ИБ. Такие ключи не фиксируются в централизованных системах, и о них никто не вспоминает до момента внезапной утечки. 

  • Имеют неограниченный или слишком длинный срок жизни (TTL). Ключ продолжает работать годами (как в известном кейсе Toyota), превращаясь в ружьё, которое непременно выстрелит. Чем дольше живёт статический токен — тем больше людей и систем получают к нему доступ, тем выше шанс, что он утечёт.

  • Обладают избыточными правами (Superuser вместо ограниченной роли). Злоумышленник при компрометации получает полный контроль над всей инфраструктурой или базой данных вместо доступа к одному конкретному микросервису.

  • Разработчики генерируют ключи под своими личными учётными записями. После увольнения или перехода сотрудника в другой проект такие токены часто «забываются» и остаются активными. 

  • Использование дефолтных или слабоэнтропийных паролей в dev-окружении («потом поменяем на prod’е»). На практике «потом» не наступает никогда: dev-пароли часто совпадают со стейджингом. Плюс слабые пароли типа admin123 или password брутфорсятся за секунды.

  • Разработчики генерируют персональные ключи к OpenAI / Hugging Face и сохраняют их в локальные конфигурационные файлы mcp.json или .env без контроля со стороны ИБ. Такие файлы часто утекают через репозитории или становятся уязвимы для атак типа Prompt Injection, открывая доступ к корпоративным ИИ-ресурсам и бюджетам. 

Как можно избежать этих проблем:

Можно использовать динамические секреты (Dynamic Secrets). Суть: отказываемся от мысли, что пароль должен быть постоянным. Вместо этого договариваемся, что он создаётся на лету, живет ровно столько, сколько нужно для задачи (например, 1 час), и умирает.

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

Таким центральным пунктом могут быть, например, Deckhouse Stronghold или HashiCorp Vault. Это специализированные системы управления секретами: они выдают ключи по запросу, автоматически их ротируют и создают временные доступы, снижая риски утечек.

То есть подобные системы берут на себя роль единого центра генерации временных credentials с минимально необходимыми правами (Least Privilege). 

Но правила часто нарушаются, и кто-то из разработчиков по старой привычке может попытаться сгенерировать токен вручную и захардкодить его в проекте. Поэтому нельзя всецело полагаться на установленные правила. Чтобы и в таком случае всё было под контролем, советую использовать сканер секретов, например CodeScoring.Secrets или Gitleaks. Подобные решения ещё на этапе Git commit или Pull Request перехватят секреты и спасут от утечки. 

Этап 2. Хранение и разграничение доступа

Секрет создан. Где он дожидается своего использования? Часто — где угодно. Например, секреты хранят в приватных Git-репозиториях или корпоративных Wiki/KeePass-файлах с общим паролем в Telegram-чате. Как показал кейс «Яндекса», даже закрытый внутренний монорепозиторий перестаёт быть безопасным местом, если в нём лежат захардкоженные тестовые и сервисные креды.

А доступы к секретам в RAG-системах и ИИ-контекстах? Например, в компании может быть корпоративный ИИ-помощник (чат-бот), который умеет читать внутренние документы компании по типу Wiki, чтобы отвечать на вопросы сотрудников. Разработчик по ошибке может вставить API-ключ или пароль в тикет или в техническую документацию. ИИ проиндексирует этот документ и «запомнит» секрет как часть базы знаний. Любой сотрудник с помощью правильно сформулированного промпта может извлечь чужие права доступа.

Другие частые ошибки:

  • Хранение в незашифрованном виде. Например, дамп базы или экспорт из KeePass лежит на расшаренном сетевом диске или в облаке без шифрования, и любой, кто получил доступ к папке, сразу видит все пароли.

  • Раздача прав «всем членам команды». Увеличиваем поверхность атаки: если один сотрудник теряет ключ, то у злоумышленника появляется доступ сразу ко всей инфраструктуре.

  • Отсутствие аудита доступа. В случае инцидента ИБ-служба не сможет определить точку утечки, быстро оценить масштаб компрометации и узнать, успел ли атакующий воспользоваться ключом до его отзыва. 

Что можно сделать, чтобы избежать проблем:

  • Secret Manager (SM): использование специализированных хранилищ с шифрованием на диске (Encryption at Rest) и строгим RBAC/ABAC (Access Control). Вот как раз Deckhouse Stronghold и является таким менеджером секретов. На этом этапе он выступает в роли защищённого «сейфа», исключающего хранение секретов в коде или мессенджерах. Приложение не хранит секрет у себя в .env или конфиге. В момент запуска (или по мере необходимости) оно стучится в API хранилища, аутентифицируется и получает секрет напрямую в оперативную память. Через это хранилище мы также навязываем строгие правила: кто, когда и к каким данным имеет доступ.

  • Data Loss Prevention (DLP) и Secret Detection: использование автоматизированных сканеров (например, CodeScoring.Secrets) для непрерывного поиска секретов там, где их быть не должно (в исходном коде, истории Git, логах CI/CD, бинарниках и Pull Request’ах), с возможностью блокировки на входе (pre-commit хуки, CI-гейты) и оперативного реагирования на инциденты. 

Как они помогают в связке: Secret Manager централизованно хранит и защищает секреты, а Secret Detection непрерывно сканирует всю инфраструктуру и находит ключи, которые случайно «протекли» мимо Secret Manager из-за невнимательности человека.

Этап 3. Использование и передача (Runtime & CI/CD)

Этап, на котором секрет покидает хранилище, то есть безопасный контур, и попадает в среду исполнения (Runtime) или процессы сборки. 

Вот такие ошибки чаще всего допускаются здесь: 

  • Передача секретов в открытом виде по сети. Пересылка кредов между микросервисами или компонентами инфраструктуры без использования шифрования (TLS/HTTPS) или по незащищённым внутренним каналам. Если злоумышленник сумеет закрепиться во внутренней сети или перехватить трафик (например, через MITM-атаку), он получит готовые токены в чистом виде. 

  • Подстановка в параметры командной строки. Передача паролей или токенов через прямые аргументы при запуске процессов (например, ./app --api-token=secret_xyz). Такие параметры сохраняются в истории терминала, видны всем пользователям системы через стандартный мониторинг процессов (ps aux) и неизбежно попадают в дампы памяти при падении приложения (core dumps).

  • Логирование. Банальная опечатка в bash-скрипте вроде echo $SECRET_KEY или падение пайплайна с детальным трейсбэком, который выводит весь массив переменных окружения. Вся эта информация улетает в системы логирования (GitLab CI/CD logs, Jenkins, ELK), доступ к которым часто имеет не только команда разработки, но и широкие круги смежных специалистов. 

  • Запекание в артефакты сборки. Ошибка при создании Docker-образов вроде инструкции COPY . ., когда локальный .env-файл или конфигурация попадают внутрь контейнера. Даже если в следующем слое разработчик напишет RUN rm .env, секрет никуда не исчезнет — он навсегда останется в истории слоёв Docker-образа.

# НЕПРАВИЛЬНО: секрет попадает в слой образа.

COPY . . # Копируем всё «под ногами» в контейнер — забрали секрет к себе в слой

RUN build.sh

# ПРАВИЛЬНО: использование BuildKit Secrets без сохранения в слоях.

COPY build.sh . # Копируем только наш скрипт.

RUN --mount=type=secret,id=my_secret ./build.sh # Запускаем наш скрипт, монтируя my_secret (который мы предварительно передали при вызове сборки данного Dockerfile) в /run/secrets/my_secret. Такой секрет не останется в слоях и будет доступен только при сборке контейнера.

Здесь тоже можно пойти двумя путями ​​(и, как обычно, лучше комбинировать):

In-Memory Injection (доставка секретов в память)

Это подход, при котором секрет никогда не записывается на диск, что исключает его кражу через чтение файлов или историю слоёв Docker.

Как это работает на практике? Механизмы доставки зависят от инфраструктуры:

  • В Kubernetes: реализуется через модуль secrets-store-integration. Он работает как CSI-драйвер и монтирует секреты напрямую в оперативную память пода (через tmpfs) или инжектирует их как переменные окружения, не касаясь диска узла.

  • На виртуальных машинах: где нет встроенной поддержки работы с системами управления секретами, используется Stronghold Agent. Он аутентифицируется в хранилище, получает секрет и безопасно передаёт его напрямую в переменные окружения (ENV vars) запускаемого процесса.

Например, для PKI-сертификатов Stronghold выдаёт эфемерный сертификат, который хранится только в памяти приложения с момента его запуска и удаляется при завершении работы, никогда не касаясь диска. Для legacy-приложений агент может автоматически подставить credentials в ENV, не требуя изменений в коде (например, в Spring Boot).

Secret Masking (маскирование в логах)

Даже если секрет доставлен безопасно, разработчик может по ошибке вывести его в лог (например, добавив echo $MY_SECRET для отладки или из-за падения пайплайна с дампом переменных окружения). Здесь в игру вступает сканер — CodeScoring.Secrets.

Как это работает на практике?

Он сканирует исходники и логи пайплайна — как часть CI/CD или по графику — на наличие секретов, чтобы перехватить ошибки до того, как они станут доступны посторонним. Забытый echo, опечатка в bash-скрипте, нестандартный формат вывода или трейсбэк при падении приложения — всё это ловится автоматически.

Дополнительный уровень защиты — маскирование на уровне самих CI/CD-раннеров и программ, которые они запускают. Это не магия какой-то отдельной «волшебной» системы, а настройка (например, встроенные функции маскирования переменных в GitLab CI). Если приложение попытается вывести чувствительные данные в лог при сбое, раннер автоматически затрёт их, не давая токенам «улететь» в системы агрегации логов.

В связке эти два механизма создают надёжную страховку.

Этап 4. Ротация и отзыв (Rotation & Revocation)

Завершающий этап жизненного цикла, о котором вспоминают реже всего. Пока секрет работает, его не трогают. А когда перестаёт работать — уже поздно.

В чём проблема. Большинство команд относятся к секретам как к статичным константам: один раз создали, вписали в конфиг — и забыли. Ключи живут годами, потому что «работает — не трогай». Ротация воспринимается как болезненная операция: нужно менять конфиги, перезапускать сервисы, пересобирать образы, молиться, что ничего не упадёт. Поэтому её откладывают до последнего — то есть до инцидента.

Дополнительная слепая зона — сервисные токены. Когда сотрудник увольняется, его доступ в IAM отзывают за пять минут. Но все API-ключи, которые он когда-либо генерировал от своего имени для CI/CD, скриптов, интеграций с внешними сервисами, остаются активными. Формально человека в компании уже нет, а его «цифровой призрак» продолжает иметь доступ к инфраструктуре.

Вернемся к кейсу Toyota, когда ключ доступа к внутренним системам пролежал в открытом GitHub-репозитории пять лет. Виноват не только разработчик, который его туда положил. Виновата архитектура, в которой не было механизма автоматической ротации: ключ не протухал, не отзывался, не пересоздавался. Пять лет окно было открыто.

Здесь работают два принципа, которые нужно внедрять вместе.

Принцип 1. Автоматическая ротация (Automated Rotation) через механизм аренды (Lease)

Когда для каждого динамического секрета создаётся аренда (lease). Это метаданные, которые содержат срок действия (TTL) и информацию о возможности продления. Этот принцип используется в Deckhouse Stronghold.

Как это работает на практике? Приложение или скрипт должны регулярно связываться со Stronghold, чтобы продлить аренду или запросить новый секрет до истечения TTL. Это гарантирует, что ключи регулярно обновляются, а журналы аудита остаются актуальными. Если срок аренды истекает, Stronghold автоматически аннулирует данные, и потребитель больше не может быть уверен в их актуальности.

Пример — механизм секретов PKI (Public Key Infrastructure). Вместо ручного создания закрытого ключа, подачи CSR в удостоверяющий центр и ожидания подписания, приложение запрашивает сертификат у Stronghold по заранее настроенной роли.

  • Stronghold мгновенно выдаёт динамически сгенерированный сертификат и закрытый ключ с заданным TTL (например, max_ttl=72h).

  • Если поддерживать TTL коротким, каждый экземпляр приложения может получать уникальный эфемерный сертификат.

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

Принцип 2. Emergency Revocation, или «красная кнопка»

Это возможность мгновенно отозвать скомпрометированный токен во всей инфраструктуре одним действием.

Как это работает? Аренда может быть отменена (отозвана) вручную через API, с помощью команды, через веб-интерфейс или автоматически. Когда аренда отзывается, секрет сразу же становится недействительным и не подлежит дальнейшему продлению. Более того, при отзыве токена Stronghold автоматически отзывает все аренды, которые были созданы с его помощью, что позволяет точечно и быстро купировать угрозу.

На этом этапе отлично сработает связка CodeScoring.Secrets и Stronghold. Последний берёт на себя рутину ротации: он сам перевыпускает токены по расписанию, раздаёт новые версии подключённым сервисам и отзывает старые — без участия человека. Разработчикам не нужно помнить, что «пора бы поменять ключ», и не нужно бояться, что что-то упадёт.

И если CodeScoring.Secrets фиксирует факт утечки токена (например, в публичном коммите или внешнем PR), система может инициировать автоматический отзыв (Revocation Webhook) через API Stronghold, ликвидируя угрозу до того, как ею успеют воспользоваться боты.

Проблема «забытых» секретов

Помимо ротации, есть целый пласт «забытых» секретов, которые живут своей жизнью. Токен для публикации npm-пакета, который разработчик положил в ~/.npmrc в личном форке на домашнем GitHub. Сервисный аккаунт, созданный под конкретный эксперимент три года назад и забытый. Ключ от S3, который когда-то скопировали в Slack для быстрого теста и который до сих пор валиден. 

Всё это следы отсутствия ротации и централизованного управления. Deckhouse Stronghold такие токены просто не даёт создать в принципе (потому что всё идёт через него), а CodeScoring.Secrets вылавливает те, что всё-таки просочились наружу.

Как обезопасить себя на каждом шаге

Чтобы перестроить работу с секретами и жить спокойно, действуйте поэтапно. Не нужно сразу прыгать к «динамическим секретам с коротким TTL», минуя аудит и Secret Manager. Ниже — проверенная на практике последовательность шагов и набор правил, которые помогают не откатиться назад.

  1. Тотальный аудит существующего кода. Прежде чем внедрять новые процессы, нужно понять масштаб бедствия. Просканируйте все внутренние репозитории, включая историю коммитов, ветки и артефакты. Используйте специализированные инструменты (CodeScoring.Secrets, Gitleaks). Всё, что нашлось, отзовите и перевыпустите (не ограничивайтесь чисткой истории!).

  2. Внедрение защиты на входе (Shift-Left). После аудита нужно отсечь саму возможность появления новых секретов в коде. Советую разработчикам установить pre-commit-хуки и встроить сканирование секретов в CI/CD-пайплайны. Секрет не должен попадать в ветку main или удалённый репозиторий в принципе.

  3. Внедрение хранилища секретов (Secret Manager). Сканер — это контроль, но разработчику нужно дать удобную альтернативу .env-файлам. Вынесите все пароли, API-ключи и сертификаты из .env-файлов и конфигураций в централизованный Secret Manager (Stronghold / HashiCorp Vault). Так приложение больше не будет хранить секреты у себя: оно будет получать их по API в момент запуска. 

  4. Переход на динамические секреты и регулярную ротацию. Когда Secret Manager уже работает, можно двигаться дальше — отказываться от статических ключей в пользу динамических. Настройте короткий TTL для временных ключей и автоматизируйте смену статических credentials. Идея в том, чтобы даже в случае утечки окно, в течение которого токен остаётся валидным, было минимальным.

Рекомендации из личного опыта

  • Правило «Внутренний репозиторий = публичный репозиторий». Относитесь к вашему on-premise GitLab так же, как к открытому GitHub. Внутренние утечки происходят регулярно — через компрометацию учётных записей, подрядчиков или утечки бэкапов.

  • Не надейтесь на ревьюера. При код-ревью человек ищет ошибки в бизнес-логике и архитектуре. Проверка на наличие захардкоженных строк должна быть на 100 % передана автоматизированным утилитам.

  • Ограничивайте область действия (Scope) ключей. Если сервису нужен доступ к одной таблице в БД, не давайте ему токен администратора всей СУБД. Ущерб от утечки токена с ограниченными правами в разы ниже.

  • Запреты в промптах ИИ не являются техническим барьером. Инструкция «не смотри в .env» в системном промпте LLM-ассистента работает до первого переполнения контекста или Prompt Injection-атаки. Изолируйте доступ ИИ к секретам на уровне инфраструктуры.

  • Проверяйте репозитории после чистки. После удаления секрета с помощью git-filter-repo или BFG Repo-Cleaner обязательно убедитесь, что в актуальном рабочем дереве (последний коммит) не осталось файлов-дубликатов, иначе продуктовая развёртка сломается или секрет вернётся следующим коммитом.

Замкнутый контур: почему одного инструмента недостаточно

Частый вопрос, который возникает у CISO и DevSecOps-инженеров: «Зачем нам сканер секретов, если мы уже поставили HashiCorp Vault или Stronghold?» Или наоборот: «Зачем нам Secret Manager, если мы сканируем код?»

Правда в том, что эти решения ещё эффективнее работают в связке. Давайте на примере. Представьте, что в компании стоит Deckhouse Stronghold. Разработчики получают секреты через API, динамические токены ротируются, всё красиво. Но однажды джун, разбираясь с локальным багом, копирует токен из консоли в .env, чтобы «быстренько проверить», — и случайно коммитит его в ветку. Токен улетает в Git, а дальше — по классическому сценарию с ботами-парсерами.

Теперь обратная ситуация: стоит CodeScoring.Secrets, сканер ловит все коммиты с секретами на лету. Но разработчик всё равно вынужден где-то брать эти секреты — и берёт их из .env-файлов, разбросанных по репозиториям, из общих чатов или из KeePass с паролем в Telegram. Сканер ловит утечки, но не устраняет их причину: у команды просто нет удобного и безопасного места, откуда секреты можно было бы легально получать.

Получается, что Deckhouse Stronghold (как Secret Manager) и CodeScoring.Secrets (как Secret Detection) — это не конкурирующие решения, а два крыла одной системы:

  • Stronghold обеспечивает идеальное «целевое состояние»: он исключает необходимость хардкодить секреты, централизованно хранит credentials, раздаёт динамические токены и контролирует их срок жизни.

  • CodeScoring.Secrets обеспечивает непрерывный контроль фактического состояния. Человеческий фактор исключить невозможно: разработчик может забыть подключить сервис к Stronghold, скопировать токен из консоли в локальный скрипт для отладки или случайно распечатать его в логах CI/CD.

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

Как сделать так, чтобы секреты не утекали: дуэт Secret Manager и сканера - 2

Когда CodeScoring.Secrets обнаруживает незащищённый токен на этапе Git-коммита, в Pull Request или истории репозитория, он блокирует сборку, а Stronghold аннулирует (Revocation) скомпрометированный ключ.

В результате вы получаете замкнутый безопасный контур: Stronghold не даёт поводов хардкодить секреты, а CodeScoring.Secrets гарантирует, что если ошибка всё же произошла, то она не приведёт к катастрофе.

Хотите собрать такой замкнутый контур у себя? Вот ссылки на продукты: CodeScoring.Secrets и Deckhouse Stronghold.

В итоге

Для защиты секретов недостаточно разовой «чистки» репозиториев и установки сканера. Тут необходим системный подход, который включает в себя правильную архитектуру хранения, автоматические проверки на каждом этапе CI/CD и понятный план действий при инциденте.

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

Что ещё почитать в наших блогах:

Автор: nouhadonosor

Источник