# Lagune > Security-Driven Hardening для любой кодовой базы Lagune представляет собой открытый процесс Security-Driven Hardening (SDH), ориентированный только на защиту. Он помогает вашему ИИ-агенту усилить защиту любой кодовой базы на любом языке в любой момент: charter задает правила безопасности еще до разработки, универсальная команда /lagune усиливает защиту кода прямо во время написания, а пятифазный процесс Blue Team выявляет, что на самом деле делает ваша система, и ведет исправления, важные в этом контексте. Его команды устанавливаются в агент через CLI skills, и ему не нужен API-ключ. --- # Установка: усиление безопасности для любого ИИ-агента > Установите Lagune в любой проект как плагин, если ваш агент их поддерживает, или через CLI skills в остальных случаях, а затем выберите подходящие специализации по безопасности. Канонический URL: https://lagune.ai/ru-RU/docs Язык: ru-RU Оригинал: https://lagune.ai/docs Последнее обновление: 2026-11-03 **Lagune** помогает вашему ИИ-агенту сделать проект безопаснее. Вы указываете на свой код, агент разбирается, что на самом деле делает ваша система, а затем ведет вас через ту работу по безопасности, которая для нее важна. **Lagune** является первым проектом методологии [Security-Driven Hardening (SDH)](https://lagune.ai/ru-RU/docs/references/paper). **Поддержите открытый код** Нравится **Lagune**? [Поставьте нам ⭐ на **GitHub**](https://github.com/wellwelwel/lagune) ## Выберите агента - [Claude Code](https://lagune.ai/ru-RU/docs/install/claude-code): Агентный инструмент для программирования от Anthropic - [Codex](https://lagune.ai/ru-RU/docs/install/codex): Агент для программирования от OpenAI - [Cursor](https://lagune.ai/ru-RU/docs/install/cursor): Редактор кода с ИИ - [GitHub Copilot](https://lagune.ai/ru-RU/docs/install/github-copilot-cli): ИИ-напарник по программированию от GitHub - [Gemini CLI](https://lagune.ai/ru-RU/docs/install/gemini-cli): Открытый агент для терминала от Google - [Antigravity](https://lagune.ai/ru-RU/docs/install/antigravity-cli): Платформа агентной разработки от Google - [OpenCode](https://lagune.ai/ru-RU/docs/install/opencode): Открытый агент для программирования - [Devin for Terminal](https://lagune.ai/ru-RU/docs/install/devin-cli): Агент для терминала от Cognition - [Factory Droid](https://lagune.ai/ru-RU/docs/install/factory-droid): Агент для разработки ПО от Factory - [Grok Build](https://lagune.ai/ru-RU/docs/install/grok-build): Агент для программирования от xAI - [Qwen Code](https://lagune.ai/ru-RU/docs/install/qwen-code): Агент для программирования в терминале от Qwen - [Kimi Code](https://lagune.ai/ru-RU/docs/install/kimi-code): Агент для программирования от Moonshot AI - [Muse Code](https://lagune.ai/ru-RU/docs/install/muse-code): Агент для программирования от Meta - [Pi](https://lagune.ai/ru-RU/docs/install/pi): Минималистичный агент для программирования в терминале - [Hermes Agent](https://lagune.ai/ru-RU/docs/install/hermes-agent): Открытый агент от Nous Research - [Универсальная установка](https://lagune.ai/ru-RU/docs/install/universal): Cline, Kiro CLI, Windsurf, Zed и еще 66 **Информация** - Внутри **Lagune** работает на **Node.js**, но вы пишете на любом языке. - Чтобы работать полностью офлайн, установите **Lagune** в проект командой `npm i -D lagune@0.16.0`. ## Категории Знания **Lagune** о безопасности поставляются в виде [**специализаций**](https://lagune.ai/ru-RU/docs/catalog), сгруппированных по [**категориям**](https://lagune.ai/ru-RU/docs/categories). - **OWASP** (`owasp`): Защита от рисков безопасности приложений, которые отслеживает OWASP: инъекций, нарушения контроля доступа, сбоев аутентификации и криптографии - **Инфраструктура** (`infra`): Защита конфигурации контейнеров, рабочих нагрузок и serverless: Dockerfile, Compose, безопасность подов, IAM и триггеры FaaS - **ИИ / LLM** (`ai`): Защита интеграций с ИИ и LLM от prompt injection и небезопасного подключения инструментов, агентов, поиска данных и MCP - **Lovable** (`lovable`): Защита сгенерированных ИИ приложений на Supabase (Lovable и подобных): пробелы в RLS, утечки ключей service_role и небезопасные настройки по умолчанию - **JavaScript** (`javascript`): Защита JavaScript и его сред выполнения от RCE через eval и child_process, path traversal и prototype pollution - **Python** (`python`): Защита Python от RCE через десериализацию pickle и YAML, обхода через строки str.format и class pollution - **Rust** (`rust`): Защита Rust от некорректных unsafe API, неправильного использования transmute, целочисленного переполнения и неопределенного поведения на границе FFI - **Java** (`java`): Защита Java от цепочек гаджетов десериализации ObjectInputStream, ведущих к удаленному выполнению кода - **Ruby** (`ruby`): Защита Ruby от цепочек гаджетов десериализации Marshal.load и YAML, ведущих к удаленному выполнению кода - **PHP** (`php`): Защита PHP от обхода аутентификации через type juggling, цепочек гаджетов object injection и небезопасных настроек по умолчанию - **Go** (`go`): Защита Go от ошибок с typed nil в интерфейсах, data races в горутинах и небезопасной конкурентности на путях безопасности - **C / C++** (`c-cpp`): Защита C и C++ от ошибок форматных строк, переполнений буфера и записи за границами памяти, ведущих к выполнению кода - **.NET** (`dotnet`): Защита .NET и C# от RCE через десериализацию BinaryFormatter и обходов кодировщиков, ведущих к XSS Выполните `npx lagune write add --categories` с ключами выбранных категорий. **Совет** Проект начинается с `owasp`, а [`/lagune-charter`](https://lagune.ai/ru-RU/docs/commands/charter) добавляет категории, которые подтверждает анализ проекта. ## Требования В системе должен быть установлен [**Node.js (LTS)**](https://nodejs.org/en/download/package-manager). ## Добавьте бейдж ✨ Используете **Lagune**? Добавьте бейдж в свой **README**: **Двухцветный** ![Secured By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Secured%20By&labelColor=303952) ```md [![Secured By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Secured%20By&labelColor=303952)](https://lagune.ai) ``` ![Security Powered By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security%20Powered%20By&labelColor=303952) ```md [![Security Powered By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security%20Powered%20By&labelColor=303952)](https://lagune.ai) ``` ![Security-Driven Hardening with Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security-Driven%20Hardening&labelColor=303952) ```md [![Security-Driven Hardening with Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security-Driven%20Hardening&labelColor=303952)](https://lagune.ai) ``` **Одноцветный** ![Secured By Lagune](https://img.shields.io/badge/Secured%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white) ```md [![Secured By Lagune](https://img.shields.io/badge/Secured%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white)](https://lagune.ai) ``` ![Security Powered By Lagune](https://img.shields.io/badge/Security%20Powered%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white) ```md [![Security Powered By Lagune](https://img.shields.io/badge/Security%20Powered%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white)](https://lagune.ai) ``` ![Security-Driven Hardening](https://img.shields.io/badge/Security--Driven%20Hardening-2f7bff?logo=springsecurity&logoColor=white) ```md [![Security-Driven Hardening](https://img.shields.io/badge/Security--Driven%20Hardening-2f7bff?logo=springsecurity&logoColor=white)](https://lagune.ai) ``` ## Что дальше Узнайте, что делает каждый из [**навыков**](https://lagune.ai/ru-RU/docs/get-started/commands) **Lagune**. ## Частые вопросы ### Что такое Lagune? Lagune представляет собой открытый процесс безопасности, ориентированный только на защиту, который помогает вашему ИИ-агенту усилить защиту любой кодовой базы. Вы указываете на свой код, Lagune выявляет, что на самом деле делает ваша система, и направляет исправления безопасности, важные именно в этом контексте. ### Как установить Lagune? Выберите своего агента: Claude Code, GitHub Copilot CLI, Muse Code, Antigravity CLI, Cursor, Kimi Code, OpenCode, Codex CLI, Factory Droid, Grok Build, Devin CLI и Hermes Agent устанавливают Lagune как плагин, Gemini CLI и Qwen Code как расширение, Pi как пакет, а любой другой агент через npx skills add wellwelwel/lagune. Lagune работает и в новых, и в существующих проектах. ### Нужен ли Lagune API-ключ? Нет. Lagune работает через вашего собственного ИИ-агента, поэтому API-ключи не нужны. ### Какие требования? В системе должен быть установлен Node.js (LTS). ### Какие языки программирования поддерживает Lagune? Любые. Внутри Lagune работает на Node.js, но проводит аудит и усиливает защиту проектов на любом языке программирования. ### Что Lagune добавляет в мой проект? Директорию .lagune/ с состоянием безопасности вашего проекта, которую создает первая команда, записывающая данные. CLI skills также устанавливает slash-команды в проект, где их читает ваш агент, а плагин хранит их внутри агента. ### Как обновить Lagune? Так же, как вы его установили. На странице установки каждого агента показано, как обновить Lagune в нем, а CLI skills обновляет его командой npx skills update. Ваши принципы безопасности, артефакты фаз и собственные специализации остаются нетронутыми. ### Какие специализации использует проект? Встроенные специализации его категорий плюс собственные. Принципы безопасности фиксируют категории, которые подтверждает анализ проекта, а npx lagune write add --categories их меняет. ### Нужно ли закончить разработку, прежде чем защищать проект? Нет. Команда /lagune усиливает защиту кода прямо во время написания: она принимает любой промпт, создает то, что вы попросили, и защищает результат безопасными настройками по умолчанию, следуя принципам безопасности. Пятифазный процесс Blue Team проводит аудит того, что уже есть. ### Может ли Lagune провести аудит существующего проекта? Да. Пятифазный процесс Blue Team проводит аудит того, что уже есть: charter задает ваши правила безопасности, detect выявляет, что делает система и где находятся риски, plan оценивает каждую находку и подбирает к ней исправление, harden применяет исправления, а verify доказывает, что они действуют, и закрывает их. ### Чем использование Lagune отличается от простой просьбы к агенту найти уязвимости и проблемы безопасности? Агент, читающий код сам по себе, находит то, что похоже на уязвимость, и пропускает то, что похоже на меру защиты. Список заблокированных адресов выглядит так, будто кто-то уже справился с риском, поэтому никто не проверяет, что он пропускает большинство адресов, и код уходит в продакшен. Lagune переворачивает это поведение по умолчанию: защита, которая уже есть в коде, считается недоказанной, пока ее не проверят, каждая специализация из каталога получает явный вердикт, а verify спрашивает, исчез ли риск, а не есть ли мера защиты. Каждая находка также остается одним отслеживаемым элементом между запусками, поэтому ее можно доказанно закрыть и снять с учета, тогда как простая просьба каждый раз дает новый отчет, который не с чем сравнить. ### Чем разработка с Lagune отличается от простой просьбы к агенту писать безопасный код? Просьба писать безопасный код оставляет определение безопасности агенту и предполагает, что вы знаете, о чем просить. Требование обычно уже скрыто в вашей просьбе, и ни вы, ни агент его не замечаете: просьба сделать страницу с курсами, к которым у пользователя есть доступ, задает правило авторизации, а проверка, которую так и не написали, не оставляет в коде ничего, что можно было бы заметить. Команда /lagune загружает ваши принципы безопасности и специализации, подходящие к тому, что предстоит создать, еще до первой строки кода, а затем перечитывает результат, сверяя его с примененной защитой. Безопасный вариант редко обходится дороже небезопасного, поэтому исход решает знание того, какой из них выбрать, и именно это знание приходит заранее. ### Выполняет ли Lagune DAST (Dynamic Application Security Testing) или тестирует мое работающее приложение? Нет. Lagune читает код и никогда не запускает вашу систему и не отправляет ей специально сформированные запросы. Verify подтверждает, что мера защиты присутствует в исходном коде и реализована правильно, а это другой вопрос, чем выдержит ли она атаку на работающую систему, поэтому "по коду определить нельзя" является законным вердиктом, а не молчаливым прохождением проверки. DAST отвечает на вопрос о времени выполнения, а Lagune на вопрос об исходном коде, поэтому ни один не заменяет другой. Даже необязательная команда prove держится этой границы: ее тесты проверяют безопасное поведение и никогда не содержат атакующую нагрузку. ### Заменяет ли Lagune пентест (тестирование на проникновение)? Нет, определенно нет! Пентест представляет собой санкционированную работу, в которой специалист применяет собственное суждение к вашей работающей системе, выстраивая цепочки из находок и исследуя бизнес-логику, которую не описывает ни одно правило для отдельной поверхности. Находки пентеста можно передать в процесс Blue Team от Lagune как опасения для фазы detect, чтобы то, о чем сообщил специалист, было спланировано, исправлено и проверено. ## Политика безопасности Ознакомьтесь с [SECURITY.md](https://github.com/wellwelwel/lagune/blob/main/SECURITY.md). ## Лицензия **Lagune** распространяется по лицензии [Apache License 2.0](https://github.com/wellwelwel/lagune/blob/main/LICENSE). Copyright © 2026-н. в. [Weslley Araújo](https://github.com/wellwelwel) и [участники](https://github.com/wellwelwel/lagune/graphs/contributors). --- # Установка Lagune в Antigravity CLI как плагина > Установите Lagune в Antigravity CLI как плагин, поддерживайте его в актуальном состоянии и заранее разрешите его движок. Канонический URL: https://lagune.ai/ru-RU/docs/install/antigravity-cli Язык: ru-RU Оригинал: https://lagune.ai/docs/install/antigravity-cli Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity ``` ## Обновление Чтобы обновить **Lagune**, установите его снова: ```bash agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity ``` ## Команды Вводите команды с именем плагина, например `/lagune:lagune-charter` для `/lagune-charter`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. Команда, отправленная первым сообщением сессии, выполняется до их загрузки, поэтому использует **npx**. Чтобы разрешить инструменты и **npx** заранее, добавьте эти правила в `~/.gemini/antigravity-cli/settings.json`: ```json { "permissions": { "allow": [ "mcp(lagune_lagune/lagune_read)", "mcp(lagune_lagune/lagune_write)", "command(regex:npx --yes lagune@[0-9.]+)" ] } } ``` ## Частые вопросы ### Как установить Lagune в Antigravity CLI? Выполните agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity. ### Как обновить Lagune в Antigravity CLI? Снова выполните agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity. ### Как запускать команды Lagune в Antigravity CLI? Вводите их с именем плагина, например /lagune:lagune-charter. ### Может ли Antigravity CLI запускать Lagune, не спрашивая разрешения? Да. Разрешите mcp(lagune_lagune/lagune_read), mcp(lagune_lagune/lagune_write) и command(regex:npx --yes lagune@[0-9.]+) в настройках Antigravity CLI. Правило для npx охватывает команду, отправленную первым сообщением сессии. --- # Установка Lagune в Claude Code как плагина > Установите Lagune в Claude Code как плагин, в терминале, расширении или десктопном приложении, поддерживайте его в актуальном состоянии и заранее разрешите его движок. Канонический URL: https://lagune.ai/ru-RU/docs/install/claude-code Язык: ru-RU Оригинал: https://lagune.ai/docs/install/claude-code Последнее обновление: 2026-11-03 **Терминал** Установите плагин из терминала: ```bash claude plugin install lagune --marketplace wellwelwel/lagune ``` Или из сессии **Claude Code**: ```text /plugin marketplace add wellwelwel/lagune /plugin install lagune@lagune ``` **Расширение** - Введите `/plugin` и выберите **Manage plugins**. - Добавьте `wellwelwel/lagune` на вкладке **Marketplaces**. - Установите `lagune` на вкладке **Plugins**. **Десктоп** - Установите **Lagune** из терминала или расширения, выбрав в расширении **Install for you**. - Начните новую сессию в десктопном приложении, которое загружает плагины, установленные вами для себя. ## Обновление **Терминал** Чтобы обновить **Lagune**, выполните: ```bash claude plugin marketplace update lagune claude plugin update lagune@lagune ``` Чтобы он обновлялся сам, выберите **Enable auto-update** для маркетплейса `lagune` в `/plugin`. **Расширение** - Введите `/plugin` и выберите **Manage plugins**. - Откройте вкладку **Marketplaces**. - Нажмите значок обновления у `lagune`. **Десктоп** - Обновите **Lagune** из терминала или расширения. - Начните новую сессию в десктопном приложении. ## Команды Вводите команды по имени, например `/lagune-charter`, или с именем плагина, например `/lagune:lagune-charter`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. Чтобы разрешить их заранее, добавьте эти правила в `.claude/settings.json` для одного проекта или в `~/.claude/settings.json` для всех: ```json { "permissions": { "allow": [ "mcp__plugin_lagune_lagune__lagune_read", "mcp__plugin_lagune_lagune__lagune_write" ] } } ``` Когда движок запускается через **npx**, как в случае **skills.sh**, разрешите `Bash(npx --yes lagune@*)`. Если включена песочница, также добавьте `registry.npmjs.org` в `sandbox.network.allowedDomains`. ## Частые вопросы ### Как установить Lagune в Claude Code? Выполните claude plugin install lagune --marketplace wellwelwel/lagune. В сессии или расширении добавьте маркетплейс wellwelwel/lagune через менеджер плагинов и установите lagune. Десктопное приложение загружает его, как только вы установите его для себя в терминале или расширении. ### Как обновить Lagune в Claude Code? Выполните claude plugin marketplace update lagune, затем claude plugin update lagune@lagune, или выберите Enable auto-update для маркетплейса lagune в /plugin. В расширении откройте Manage plugins из /plugin и нажмите значок обновления у маркетплейса lagune. Десктопное приложение загружает обновление в следующей сессии. ### Как запускать команды Lagune в Claude Code? Вводите их по имени, например /lagune-charter, или с именем плагина, например /lagune:lagune-charter. ### Может ли Claude Code запускать Lagune, не спрашивая разрешения? Да. Разрешите mcp__plugin_lagune_lagune__lagune_read и mcp__plugin_lagune_lagune__lagune_write в настройках Claude Code, а также Bash(npx --yes lagune@*), когда движок запускается через npx. --- # Установка Lagune в Codex CLI как плагина > Установите Lagune в Codex CLI как плагин, поддерживайте его в актуальном состоянии и запускайте его движок внутри песочницы. Канонический URL: https://lagune.ai/ru-RU/docs/install/codex Язык: ru-RU Оригинал: https://lagune.ai/docs/install/codex Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash codex plugin marketplace add wellwelwel/lagune codex plugin add lagune@lagune ``` ## Обновление Чтобы обновить **Lagune**, выполните: ```bash codex plugin marketplace upgrade lagune ``` ## Команды Введите `$` и команду с именем плагина, а за ней свой запрос, например `$lagune:lagune-charter` для `/lagune-charter`. Если ввести `$`, появится список команд, и при выборе одной из них подставится ее полное имя. --- **Разрешения** У песочницы **Codex** нет доступа к сети. Установите движок в проект из своего терминала, один раз и после каждого обновления: ```bash npm i -D lagune@0.16.0 ``` ## Частые вопросы ### Как установить Lagune в Codex CLI? Выполните codex plugin marketplace add wellwelwel/lagune, затем codex plugin add lagune@lagune. ### Как обновить Lagune в Codex CLI? Выполните codex plugin marketplace upgrade lagune. ### Как запускать команды Lagune в Codex CLI? Введите $ и команду с именем плагина, а за ней свой запрос, например $lagune:lagune-charter. ### Работает ли Lagune внутри песочницы Codex? Да, если установить движок в проект командой npm i -D lagune@0.16.0 из своего терминала, один раз и после каждого обновления. --- # Установка Lagune в Cursor как плагина > Установите Lagune в Cursor и Cursor CLI как плагин, поддерживайте его в актуальном состоянии и заранее разрешите его движок. Канонический URL: https://lagune.ai/ru-RU/docs/install/cursor Язык: ru-RU Оригинал: https://lagune.ai/docs/install/cursor Последнее обновление: 2026-11-03 **Cursor** - Откройте **Customize**. - Выберите **From GitHub Repository** и введите `https://github.com/wellwelwel/lagune`. - Нажмите **Install** у **Lagune** и выберите область проекта или пользователя. **Cursor CLI** - Добавьте маркетплейс из терминала: ```bash agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor ``` - Введите `/plugins` в сессии `agent`. - Установите **Lagune**. Если **Lagune** уже установлен в **Claude Code**, **Cursor CLI** загружает его оттуда. ## Обновление **Cursor** - Откройте **Customize**. - Нажмите **Refresh** у маркетплейса `lagune`. **Cursor CLI** - Замените маркетплейс из терминала: ```bash agent plugin marketplace remove lagune agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor ``` - Введите `/plugins` в сессии `agent`. - Снова установите **Lagune**. ## Команды Вводите команды по имени, например `/lagune-charter`. --- **Разрешения** В **Cursor** команды запускают движок через **npx**, что режим Auto-review по умолчанию разрешает без вопросов. В **Cursor CLI** движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. Чтобы разрешить их заранее, добавьте эти правила в `.cursor/cli.json` для одного проекта или в `~/.cursor/cli-config.json` для всех: ```json { "permissions": { "allow": [ "Mcp(plugin-lagune-lagune:lagune_read)", "Mcp(plugin-lagune-lagune:lagune_write)" ] } } ``` Когда движок запускается через **npx**, как в случае **skills.sh**, разрешите `Shell(npx:--yes lagune@*)`. ## Частые вопросы ### Как установить Lagune в Cursor? В Cursor откройте Customize, выберите From GitHub Repository, введите https://github.com/wellwelwel/lagune и установите Lagune. В Cursor CLI выполните agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor, затем установите Lagune из /plugins. ### Как обновить Lagune в Cursor? В Cursor нажмите Refresh у маркетплейса lagune в Customize. В Cursor CLI удалите маркетплейс lagune, добавьте его снова, а затем снова установите Lagune из /plugins. ### Как запускать команды Lagune в Cursor? Вводите их по имени, например /lagune-charter. ### Может ли Cursor запускать Lagune, не спрашивая разрешения? Да. Режим Auto-review в Cursor по умолчанию уже это разрешает. В Cursor CLI разрешите Mcp(plugin-lagune-lagune:lagune_read) и Mcp(plugin-lagune-lagune:lagune_write), а также Shell(npx:--yes lagune@*), когда движок запускается через npx. --- # Установка Lagune в Devin CLI как плагина > Установите Lagune в Devin CLI как плагин и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/devin-cli Язык: ru-RU Оригинал: https://lagune.ai/docs/install/devin-cli Последнее обновление: 2026-11-03 Войдите в **Devin**, затем установите плагин из терминала: ```bash devin auth login devin plugins install wellwelwel/lagune ``` ## Обновление Чтобы обновить **Lagune**, выполните: ```bash devin plugins update lagune ``` ## Команды Вводите команды с именем плагина, например `/lagune:lagune-charter` для `/lagune-charter`. Меню `/` тоже их показывает. ## Частые вопросы ### Как установить Lagune в Devin CLI? Войдите командой devin auth login, затем выполните devin plugins install wellwelwel/lagune. ### Как обновить Lagune в Devin CLI? Выполните devin plugins update lagune. ### Как запускать команды Lagune в Devin CLI? Вводите их с именем плагина, например /lagune:lagune-charter. Меню / тоже их показывает. --- # Установка Lagune в Factory Droid как плагина > Установите Lagune в Factory Droid как плагин, поддерживайте его в актуальном состоянии и разрешите инструменты его движка. Канонический URL: https://lagune.ai/ru-RU/docs/install/factory-droid Язык: ru-RU Оригинал: https://lagune.ai/docs/install/factory-droid Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash droid plugin marketplace add wellwelwel/lagune droid plugin install lagune@lagune ``` ## Обновление Чтобы обновить **Lagune**, выполните: ```bash droid plugin marketplace update lagune droid plugin update lagune@lagune ``` ## Команды Вводите команды по имени, например `/lagune-charter`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. Когда **Factory Droid** спросит, выберите всегда разрешать каждый из них. Он спросит снова после синхронизации нового коммита маркетплейса `lagune`, что может произойти при запуске. ## Частые вопросы ### Как установить Lagune в Factory Droid? Выполните droid plugin marketplace add wellwelwel/lagune, затем droid plugin install lagune@lagune. ### Как обновить Lagune в Factory Droid? Выполните droid plugin marketplace update lagune, затем droid plugin update lagune@lagune. ### Как запускать команды Lagune в Factory Droid? Вводите их по имени, например /lagune-charter. ### Может ли Factory Droid запускать Lagune, не спрашивая разрешения? Да. Когда Factory Droid спросит, выберите всегда разрешать lagune_read и lagune_write. Он спросит снова после синхронизации нового коммита маркетплейса lagune. --- # Установка Lagune в Gemini CLI как расширения > Установите Lagune в Gemini CLI как расширение, поддерживайте его в актуальном состоянии и заранее разрешите его движок. Канонический URL: https://lagune.ai/ru-RU/docs/install/gemini-cli Язык: ru-RU Оригинал: https://lagune.ai/docs/install/gemini-cli Последнее обновление: 2026-11-03 Установите расширение из терминала: ```bash gemini extensions install https://github.com/wellwelwel/lagune ``` ## Обновление Чтобы обновить **Lagune**, выполните: ```bash gemini extensions update lagune ``` Чтобы он обновлялся сам, установите его с `--auto-update`. ## Команды Вводите команды с именем расширения, например `/lagune:lagune-charter` для `/lagune-charter`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. **Gemini CLI** запускает их только в доверенной папке. Чтобы разрешить их заранее, сохраните это правило как `~/.gemini/policies/lagune.toml`: ```toml [[rule]] mcpName = "lagune" toolName = ["lagune_read", "lagune_write"] decision = "allow" priority = 100 ``` Когда движок запускается через **npx**, как в случае **skills.sh**, добавьте в тот же файл это правило: ```toml [[rule]] toolName = "run_shell_command" commandRegex = 'npx --yes lagune@\d+\.\d+\.\d+\s' decision = "allow" priority = 100 ``` ## Частые вопросы ### Как установить Lagune в Gemini CLI? Выполните gemini extensions install https://github.com/wellwelwel/lagune. ### Как обновить Lagune в Gemini CLI? Выполните gemini extensions update lagune или установите расширение с --auto-update. ### Как запускать команды Lagune в Gemini CLI? Вводите их с именем расширения, например /lagune:lagune-charter. ### Может ли Gemini CLI запускать Lagune, не спрашивая разрешения? Да. Добавьте правило политики, которое разрешает инструменты lagune_read и lagune_write сервера lagune, а также правило для run_shell_command с npx --yes lagune@ и версией, когда движок запускается через npx. --- # Установка Lagune в GitHub Copilot CLI как плагина > Установите Lagune в GitHub Copilot CLI как плагин и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/github-copilot-cli Язык: ru-RU Оригинал: https://lagune.ai/docs/install/github-copilot-cli Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash copilot plugin marketplace add wellwelwel/lagune copilot plugin install lagune@lagune ``` В редакторе устанавливайте **Lagune** для **GitHub Copilot** через [**skills.sh**](https://lagune.ai/ru-RU/docs/install/universal). ## Обновление Чтобы обновить **Lagune**, выполните: ```bash copilot plugin marketplace update lagune copilot plugin update lagune@lagune ``` ## Команды Вводите команды по имени, например `/lagune-charter`. ## Частые вопросы ### Как установить Lagune в GitHub Copilot CLI? Выполните copilot plugin marketplace add wellwelwel/lagune, затем copilot plugin install lagune@lagune. ### Как обновить Lagune в GitHub Copilot CLI? Выполните copilot plugin marketplace update lagune, затем copilot plugin update lagune@lagune. ### Как запускать команды Lagune в GitHub Copilot CLI? Вводите их по имени, например /lagune-charter. ### Можно ли использовать Lagune с GitHub Copilot в VS Code? Да. В VS Code или другом редакторе устанавливайте Lagune через skills.sh, а не как плагин. --- # Установка Lagune в Grok Build как плагина > Установите Lagune в Grok Build как плагин, поддерживайте его в актуальном состоянии и заранее разрешите его движок. Канонический URL: https://lagune.ai/ru-RU/docs/install/grok-build Язык: ru-RU Оригинал: https://lagune.ai/docs/install/grok-build Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash grok plugin install wellwelwel/lagune@plugin-grok --trust ``` ## Обновление Чтобы обновить **Lagune**, выполните: ```bash grok plugin update lagune ``` ## Команды Вводите команды по имени, например `/lagune-charter`, или с именем плагина, например `/lagune:lagune-charter`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. Чтобы разрешить их заранее, добавьте эти правила в `~/.grok/config.toml`: ```toml [permission] allow = ["MCPTool(lagune__lagune_read)", "MCPTool(lagune__lagune_write)"] ``` Когда движок запускается через **npx**, как в случае **skills.sh**, разрешите `Bash(npx --yes lagune@*)`. ## Частые вопросы ### Как установить Lagune в Grok Build? Выполните grok plugin install wellwelwel/lagune@plugin-grok --trust. ### Как обновить Lagune в Grok Build? Выполните grok plugin update lagune. ### Как запускать команды Lagune в Grok Build? Вводите их по имени, например /lagune-charter, или с именем плагина, например /lagune:lagune-charter. ### Может ли Grok Build запускать Lagune, не спрашивая разрешения? Да. Разрешите MCPTool(lagune__lagune_read) и MCPTool(lagune__lagune_write) в конфигурации Grok Build, а также Bash(npx --yes lagune@*), когда движок запускается через npx. --- # Установка Lagune в Hermes Agent как плагина > Установите Lagune в Hermes Agent как плагин и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/hermes-agent Язык: ru-RU Оригинал: https://lagune.ai/docs/install/hermes-agent Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash hermes plugins install wellwelwel/lagune --enable ``` - Когда **Hermes Agent** попросит подтвердить плагин не из своего каталога, **подтвердите**. - Когда он предложит установить зависимости **Node.js** из репозитория, **откажитесь**. ## Обновление Чтобы обновить **Lagune**, выполните: ```bash hermes plugins update lagune ``` ## Команды Вводите команды с именем плагина, например `/lagune:lagune-charter` для `/lagune-charter` и `/lagune:lagune` для `/lagune`. ## Частые вопросы ### Как установить Lagune в Hermes Agent? Выполните hermes plugins install wellwelwel/lagune --enable. Подтвердите плагин, когда вас попросят, и откажитесь от установки зависимостей Node.js из репозитория. ### Как обновить Lagune в Hermes Agent? Выполните hermes plugins update lagune. ### Как запускать команды Lagune в Hermes Agent? Вводите их с именем плагина, например /lagune:lagune-charter и /lagune:lagune. --- # Установка Lagune в Kimi Code как плагина > Установите Lagune в Kimi Code как плагин и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/kimi-code Язык: ru-RU Оригинал: https://lagune.ai/docs/install/kimi-code Последнее обновление: 2026-11-03 Установите плагин из сессии **Kimi Code**, выберите **Trust and install**, а затем начните новую сессию, чтобы он загрузился: ```text /plugins install https://github.com/wellwelwel/lagune /new ``` ## Обновление Чтобы обновить **Lagune**, установите его снова: ```text /plugins install https://github.com/wellwelwel/lagune /new ``` ## Команды Вводите команды с именем плагина, например `/lagune:lagune-charter` для `/lagune-charter`. Меню `/` показывает их как `/skill:lagune:lagune-charter`, и такая форма тоже работает. ## Частые вопросы ### Как установить Lagune в Kimi Code? В сессии Kimi Code выполните /plugins install https://github.com/wellwelwel/lagune, выберите Trust and install, а затем выполните /new. ### Как обновить Lagune в Kimi Code? Снова выполните /plugins install https://github.com/wellwelwel/lagune, а затем /new. ### Как запускать команды Lagune в Kimi Code? Вводите их с именем плагина, например /lagune:lagune-charter, или так, как их показывает меню /, например /skill:lagune:lagune-charter. --- # Установка Lagune в Muse Code как плагина > Установите Lagune в Muse Code как плагин, поддерживайте его в актуальном состоянии и запускайте его движок внутри песочницы. Канонический URL: https://lagune.ai/ru-RU/docs/install/muse-code Язык: ru-RU Оригинал: https://lagune.ai/docs/install/muse-code Последнее обновление: 2026-11-03 Установите плагин из терминала: ```bash muse plugins marketplace add lagune wellwelwel/lagune muse plugins install lagune@lagune ``` ## Обновление Чтобы обновить **Lagune**, обновите маркетплейс и переустановите плагин: ```bash muse plugins marketplace update lagune muse plugins remove lagune muse plugins install lagune@lagune ``` ## Команды Вводите команды по имени, например `/lagune-charter`, или с именем плагина, например `/lagune:lagune-charter`. --- **Разрешения** Песочница **Muse Code** не может скачать движок. Установите его в проект из своего терминала, один раз и после каждого обновления: ```bash npm i -D lagune@0.16.0 ``` ## Частые вопросы ### Как установить Lagune в Muse Code? Выполните muse plugins marketplace add lagune wellwelwel/lagune, затем muse plugins install lagune@lagune. ### Как обновить Lagune в Muse Code? Выполните muse plugins marketplace update lagune, затем переустановите плагин командами muse plugins remove lagune и muse plugins install lagune@lagune. ### Как запускать команды Lagune в Muse Code? Вводите их по имени, например /lagune-charter, или с именем плагина, например /lagune:lagune-charter. ### Работает ли Lagune внутри песочницы Muse Code? Да, если установить движок в проект командой npm i -D lagune@0.16.0 из своего терминала, один раз и после каждого обновления. --- # Установка Lagune в OpenCode как плагина > Установите Lagune в OpenCode 1.x и 2.x как плагин и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/opencode Язык: ru-RU Оригинал: https://lagune.ai/docs/install/opencode Последнее обновление: 2026-11-03 **OpenCode 2.x** Установите плагин из терминала: ```bash opencode plugin add lagune ``` Или добавьте его в список `plugins` в `opencode.json`: ```json { "plugins": ["lagune"] } ``` **OpenCode 1.x** Установите плагин в проект из терминала или добавьте `-g`, чтобы установить его для всех своих проектов: ```bash opencode plugin lagune ``` Или добавьте его в список `plugin` в `opencode.json`: ```json { "plugin": ["lagune"] } ``` ## Обновление **OpenCode 2.x** Чтобы обновить **Lagune**, выполните: ```bash opencode plugin update lagune opencode reload ``` **OpenCode 1.x** Чтобы обновить **Lagune**, установите новый релиз поверх старого, добавив `-g`, если вы устанавливали его для всех своих проектов: ```bash opencode plugin lagune@0.16.0 --force ``` ## Команды **OpenCode 2.x** Введите `@` и выберите команду, например `@lagune-charter`, затем напишите свой запрос в том же сообщении. **OpenCode 1.x** Вводите команды по имени, например `/lagune-charter`. Они перечислены в `/skills`, а не в меню `/`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. **OpenCode** запускает их без вопросов. ## Частые вопросы ### Как установить Lagune в OpenCode? В OpenCode 2.x выполните opencode plugin add lagune. В OpenCode 1.x выполните opencode plugin lagune, добавив -g, чтобы установить его для всех своих проектов. ### Как обновить Lagune в OpenCode? В OpenCode 2.x выполните opencode plugin update lagune, затем opencode reload. В OpenCode 1.x выполните opencode plugin lagune@0.16.0 --force. ### Как запускать команды Lagune в OpenCode? В OpenCode 2.x введите @ и выберите команду, например @lagune-charter, затем напишите свой запрос в том же сообщении. В OpenCode 1.x вводите их по имени, например /lagune-charter, или найдите их в /skills. ### Спрашивает ли OpenCode разрешение перед запуском Lagune? Нет. OpenCode запускает два инструмента движка, lagune_read и lagune_write, без вопросов. --- # Установка Lagune в Pi как пакета > Установите Lagune в Pi как пакет, из npm или из GitHub, и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/pi Язык: ru-RU Оригинал: https://lagune.ai/docs/install/pi Последнее обновление: 2026-11-03 **npm** Установите пакет из терминала: ```bash pi install npm:lagune ``` **GitHub** Установите последний коммит из **GitHub**, который запускает движок через **npx**: ```bash pi install git:github.com/wellwelwel/lagune ``` ## Обновление **npm** Чтобы обновить **Lagune**, выполните: ```bash pi update npm:lagune ``` **GitHub** Чтобы обновить **Lagune**, выполните: ```bash pi update git:github.com/wellwelwel/lagune ``` `pi update --extensions` обновляет все установленные вами пакеты, а `pi update` без флагов обновляет только **Pi**. ## Команды Вводите команды с префиксом `skill:`, например `/skill:lagune-charter` для `/lagune-charter`. ## Частые вопросы ### Как установить Lagune в Pi? Выполните pi install npm:lagune или pi install git:github.com/wellwelwel/lagune, чтобы получить последний коммит из GitHub. ### Как обновить Lagune в Pi? Выполните pi update npm:lagune или pi update git:github.com/wellwelwel/lagune для установки из GitHub. pi update --extensions обновляет все установленные вами пакеты. ### Как запускать команды Lagune в Pi? Вводите их с префиксом skill:, например /skill:lagune-charter. --- # Установка Lagune в Qwen Code как расширения > Установите Lagune в Qwen Code как расширение, поддерживайте его в актуальном состоянии и заранее разрешите его движок. Канонический URL: https://lagune.ai/ru-RU/docs/install/qwen-code Язык: ru-RU Оригинал: https://lagune.ai/docs/install/qwen-code Последнее обновление: 2026-11-03 Установите расширение из терминала: ```bash qwen extensions install lagune ``` ## Обновление Чтобы обновить **Lagune**, выполните: ```bash qwen extensions update lagune ``` Чтобы он обновлялся сам, установите его с `--auto-update`. ## Команды Вводите команды с именем расширения, например `/lagune:lagune-charter` для `/lagune-charter`. --- **Разрешения** Движок работает через два инструмента: `lagune_read` только читает ваш проект, а `lagune_write` только пишет в `.lagune/`. Чтобы разрешить их заранее, добавьте эти правила в `.qwen/settings.json` для одного проекта или в `~/.qwen/settings.json` для всех: ```json { "permissions": { "allow": ["mcp__lagune__lagune_read", "mcp__lagune__lagune_write"] } } ``` Когда движок запускается через **npx**, как в случае **skills.sh**, разрешите `Shell(npx --yes lagune@*)`. ## Частые вопросы ### Как установить Lagune в Qwen Code? Выполните qwen extensions install lagune. ### Как обновить Lagune в Qwen Code? Выполните qwen extensions update lagune или установите расширение с --auto-update. ### Как запускать команды Lagune в Qwen Code? Вводите их с именем расширения, например /lagune:lagune-charter. ### Может ли Qwen Code запускать Lagune, не спрашивая разрешения? Да. Разрешите mcp__lagune__lagune_read и mcp__lagune__lagune_write в настройках Qwen Code, а также Shell(npx --yes lagune@*), когда движок запускается через npx. --- # Установка Lagune в любой агент через skills.sh > Установите Lagune в любой ИИ-агент через CLI skills и поддерживайте его в актуальном состоянии. Канонический URL: https://lagune.ai/ru-RU/docs/install/universal Язык: ru-RU Оригинал: https://lagune.ai/docs/install/universal Последнее обновление: 2026-11-03 **Терминал** Установите команды **Lagune** из терминала через [**skills.sh**](https://www.skills.sh/wellwelwel/lagune): ```bash npx skills add wellwelwel/lagune ``` **Промпт** Вставьте этот промпт в своего агента: ```md Выполни `npx --yes skills add wellwelwel/lagune` и сразу следуй сгенерированным инструкциям навыка. Прочитай весь вывод, при необходимости сначала перенаправив его во временный файл. Разрешай относительные пути от директории со вспомогательными файлами, которую он указывает. ``` ## Обновление **Терминал** Чтобы обновить **Lagune**, выполните: ```bash npx skills update ``` **Промпт** Чтобы обновить **Lagune**, вставьте этот промпт в своего агента: ```md Выполни `npx --yes skills update -y` и прочитай весь вывод, при необходимости сначала перенаправив его во временный файл. ``` --- **Один способ на агента** Устанавливайте **Lagune** либо через **skills.sh**, либо через его **плагин**, но никогда обоими способами. **Разрешения** Команды запускают движок как `npx --yes lagune@0.16.0`, а на [странице установки каждого агента](https://lagune.ai/ru-RU/docs) показано правило, которое разрешает его заранее. В песочнице без доступа к сети установите движок в проект из своего терминала, один раз и после каждого обновления: ```bash npm i -D lagune@0.16.0 ``` ## Частые вопросы ### Как установить Lagune в любой ИИ-агент? Выполните npx skills add wellwelwel/lagune в своем проекте или вставьте промпт установки в своего агента. ### Как обновить Lagune, установленный через CLI skills? Выполните npx skills update или вставьте промпт обновления в своего агента. ### Можно ли установить Lagune и через CLI skills, и как плагин? Нет. При обоих способах агент показывает каждую команду дважды или использует одну копию и скрывает другую. --- # Навыки безопасности для ИИ-агентов > Навыки, которые Lagune открывает вашему ИИ-агенту: аудит существующего проекта или защита новой работы прямо во время разработки, и все это под управлением принципов безопасности. Канонический URL: https://lagune.ai/ru-RU/docs/get-started/commands Язык: ru-RU Оригинал: https://lagune.ai/docs/get-started/commands Последнее обновление: 2026-11-03 Когда **Lagune** [установлен](https://lagune.ai/ru-RU/docs), вашему **ИИ**-агенту становится доступен набор навыков. Пользоваться ими можно двумя способами, и оба подчиняются **принципам безопасности**: защищать новую работу прямо во время разработки или проводить полный аудит проекта. **⌨️ Разработка** Не обязательно заканчивать работу, прежде чем ее защищать. Используйте [**`/lagune`**](https://lagune.ai/ru-RU/docs/commands/lagune) для того, что вы пишете **прямо сейчас**: | Навык | Что он делает для вас | | --------------------------------------------- | ----------------------------------------------------------------------------------------------- | | [**/lagune-charter**](https://lagune.ai/ru-RU/docs/commands/charter) | Задает правила безопасности вашего проекта, основу, на которую опирается `/lagune` | | [**/lagune**](https://lagune.ai/ru-RU/docs/commands/lagune) | Создает то, что вы просите, и усиливает защиту по ходу написания, следуя принципам безопасности | **Используйте в любой момент** [**`/lagune`**](https://lagune.ai/ru-RU/docs/commands/lagune) соблюдает ваши принципы безопасности при каждом запуске. Команда принимает любой промпт, создает то, что вы попросили, и по ходу дела, а не потом, защищает результат безопасными настройками по умолчанию. --- #### Специальные навыки | Навык | Что он делает | | --------------------------------------------------- | ------------------------------------------------------------------------------------------- | | [**/lagune-specialize**](https://lagune.ai/ru-RU/docs/commands/specialize) | Обучает **Lagune** новой специализации по безопасности на основе статей, эксплойтов или тем | **🔬 Аудит: процесс Blue Team** Полный **процесс Blue Team**: понять, что делает проект, выявить его риски и закрыть их. Каждая фаза опирается на предыдущую, поэтому достаточно идти по списку сверху вниз: | # | Навык | Что он делает для вас | | --- | --------------------------------------------- | ---------------------------------------------------------------------------------------------- | | 1 | [**/lagune-charter**](https://lagune.ai/ru-RU/docs/commands/charter) | Задает правила безопасности вашего проекта: предлагает их сам или формирует по вашему описанию | | 2 | [**/lagune-detect**](https://lagune.ai/ru-RU/docs/commands/detect) | Читает ваш код и выявляет, что делает система и где находятся риски | | 3 | [**/lagune-plan**](https://lagune.ai/ru-RU/docs/commands/plan) | Превращает то, что нашла фаза detect, в план защиты с исправлением для каждой находки | | 4 | [**/lagune-harden**](https://lagune.ai/ru-RU/docs/commands/harden) | Применяет исправления из плана к вашему коду, безопасно и по одному | | 5 | [**/lagune-verify**](https://lagune.ai/ru-RU/docs/commands/verify) | Доказывает, что каждое примененное исправление действует, и закрывает те, что прошли проверку | --- #### Специальные навыки | Навык | Что он делает | | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | | [**/lagune-specialize**](https://lagune.ai/ru-RU/docs/commands/specialize) | Обучает **Lagune** новой специализации по безопасности на основе статей, эксплойтов или тем | | [**/lagune-prove**](https://lagune.ai/ru-RU/docs/commands/prove) | Превращает каждую обнаруженную находку в запускаемое доказательство, ориентированное только на защиту, для ответственного раскрытия | --- #### Внутренние навыки | Навык | Что он делает | | ------------------------------------------- | -------------------------------------------------- | | [**/lagune-repair**](https://lagune.ai/ru-RU/docs/commands/repair) | Восстанавливает внутреннее отслеживание **Lagune** | **Совет** Безопасность не расход, а инвестиция: то, что вы вложите заранее, многократно окупится инцидентами, которых так и не случится 🙋🏻‍♂️ ## Частые вопросы ### Какие навыки добавляет Lagune? /lagune, чтобы усиливать защиту работы прямо во время разработки, и пятифазный процесс аудита Blue Team: /lagune-charter, /lagune-detect, /lagune-plan, /lagune-harden, /lagune-verify. А также /lagune-specialize и /lagune-prove. ### Что такое процесс Blue Team в Lagune? Пятифазный аудит: charter (задать правила), detect (выявить риски), plan (оценить и спланировать исправления), harden (применить исправления), verify (доказать, что они действуют, и закрыть их). ### Чем /lagune отличается от процесса аудита? /lagune защищает новую работу прямо во время написания, без процесса, которому нужно следовать. Процесс аудита проходит пять фаз по порядку над существующим проектом. --- # Дашборд > Смотрите принципы безопасности, находки и каталог своего проекта в локальном представлении в реальном времени, которое открывается одной командой. Канонический URL: https://lagune.ai/ru-RU/docs/get-started/dashboard Язык: ru-RU Оригинал: https://lagune.ai/docs/get-started/dashboard Последнее обновление: 2026-11-03 Запустите **Lagune** напрямую, без подкоманды, чтобы получить интерактивное представление `.lagune/` в реальном времени. Команда поднимает дашборд и открывает его на случайном порту: ```bash npx lagune ``` - [x] **Live Reload** - [x] **Приватно** и **локально** - [x] Показывает все, что есть в `.lagune/`, начиная с первых принципов безопасности - [x] **Управляйте** категориями проекта прямо из браузера - [x] Не нужны ни `node_modules`, ни `package.json` 📦 ![Принципы безопасности в дашборде Lagune](https://lagune.ai/img/dashboard/02.webp) ![Находки в дашборде Lagune](https://lagune.ai/img/dashboard/03.webp) ![Побочные задачи в дашборде Lagune](https://lagune.ai/img/dashboard/04.webp) ![Подробности находки в дашборде Lagune](https://lagune.ai/img/dashboard/05.webp) ![Каталог в дашборде Lagune](https://lagune.ai/img/dashboard/06.webp) **Совет** - 🚪 Используйте `--port`, чтобы указать свой порт. - ⏏️ Нажмите `Ctrl+C`, чтобы остановить. ## Частые вопросы ### Как открыть дашборд Lagune? Выполните npx lagune без подкоманды в корне проекта. Команда поднимает представление .lagune/ в реальном времени на случайном порту и открывает его в браузере. ### Дашборд приватный? Да. Он работает только на вашем компьютере, по локальному адресу, недоступному ни для какого другого компьютера. ### Можно ли менять проект из дашборда? Только его категории, из браузера. Все остальное в дашборде доступно только для чтения. --- # /lagune: защищайте код, пока его пишет ИИ > Создавайте то, что просите, и усиливайте защиту прямо во время написания, следуя принципам безопасности и без процесса, которому нужно следовать. Канонический URL: https://lagune.ai/ru-RU/docs/commands/lagune Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/lagune Последнее обновление: 2026-11-03 ⌨️ Выполняет работу, о которой вы попросили, и защищает ее прямо во время написания. **`/lagune`** принимает любой промпт на любом этапе, создает то, что вы хотели, и защищает результат безопасными настройками по умолчанию, прежде чем вернуть его вам. ## Использование Добавьте **`/lagune`** к любому промпту и опишите работу, как обычно. **📘 Инструкции для агента** ```md # Инструкции моего проекта для агентов ## Безопасность - Используй навык `/lagune` каждый раз, когда создаешь или меняешь код, чтобы он повышал безопасность по умолчанию. ``` - Например: **AGENTS.md**, **CLAUDE.md**, **.github/copilot-instructions.md**, **.cursorrules** и т. д. **💬 Функция** ```prompt /lagune дай пользователям загружать собственное фото в профиль. ``` **💬 Исправление** ```prompt /lagune когда пользователь отправляет форму, ничего не происходит. Разберись, в чем может быть дело, и исправь. ``` **💬 Рефакторинг** ```prompt /lagune раздели и улучши логику обработки payload ``` **Принципы безопасности необязательны, но с ними лучше** **`/lagune`** работает как с принципами безопасности, так и без них. Если они есть, собственные правила вашего проекта определяют каждую сборку. Задайте их один раз с помощью [`/lagune-charter`](https://lagune.ai/ru-RU/docs/commands/charter). ## Как это работает Команда оборачивает работу в три шага и ничего не записывает в Lagune: 1. Загружает ваши принципы безопасности, если они есть, и они управляют всей работой, а если их пока нет, используется базовый уровень, безопасный по умолчанию. 2. Получает [каталог](https://lagune.ai/ru-RU/docs/catalog) вашего проекта и загружает только специализации, которые затрагивает ваша работа, те же знания по запросу, что использует процесс аудита. 3. Применяет защиту прямо во время написания кода, а затем перечитывает собственный результат, чтобы убедиться, что меры защиты действительно работают, прежде чем вернуть работу вам. Результат: работающий код в вашем проекте, безопасный с первой строки. **Используйте в любой момент** Ни detect, ни plan, ни уборки потом. **`/lagune`** одинаково подходит и для нового каркаса проекта, и для изменения в зрелой кодовой базе и усиливает защиту по ходу работы, а не потом. ## Чего она не делает - Ничего не записывает в директорию `.lagune`, ни артефактов, ни отслеживания, поэтому единственный ее результат: защищенный код, о котором вы просили. - Не ослабляет правило ради промпта: если то, о чем вы попросили, нарушает принцип безопасности, команда сначала останавливается и сообщает вам об этом, а не создает небезопасный вариант. ## Частые вопросы ### Что делает /lagune? Принимает любой промпт на любом этапе, создает то, что вы попросили, и защищает результат безопасными настройками по умолчанию, прежде чем вернуть его вам. Защита применяется прямо во время написания кода, а не потом. ### Нужны ли принципы безопасности, чтобы использовать /lagune? Нет. Команда работает как с ними, так и без них. Если принципы безопасности есть, собственные правила вашего проекта определяют каждую сборку. Если их нет, используется базовый уровень, безопасный по умолчанию. ### Чем /lagune отличается от процесса Blue Team? /lagune защищает новую работу прямо во время написания, без процесса, которому нужно следовать. Процесс Blue Team проходит пять фаз аудита по порядку над существующим проектом. ### Отслеживает ли /lagune находки или записывает артефакты? Нет. Команда ничего не записывает в директорию .lagune, ни артефактов, ни отслеживания. Единственный ее результат: защищенный код, о котором вы просили. ### Как сделать так, чтобы агент использовал /lagune автоматически? Добавьте в файл инструкций агента (AGENTS.md, CLAUDE.md, .cursorrules и подобные) указание использовать навык /lagune каждый раз, когда он создает или меняет код. --- # /lagune-charter: задайте принципы безопасности > Задайте принципы безопасности проекта, правила, которые соблюдает каждая следующая фаза, и зафиксируйте категории специализаций, которые подтверждает анализ проекта. Канонический URL: https://lagune.ai/ru-RU/docs/commands/charter Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/charter Последнее обновление: 2026-11-03 🧬 Расскажите **Lagune**, что представляет собой ваш проект, и он превратит это в ваши правила безопасности (а без описания выведет их из самого проекта). Принципы безопасности образуют управляющий уровень: набор принципов с приоритетом безопасности, которые обязана соблюдать каждая следующая фаза. Считайте их проверкой во время компиляции для уровня защищенности вашего проекта. ## Использование **Описать проект** ```prompt /lagune-charter Мой проект: интернет-магазин видеоигр. Покупатели добавляют товары в корзину и платят банковской картой или по счету. Они видят свои заказы и статус каждого из них. ``` **Предложение от Lagune** ```prompt /lagune-charter ``` > _Я вижу платежную библиотеку, настройку входа и модель заказа, привязанную к покупателю. Похоже на интернет-магазин, который что-то продает. Покупатели платят и отслеживают свои заказы..._ ☁️ ## Что он выясняет **Lagune** берет ваше описание или **PRD** за основу и выясняет, что из него следует для безопасности, а затем читает проект, чтобы пойти дальше того, что вы назвали. Например: - Корзина, в которой хранятся заказы, означает, что есть **база данных**: - например, `"Где хранятся данные?"`, `"У кого есть к ним доступ?"`, `"Есть ли утечки?"`. - Покупатели, которые видят свои заказы, означают, что есть какой-то **вход в систему или контроль доступа**: - например, `"Может ли один покупатель добраться до заказов другого?"`, `"Защищены ли сессии?"`. - Прием оплаты картой и по счету означает, что **затронуты деньги и чувствительные данные**: - например, `"Хранятся ли данные карт?"`, `"Проверяются ли платежи?"`. Ваше описание и проект дополняют друг друга: описание задает намерение, а чтение зависимостей, README и конфигурации выявляет то, о чем вы не упомянули. Если что-то важное по-прежнему неясно, **Lagune** задает короткий простой вопрос, а не гадает. Отсюда **Lagune** составляет набор правил безопасности, подогнанный под проект, который вы можете просмотреть и скорректировать в любой момент. **Как извлечь максимум** - Вы также можете задать собственные правила безопасности для проекта. - Чем больше относящихся к делу подробностей вы дадите, тем лучше итоговый отчет: - Объясните, что это за проект, как он работает и что происходит внутри. - Кто конечный пользователь? Что пользователи могут делать, а что нет? - Подробности о поведении так же ценны, как технические подробности. - Память принципов безопасности хранится в `.lagune/memory/charter.md`. ## Какие категории он фиксирует Специализации, знания о безопасности, которые следующие фазы загружают по запросу, попадают в [каталог](https://lagune.ai/ru-RU/docs/catalog) проекта по [категориям](https://lagune.ai/ru-RU/docs/categories). Пока у проекта не зафиксировано ни одной категории, charter фиксирует каждую, которую подтверждает анализ проекта, например язык проекта, вызовы LLM или контейнеры, и называет их в своей сводке. Когда категории уже зафиксированы, charter оставляет их как есть и лишь называет категорию, которую проект пока не использует. Меняйте их сами в любой момент: ```bash npx lagune write add --categories python npx lagune write remove --categories python ``` ## Что дальше Когда правила заданы, выявите, что на самом деле делает ваша система: [`/lagune-detect`](https://lagune.ai/ru-RU/docs/commands/detect). ## Частые вопросы ### Что такое принципы безопасности (charter) в Lagune? Принципы безопасности образуют управляющий уровень Lagune, набор принципов с приоритетом безопасности, которые обязана соблюдать каждая следующая фаза. Считайте их проверкой во время компиляции для уровня защищенности вашего проекта. ### Где хранятся принципы безопасности? В .lagune/memory/charter.md. ### Можно ли написать собственные правила безопасности? Да. Lagune предлагает правила на основе вашего описания и кода, а вы можете их переформулировать, убрать, дополнить или сузить их охват. ### Выбирает ли charter категории специализаций? Только пока ни одна не зафиксирована. Тогда он фиксирует каждую категорию, которую подтверждает анализ проекта, например ваш язык или вызовы LLM. Когда категории уже зафиксированы, он никогда их не меняет. --- # /lagune-detect: выявите, что делает система и где ее риски > Прочитайте свой код и выявите, что делает ваша система и где находятся риски. Канонический URL: https://lagune.ai/ru-RU/docs/commands/detect Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/detect Последнее обновление: 2026-11-03 🔬 Узнайте, что на самом деле делает ваша система и где находятся риски. Detect читает код и фиксирует только то, что действительно находит, со свидетельствами, которые нужны следующим фазам. Ее главное правило: обнаруживать, а не выдумывать. ## Использование **Полное сканирование** ```prompt /lagune-detect ``` **Указать пути** ```prompt /lagune-detect src/routes/ src/auth.ts ``` **Описать опасение** ```prompt /lagune-detect убедись, что данные клиентов никогда не раскрываются ``` ## Что она выявляет **Lagune** читает код и описывает то, что находит. Каждая находка содержит, что это такое, почему это важно, и свидетельства. Например: - **Загрузка файлов**, система принимает файлы от пользователей: - _Почему это важно:_ файл, замаскированный под изображение, может скрывать вредоносный код. - _Свидетельство:_ обработчик `POST /upload` доверяет MIME-типу, который присылает клиент, не проверяя настоящий тип файла. - **Вход и сессии**, пользователи входят, чтобы попасть в свою учетную запись: - _Почему это важно:_ слабая работа с сессиями позволяет захватить одну учетную запись из другой. - _Свидетельство:_ логика выдачи сессий, где сессии выдаются без срока действия. Попутно detect выносит каждой специализации из [каталога](https://lagune.ai/ru-RU/docs/catalog) проекта вердикт по коду, применяет те, чей контекст присутствует, и фиксирует их в разделе **Applied specializations**, списке, который повторно используют harden и verify. В результате у вас есть четкая карта того, что делает ваша система и где живут риски, готовая для следующих шагов. **Совет** - Повторный запуск обновляет карту: решенные находки уходят, новые появляются. - Карта обнаружения хранится в `.lagune/memory/detect.md`. ## Что дальше Превратите карту в план: [`/lagune-plan`](https://lagune.ai/ru-RU/docs/commands/plan). ## Частые вопросы ### Что делает /lagune-detect? Читает ваш код и выявляет, что делает система и где находятся риски, фиксируя только то, что действительно находит. Ее правило: обнаруживать, а не выдумывать. ### Что такое находка в Lagune? Находка представляет собой один обнаруженный риск: что это такое, почему это важно, и свидетельства в коде. Это отслеживаемая единица, которую переносят дальше plan, harden и verify. ### Где хранится карта обнаружения? В .lagune/memory/detect.md. ### Какие специализации использует detect? Каждая специализация из каталога проекта получает вердикт по коду. Detect применяет те, чей контекст присутствует, и фиксирует их в разделе Applied specializations. --- # /lagune-plan: оцените находки и спланируйте исправления > Превратите то, что нашла фаза detect, в план защиты, присвоив каждой находке категорию и оценку CVSS v4.0 и подобрав к ней исправление. Канонический URL: https://lagune.ai/ru-RU/docs/commands/plan Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/plan Последнее обновление: 2026-11-03 🛡️ Превратите то, что нашла фаза detect, в план защиты: присвойте каждой находке категорию и оценку CVSS v4.0, а затем подберите к ней исправление. ## Использование **Спланировать все** ```prompt /lagune-plan ``` **Указать пути** ```prompt /lagune-plan src/routes/upload.ts ``` **Сосредоточиться на опасении** ```prompt /lagune-plan где могут утечь чувствительные данные ``` ## Как это работает Эта фаза продолжает detect. Detect уже выяснила, что делает ваша система и какой риск несет каждая ее часть, поэтому план не повторяет риск, а оценивает, насколько он серьезен, и решает, что с ним делать. Plan никогда не читает код, и это заставляет каждое исправление указывать на то, что detect действительно обнаружила. Она оценивает каждую находку по методу CVSS v4.0: категория, вектор CVSS v4.0, выведенный из того, что зафиксировали detect и принципы безопасности, и рассчитанный [хуком `cvss`](https://lagune.ai/ru-RU/docs/hooks/cvss), и диапазон приоритета, в который попадает эта оценка. Каждое исправление также указывает принцип безопасности, который оно поддерживает. Например: - **Загрузка файлов** (приоритет: **Critical**) - _Категория:_ неограниченная загрузка файлов (CWE-434). - _CVSS:_ CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N (9.3, Critical). - _Почему такой приоритет:_ любой может добраться до загрузки через интернет, а она находится на сервере, где хранятся файлы клиентов. - _Поддерживает:_ III. Любой ввод считается недоверенным, пока не проверен. - _Исправление:_ проверять настоящий тип и размер файла, переименовывать его при сохранении и хранить загрузки там, где их нельзя выполнить как код. В результате у вас есть оцененный и упорядоченный по приоритету список исправлений, каждое из которых привязано к находке и готово к применению в следующей фазе. Оценка вычисляется, а не прикидывается: вектор содержит открытость проекта и ставки в виде метрик Environmental, и любой может вставить его в калькулятор FIRST или NVD и получить ту же оценку. **Совет** - Фаза целиком опирается на detect. Если файл или опасение так и не были выявлены, она попросит сначала запустить для них `/lagune-detect`. - Повторный запуск обновляет план: выполненные исправления уходят, новые появляются. - План защиты хранится в `.lagune/memory/plan.md`. **Зависит от detect** Plan работает только с тем, что уже выявила [`/lagune-detect`](https://lagune.ai/ru-RU/docs/commands/detect), поэтому сначала запустите detect. ## Что дальше Примените план: [`/lagune-harden`](https://lagune.ai/ru-RU/docs/commands/harden). ## Частые вопросы ### Как Lagune расставляет приоритеты уязвимостей? /lagune-plan присваивает каждой находке категорию и оценку CVSS v4.0, рассчитанную хуком cvss, а затем подбирает к ней исправление. ### Использует ли Lagune CVSS v4.0? Да. Каждая находка получает вектор и оценку CVSS v4.0, которые рассчитывает хук cvss по той же арифметике, что и калькулятор FIRST, поэтому любой может вставить туда вектор и заново получить оценку. ### Читает ли план мой код? Нет. Plan никогда не читает код, и это заставляет каждое исправление указывать на то, что detect действительно обнаружила. --- # /lagune-harden: примените исправления безопасности к коду > Примените исправления из плана к своему коду, безопасно и по одному. Канонический URL: https://lagune.ai/ru-RU/docs/commands/harden Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/harden Последнее обновление: 2026-11-03 🔧 Примените исправления из плана к своему коду, безопасно и по одному. ## Использование **Применить все** ```prompt /lagune-harden ``` **Указать пути** ```prompt /lagune-harden src/routes/upload.ts ``` **По приоритету** ```prompt /lagune-harden критический и высокий приоритет ``` ## Как это работает План уже определил каждое исправление, поэтому harden просто применяет его. Это единственная фаза, которая трогает ваш код, поэтому она действует осторожно: применяет исправления по одному, чтобы каждое изменение было легко проверить, и никогда не ослабляет меру защиты, чтобы исправление подошло. Например, исправление загрузки: - **Загрузка файлов** (статус: **Applied**) - _Что изменилось:_ проверяет настоящий тип и размер файла, отклоняет все неожиданное, переименовывает файл при сохранении и хранит его там, где его нельзя выполнить как код. - _Где:_ функция `handleUpload` и вспомогательная функция хранилища, которую она вызывает. Если исправление нельзя применить полностью, harden делает то, что может сделать безопасно, а остальное помечает как **Partial** или **Blocked**, оставляя его открытым. **Применено не значит проверено** Applied еще не означает, что исправление доказано. Для этого нужна [verify](https://lagune.ai/ru-RU/docs/commands/verify). **Совет** - Фаза целиком опирается на план. Если исправление или файл так и не попали в план, она попросит сначала запустить для них `/lagune-plan`. - Повторный запуск сверяет журнал: отмененные изменения уходят, новые примененные исправления появляются. - Журнал усиления защиты хранится в `.lagune/memory/harden.md`. **Зависит от plan и меняет ваш код** Harden опирается на [`/lagune-plan`](https://lagune.ai/ru-RU/docs/commands/plan). Это единственная фаза, которая меняет ваш код. ## Что дальше Докажите, что каждое исправление действует: [`/lagune-verify`](https://lagune.ai/ru-RU/docs/commands/verify). ## Частые вопросы ### Меняет ли /lagune-harden мой код? Да. Это единственная фаза, которая трогает ваш код: она применяет исправления из плана по одному. ### Что означают Applied, Partial и Blocked? Это статусы, которые Lagune фиксирует для каждого исправления. Applied означает, что исправление внесено, Partial означает, что внесена только его часть, Blocked означает, что его не удалось применить. Applied еще не означает, что исправление доказано. ### Применяет ли Lagune исправления, не спрашивая? Нужно ли ваше одобрение для правки, решает ваш агент и режим разрешений, в котором вы его запускаете, а не Lagune, который не добавляет собственного шага подтверждения. При этом он никогда не ослабляет меру защиты ради исправления, а если исправление противоречит правилу из принципов безопасности, он сначала останавливается и сообщает вам об этом. --- # /lagune-verify: докажите, что меры защиты действуют > Докажите, что каждое примененное исправление действует, и закройте те, что прошли проверку. Канонический URL: https://lagune.ai/ru-RU/docs/commands/verify Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/verify Последнее обновление: 2026-11-03 ⚖️ Докажите, что каждое примененное исправление действует, прочитав код и сопоставив его с тем, что зафиксировала harden, а затем закройте те, что прошли проверку. ## Использование **Проверить все** ```prompt /lagune-verify ``` **Указать пути** ```prompt /lagune-verify src/routes/upload.ts ``` **По приоритету** ```prompt /lagune-verify критический и высокий приоритет ``` ## Как это работает Фаза читает код в каждом месте, которое зафиксировала harden, и подтверждает, что он действительно соответствует заявленному. Доказательством служит само это сопоставление кода с журналом. Каждая мера защиты получает один из трех вердиктов: | Вердикт | Значение | | ---------------------------- | -------------------------------------------------------------------- | | ✅ Risk closed | Код делает ровно то, что заявлено в журнале. | | ❌ Risk not closed | Мера защиты все еще открыта. Verify отправляет вас обратно к harden. | | ❓ Cannot tell from the code | Свидетельств не видно в одном только коде. | Риск, доказанно закрытый, затем снимается с учета во всей цепочке с вашего подтверждения. Например: - **Загрузка файлов** (вердикт: **✅ Risk closed**) - _Как доказано:_ прочитан обработчик загрузки, и видно, что он определяет настоящий тип файла по содержимому, ограничивает размер и отклоняет все остальное, ровно как заявлено в журнале. - _Свидетельство:_ функция `handleUpload`, которая определяет настоящий тип файла по содержимому. Если риск не закрыт, verify прямо говорит об этом и отправляет вас обратно к [`/lagune-harden`](https://lagune.ai/ru-RU/docs/commands/harden), поскольку исправление все еще открыто. **Совет** - Фаза целиком опирается на журнал усиления защиты. - Она читает код только для того, чтобы вынести суждение, и никогда не ослабляет меру защиты и не переписывает код, чтобы вердикт прошел. - Повторный запуск сверяет вердикты: устаревшие уходят, а риск, который больше не закрыт, снова помечается. - Когда риск доказанно закрыт, фаза один раз спрашивает подтверждение, а затем убирает эту находку из всей цепочки (detect, plan, harden и отслеживание). - Она не пишет собственного отчета: каждый вердикт хранится в блоке своей меры защиты в `.lagune/memory/harden.md`, где harden прочитает его при следующем запуске. **Зависит от harden** Verify опирается на [`/lagune-harden`](https://lagune.ai/ru-RU/docs/commands/harden). ## Цикл закрывается Когда все в пределах охвата снято с учета, цикл приходит в состояние покоя. Он открывается снова, только когда меняется код. Безопасность закрываема, поэтому у процесса есть конечное состояние, а не бесконечный цикл. ## Частые вопросы ### Как Lagune проверяет исправление? /lagune-verify читает код, сопоставляет его с тем, что зафиксировала harden, и выносит один из трех вердиктов: Risk closed, Risk not closed или Cannot tell from the code. ### Что значит снять находку с учета? Когда verify доказывает, что риск закрыт, находка снимается с учета: с вашего подтверждения она удаляется из всей цепочки, чтобы ее больше не обрабатывали повторно. ### Может ли работа по безопасности когда-нибудь закончиться? Да. SDH закрываем: доказанно закрытая находка снимается с учета, поэтому у процесса есть конечное состояние, а не бесконечный цикл. --- # Категории > Категории специализаций, которые может использовать проект Lagune, от OWASP до усиления защиты под конкретные языки, такие как JavaScript, Python, Go и Rust, и как их менять. Канонический URL: https://lagune.ai/ru-RU/docs/categories Язык: ru-RU Оригинал: https://lagune.ai/docs/categories Последнее обновление: 2026-11-03 **Lagune** группирует свои встроенные [**специализации**](https://lagune.ai/ru-RU/docs/catalog) по категориям, всего их **13**. Категории, которые использует проект, определяют, какие встроенные специализации попадут в его [**каталог**](https://lagune.ai/ru-RU/docs/catalog), и делятся на две группы: что делает система и на чем она написана. Пока не зафиксировано ни одной категории, проект использует только `owasp`. [`/lagune-charter`](https://lagune.ai/ru-RU/docs/commands/charter) фиксирует каждую категорию, которую подтверждает анализ проекта, а вы можете менять их сами в любой момент. ## Что делает система | Категория | Ключ | Что она защищает | | -------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | OWASP | `owasp` | Риски безопасности приложений, которые отслеживает OWASP: инъекции, нарушение контроля доступа, сбои аутентификации и криптографии | | Инфраструктура | `infra` | Конфигурация контейнеров, рабочих нагрузок и serverless: Dockerfile, Compose, безопасность подов, IAM и триггеры FaaS | | ИИ / LLM | `ai` | Интеграции с ИИ и LLM, от prompt injection и небезопасного подключения инструментов, агентов, поиска данных и MCP | | Lovable | `lovable` | Сгенерированные ИИ приложения на Supabase (Lovable и подобные): пробелы в RLS, утечки ключей `service_role` и небезопасные настройки по умолчанию | ## На чем она написана | Категория | Ключ | Что она защищает | | ---------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------- | | JavaScript | `javascript` | RCE через `eval` и `child_process`, path traversal и prototype pollution во всех его средах выполнения | | Python | `python` | RCE через десериализацию `pickle` и YAML, обход через строки `str.format` и class pollution | | Rust | `rust` | Некорректные `unsafe` API, неправильное использование `transmute`, целочисленное переполнение и неопределенное поведение на границе FFI | | C / C++ | `c-cpp` | Ошибки форматных строк, переполнения буфера и запись за границами памяти, ведущие к выполнению кода | | PHP | `php` | Обход аутентификации через type juggling, цепочки гаджетов object injection и небезопасные настройки по умолчанию | | Go | `go` | Ошибки с typed nil в интерфейсах, data races в горутинах и небезопасная конкурентность на путях безопасности | | Java | `java` | Цепочки гаджетов десериализации `ObjectInputStream`, ведущие к удаленному выполнению кода | | Ruby | `ruby` | Цепочки гаджетов десериализации `Marshal.load` и YAML, ведущие к удаленному выполнению кода | | .NET / C# | `dotnet` | RCE через десериализацию `BinaryFormatter` и обходы кодировщиков, ведущие к XSS | **Совет** **Lagune** не зависит от языка: весь процесс читает проект, на каком бы языке он ни был написан, а эти категории лишь добавляют глубины в ловушках, характерных для конкретного языка. ## Добавляйте и убирайте в любой момент Категория служит отправной точкой, а не обязательством. Используйте то, что подходит проекту сейчас, и меняйте в любой момент по ключу с помощью `write add` и `write remove`. `--categories` без значения открывает в терминале интерактивный выбор (пробел переключает, enter подтверждает, пустой выбор пропускает). Вне терминала передайте категории после флага. **Добавить** ```bash npx lagune write add --categories # interactive npx lagune write add --categories owasp npx lagune write add --categories owasp rust ``` **Убрать** ```bash npx lagune write remove --categories # interactive npx lagune write remove --categories owasp npx lagune write remove --categories owasp rust ``` Первый `write add` или `write remove` начинает с `owasp`, поэтому если убрать все категории, останется пустой список, а не значение по умолчанию. Каждое изменение попадает в `.lagune/configs.json`, поэтому вся команда работает с одним и тем же набором. ## Посмотрите, что использует проект `read list --categories` показывает каждую категорию и то, использует ли ее проект: ```bash npx lagune read list --categories # Categories # • owasp [used] Harden against the application security risks OWASP tracks # • javascript [available] Harden JavaScript and its runtimes # • php [available] Harden PHP against type-juggling auth bypass # • go [available] Harden Go against typed-nil interface bugs # ... # # No category is recorded yet, so this project uses the default: owasp. ``` Какие специализации входят в каждую категорию, смотрите в разделе [**Каталог**](https://lagune.ai/ru-RU/docs/catalog). Ваши собственные специализации, написанные с помощью [`/lagune-specialize`](https://lagune.ai/ru-RU/docs/commands/specialize), попадают в каталог при любых категориях. ## Частые вопросы ### Как добавить категорию? Передайте ключ категории в --categories, например npx lagune write add --categories javascript. Пока не зафиксировано ни одной категории, charter также фиксирует категории, которые подтверждает анализ проекта. ### Можно ли использовать несколько категорий? Да. Перечислите их в одной строке одну за другой. ### Какую категорию стоит использовать проекту? Начните с owasp, значения по умолчанию, затем добавьте категорию для своего языка или стека. Специализации загружаются только по запросу, поэтому категория ничего не стоит, пока фазе не понадобится одна из ее специализаций. --- # Каталог: специализации по безопасности по запросу > Как загружаются специализации из каталога вашего проекта: фазой по запросу и вами напрямую. Канонический URL: https://lagune.ai/ru-RU/docs/catalog Язык: ru-RU Оригинал: https://lagune.ai/docs/catalog Последнее обновление: 2026-11-03 🧠 Специализации **Lagune** представляют собой профильные модули знаний о безопасности, независимые от языка, которые загружаются только по запросу и никогда по умолчанию. Это не команды. Каталог вашего проекта образует набор, который он использует: встроенные специализации его [категорий](https://lagune.ai/ru-RU/docs/categories) плюс собственные. Фазы detect и verify обращаются к ним во время работы, а вы можете загрузить любую напрямую в любой момент. **Обзор** *Интерактивный обзор каталога находится на веб-странице. Все встроенные специализации перечислены в таблице ниже.* **Как это работает** ## Запуск вручную Чтобы использовать специализацию напрямую, попросите агента загрузить ее с помощью `read catalog ` и напишите задачу в том же промпте. Тогда знания применяются к тому, о чем вы попросили. Это работает в любом промпте, даже не связанном с процессом **Lagune**. Например, прямой промпт в свободной форме, чтобы создать безопасную коллекцию **RegExp** на **Python**: ```prompt Загрузи специализацию regex с помощью `npx lagune read catalog regex`, затем создай в @src/utils/regex.py коллекцию регулярных выражений для проверки email-адресов и имен пользователей. ``` Так детерминированный хук проверяет каждое **RegExp** на **ReDoS**, оставляет безопасные и выдает примерно такой результат: ```python import re EMAIL = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$") USERNAME = re.compile(r"^[a-zA-Z0-9_]{3,20}$") def is_email(value: str) -> bool: return EMAIL.match(value) is not None def is_username(value: str) -> bool: return USERNAME.match(value) is not None ``` **Попробуйте проверку ReDoS** Проверьте шаблон сами на [**devina.io/redos-checker**](https://devina.io/redos-checker). ## Встроенные специализации Встроенные специализации сгруппированы по [**категориям**](https://lagune.ai/ru-RU/docs/categories). Вот набор, который поставляется с **Lagune**: | Специализация | Категория | Фокус | | --------------------- | --------------------------- | -------------------------------------------------------------------------------------------------------- | | `regex` | `owasp` | **ReDoS:** шаблоны, время работы которых взрывается на специально сформированном вводе. | | `network` | `owasp` | **SSRF и перенаправления:** адреса загрузки или перенаправления, заданные пользователем. | | `interpreter` | `owasp`, `lovable` | **Внедрение кода:** `eval`, динамическое подключение, вызов по имени. | | `sql` | `owasp` | **Реляционные базы данных:** инъекции, сырые вызовы ORM, привилегии, возможности движка СУБД. | | `path` | `owasp` | **Пути файловой системы:** traversal, нулевой байт, потоки NTFS, подброс файлов. | | `upload` | `owasp` | **Загрузка файлов:** тип и сигнатура, вредоносное содержимое, хранение, лимиты. | | `access-control` | `owasp`, `lovable` | **Аутентификация, авторизация, сессии:** IDOR, mass assignment, арендаторы, сессии. | | `credential-endpoint` | `owasp`, `lovable` | **Подбор и боты:** brute force, password spraying, credential stuffing, ограничение частоты. | | `federation` | `owasp` | **Доверие к токенам:** OAuth/OIDC, SAML, проверка JWT, вход по QR-коду. | | `http-request` | `owasp` | **Происхождение запросов:** CSRF, ошибки настройки CORS, подмена IP клиента. | | `transport` | `owasp` | **Безопасность канала:** настройка TLS, HTTPS и открытый текст, HSTS, pinning. | | `crypto` | `owasp`, `lovable` | **Криптография данных в состоянии покоя:** слабые или самодельные алгоритмы, CSPRNG, управление ключами. | | `secrets` | `owasp`, `lovable` | **Жестко заданные учетные данные:** ключи, токены, пароли в виде литералов в исходном коде. | | `api-endpoint` | `owasp` | **Интерфейсы помимо REST:** GraphQL, gRPC, авторизация WebSocket, DoS, схема. | | `payment` | `owasp`, `lovable` | **Оформление заказа:** проверка платежного шлюза на сервере, подписанные колбэки, идемпотентность. | | `xml` | `owasp` | **Разбор XML:** XXE, внешние сущности, расширение billion laughs. | | `csv` | `owasp` | **Инъекция формул:** ячейки таблицы, начинающиеся с `=`/`+`/`-`/`@`. | | `container` | `owasp`, `infra` | **Конфигурация контейнеров:** root, capabilities, монтирование сокета, усиление защиты образа. | | `infra` | `infra` | **Инфраструктура как код:** Terraform, Dockerfile, GitHub Actions. | | `serverless` | `owasp`, `infra`, `lovable` | **Функции FaaS:** IAM с минимальными привилегиями, входные данные событий, контекст, секреты. | | `llm` | `ai`, `lovable` | **Риски ИИ и LLM:** prompt injection, агентность, RAG, MCP, вывод. | | `supabase` | `lovable` | **Бэкенд на Supabase:** RLS выключен по умолчанию, политики, ошибочно сгенерированные ИИ, модель ключей. | | `browser` | `javascript`, `lovable` | **Риски на стороне клиента:** XSS, CSP, фрейминг, хранилище и т. д. | | `javascript` | `javascript` | **Риски на уровне языка:** RCE, prototype pollution и т. д. | | `python` | `python` | **Риски на уровне языка:** RCE через `pickle`, class pollution, `-O` и т. д. | | `rust` | `rust` | **Корректность `unsafe`:** UB из безопасного вызывающего кода, `transmute`, переполнение. | | `java` | `java` | **Десериализация и мобильный код:** цепочки `readObject`, перехват объектов. | | `ruby` | `ruby` | **Десериализация и `open`:** восстановление объектов через `Marshal`/YAML, особенность с pipe. | | `php` | `php` | **Type juggling и `unserialize`:** magic hashes, POP-цепочки. | | `go` | `go` | **Typed nil и data races:** `nil != nil`, горутины с общей памятью. | | `c-cpp` | `c-cpp` | **Форматные строки:** `printf(user_input)`, write-what-where через `%n`. | | `dotnet` | `dotnet` | **Риски на уровне платформы:** RCE через `BinaryFormatter`, `@Html.Raw`, пробелы в enum. | Большая часть встроенных знаний взята из OWASP. Полное соответствие каждой специализации ее каноническим страницам атак и Cheat Sheet от OWASP смотрите в разделе [**Источники OWASP**](https://lagune.ai/ru-RU/docs/references/owasp-sources). Несколько модулей для конкретных стеков опираются на рекомендации самих производителей: например, `supabase` основан на документации Supabase и CVE-2025-48757. ## Ваши собственные специализации Встроенные специализации пополняются добавлением одного файла знаний и одной строки индекса, а не новой команды. Собственные вы добавляете так же, с помощью [`/lagune-specialize`](https://lagune.ai/ru-RU/docs/commands/specialize): укажите статью или тему, и команда превратит ее в новую специализацию в вашем проекте, файл в `.lagune/catalog/` и запись в `.lagune/configs.json`. Ваши собственные специализации всегда входят в каталог, какие бы категории в нем ни были, а ваша специализация перекрывает встроенную с тем же именем. **Внутри Lagune загружает специализации автоматически, по запросу** Когда фаза detect или verify сталкивается с контекстом, который охватывает специализация, она сама загружает эту специализацию с помощью `read catalog `. Это происходит автоматически, как часть фазы. Делать это вручную не нужно. ## Узнайте, что доступно Чтобы получить каталог проекта в терминале, по одной специализации на строку с ее тегами: ```bash npx lagune read catalog # regex: Regular Expression [required] # network: Requests, Webhook, URL Fetch, Socket, IMDS, Redirect # interpreter: Evaluator, Sink, Shell, Dynamic Execution # ... ``` Специализация `[required]` применяется всегда, какой бы ни была работа. Какие встроенные специализации попадают в список, зависит от [**категорий**](https://lagune.ai/ru-RU/docs/categories) вашего проекта. **Специализации не загружаются по умолчанию** Нужные знания подключаются под то, чем проект является на самом деле, а не все проверки запускаются по умолчанию. ## Частые вопросы ### Что такое специализация Lagune? Профильный модуль знаний о безопасности, независимый от языка, который загружается только по запросу и никогда по умолчанию. Это не команда, как навыки агента. ### Что такое каталог проекта? Специализации, которые использует проект: встроенные специализации его категорий плюс собственные. Пока не зафиксировано ни одной категории, используется только OWASP. ### Загружаются ли специализации по умолчанию? Нет. Они загружаются только по запросу, под то, чем проект является на самом деле. ### Как загрузить специализацию напрямую? В том же промпте, где описана задача, попросите агента выполнить npx lagune read catalog . --- # /lagune-specialize: обучите специализацию по безопасности обычным текстом > Превратите источник или тему по безопасности, которые вы даете, в новую специализацию, загружаемую по запросу. Канонический URL: https://lagune.ai/ru-RU/docs/commands/specialize Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/specialize Последнее обновление: 2026-11-03 🎓 Обучите **Lagune** новой специализации на основе источника или темы, которые вы даете. Команда читает материал и сводит его к профильной специализации, ориентированной только на защиту и устроенной точно так же, как [встроенные](https://lagune.ai/ru-RU/docs/catalog), чтобы фазы detect и verify потом загружали ее как любую другую. Она только проводит аудит и объясняет: никогда не пишет атакующие входные данные или эксплойты и никогда не трогает ваш код. **Из статьи** ```prompt # Ссылка или источник: Lagune превращает его в защиту /lagune-specialize https://owasp.org/www-community/attacks/SQL_Injection ``` **Из эксплойта** ```prompt # Атака в качестве источника: специализация все равно описывает защиту /lagune-specialize "' OR 1=1 -- встраивает SQL в текст запроса" ``` **Из темы** ```prompt # Или просто назови, что нужно охватить /lagune-specialize SQL injection ``` **Атака может быть источником, но никогда результатом** Указать на атаку можно, если цель в том, чтобы от нее защититься: разбор эксплойта служит учебным материалом, который команда превращает в защиту. Специализация, которую она создает, всегда проводит аудит и объясняет и никогда не дает работающий эксплойт, атакующую нагрузку или способ обхода обнаружения. ## Что она записывает Результат: два файла в вашем проекте, которые коммитятся и проверяются вместе с кодом: - Специализация в `.lagune/catalog/.md`, устроенная как [встроенные](https://lagune.ai/ru-RU/docs/catalog). - Ее запись в `.lagune/configs.json`, где проект индексирует собственные специализации, чтобы каталог объединил их со встроенными. Затем команда получает каталог, чтобы убедиться, что новая запись в нем есть. Ваши собственные специализации всегда входят в каталог, какие бы категории в нем ни были. Вам не нужно добавлять команду или трогать пакет: новая специализация представляет собой один файл знаний и одну запись в индексе, записанные в ваш собственный проект. ## Уточнять, а не перезаписывать Если специализация с таким именем уже есть, будь то встроенная, например `regex`, или та, которую вы создали раньше, команда **сверяет** текущий файл, а не заменяет его. Она читает то, что там есть, вплетает новые знания, сохраняет то, что по-прежнему верно, и переписывает то, что изменилось. Ничего не отбрасывается без просмотра. Ваша специализация перекрывает встроенную с тем же именем, поэтому вы можете отточить встроенную под свой проект, не теряя ее. **Совет** - Новая специализация загружается точно так же, как встроенная: фазы detect и verify подхватывают ее по запросу, или загрузите ее сами командой `npx lagune read catalog ` и дайте ей задачу. - Если у материала есть узнаваемое происхождение (статья, автор, ссылка, стандарт), специализация указывает его. Голая тема источника не имеет. **Примечание** **Она запускается, только когда вы ее вызываете:** агент никогда не запускает ее сам. ## Частые вопросы ### Как добавить собственную специализацию по безопасности? Запустите /lagune-specialize с источником или темой. Команда превратит его в специализацию, ориентированную только на защиту, и запишет ее в .lagune/catalog/.md вместе с записью в .lagune/configs.json. ### Может ли Lagune учиться на разборе эксплойта? Да, как на источнике, но никогда в качестве результата. Атака может быть источником, но никогда продуктом. Specialize никогда не пишет атакующие входные данные или эксплойты. ### Перезаписывает ли specialize встроенные специализации? Нет. Она уточняет, а не перезаписывает. --- # /lagune-prove: proof of concept только для защиты > Превратите каждую обнаруженную находку в запускаемый proof of concept (PoC), ориентированный только на защиту, и бюллетень для ответственного раскрытия. Канонический URL: https://lagune.ai/ru-RU/docs/commands/prove Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/prove Последнее обновление: 2026-11-03 🧪 Превратите каждую обнаруженную находку в запускаемое свидетельство, ориентированное только на защиту, для ответственного раскрытия. Для каждой находки из карты обнаружения команда пишет самодостаточный бюллетень и тест, который проверяет **безопасный путь**, поэтому тест падает, пока проблема существует, и проходит, как только код исправлен. **Совет** Тесты **Lagune** хранятся изолированно в `.lagune/`, отдельно от вашего собственного набора тестов. ## Использование **Все находки** ```prompt /lagune-prove ``` **Находка по имени** Посмотрите находки, которые уже отслеживаются по имени: ```prompt npx lagune read list --findings # Findings # ... # • SQL injection при поиске пользователя # ... ``` ```prompt # Затем докажи одну из них /lagune-prove SQL injection при поиске пользователя ``` ## Как это работает Команда читает исходный код, на который указывает каждая находка, и для каждой доказанной находки создает в `.lagune/proofs/` директорию ровно с двумя файлами: | Файл | Что это | | ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- | | `report.test.mjs` (или `.cjs`) | Тест. Он запускается на Poku, если ваш проект уже его использует, а иначе на встроенном раннере Node.js, поэтому ничего устанавливать не нужно. | | `report.md` | Самодостаточный бюллетень: критичность, последствия, как воспроизвести и команда запуска, понятный сам по себе. | Доказательства всегда пишутся на JavaScript, поэтому они переносимы, на каком бы языке ни был написан ваш проект. Индекс `README.md` ссылается на каждое доказательство и дает одну команду, чтобы запустить их все. **Совет** - Команда **необязательна и автономна**: она не входит в пять фаз и не является частью цепочки отслеживания. - Она пишет только в `.lagune/proofs/` и никогда не трогает артефакты фаз или ваш код, который она только читает. - Находка, тест которой не воспроизводит проблему, не получает доказательства, и команда попросит запустить [`/lagune-detect`](https://lagune.ai/ru-RU/docs/commands/detect) для этого места, чтобы сверить данные. - Повторный запуск сверяет доказательства: директория находки, которой больше нет или которая больше не воспроизводится, удаляется. **Примечание** **Она запускается, только когда вы ее вызываете:** агент никогда не запускает ее сам. **Опирается на detect** Prove читает карту обнаружения от [`/lagune-detect`](https://lagune.ai/ru-RU/docs/commands/detect), поэтому сначала запустите detect. ## Только защита и только с разрешения Прежде чем что-либо создавать, команда убеждается, что у вас есть разрешение тестировать цель, и отказывает в любом запросе на работающий эксплойт, атакующую нагрузку или обход обнаружения. Доказательство демонстрирует безопасное поведение и никогда не содержит атакующих входных данных. ## От доказательства к раскрытию Два файла каждой доказанной находки вместе помещаются в **приватный GitHub Gist**, чтобы сообщить об уязвимости. Они свидетельствуют о существующей нераскрытой проблеме, поэтому `.gitignore` внутри `.lagune/proofs/` не пускает их ни в один коммит: делитесь ими только через этот Gist, пока мейнтейнеры не устранят проблему. Закрывать находку в цепочке **Lagune** по-прежнему должны [`/lagune-harden`](https://lagune.ai/ru-RU/docs/commands/harden) и [`/lagune-verify`](https://lagune.ai/ru-RU/docs/commands/verify): prove создает свидетельства, но ничего не закрывает. ## Частые вопросы ### Создает ли Lagune эксплойты? Нет. /lagune-prove пишет свидетельства, ориентированные только на защиту: тест, который проверяет безопасный путь, поэтому падает, пока проблема существует, и проходит, как только код исправлен, а также бюллетень для ответственного раскрытия. ### Что создает prove? Два файла на каждую находку: тест (report.test.mjs или .cjs) и бюллетень (report.md). ### Как ответственно раскрыть ошибку, которую нашел Lagune? Prove пишет самодостаточный бюллетень, которым можно поделиться через приватный канал, например приватный GitHub Gist, следуя принципам ответственного раскрытия. --- # Хук agent: обнаружение неограниченных циклов агентов > Проверьте кодовую базу на вызовы агентов и LLM без ограничения шагов или времени или оцените отдельный вызов из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/agent Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/agent Последнее обновление: 2026-11-03 Хук `agent` помечает **среды выполнения агентов, которые крутятся в цикле без ограничения ходов, бюджета или времени**, ту дыру неконтролируемой автономии, через которую специально сформированный ввод превращается в неограниченные расходы или эскалацию через prompt injection. Он **учитывает язык** и охватывает две экосистемы агентных фреймворков: **JavaScript** (среда выполнения `query` из агентного SDK **Claude**) и **Python** (**LangChain**, **LangGraph**, **CrewAI**, **OpenAI Agents**). Это детерминированный движок, стоящий за [специализацией `llm`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами в режиме **scan** или **check**. ## Запуск **Сканировать кодовую базу** ```bash npx lagune read agent # scans the whole project npx lagune read agent --dir src/ai # scans a directory npx lagune read agent --file chat.ts # scans a single file ``` **Проверить вызов** ```bash npx lagune read agent --lang javascript --pattern 'query({ prompt })' # => uncapped npx lagune read agent --lang javascript --pattern 'query({ prompt, options: { maxTurns: 5 } })' # => safe npx lagune read agent --lang python --pattern 'AgentExecutor(agent=a, max_iterations=None)' # => uncapped ``` Каждая строка в разделе **Uncapped agent loops found** находится в файле, который импортирует агентный SDK, и представляет собой либо вызов среды выполнения `query` из агентного SDK Claude без ограничения ходов, бюджета или времени (JavaScript, по умолчанию без ограничений), либо явное снятие ограничения фреймворка по умолчанию, например `max_iterations=None` / `max_turns=None` (Python, по умолчанию с ограничением). В обоих случаях хук завершается с ненулевым кодом. В Vercel AI SDK `generateText`/`streamText` по умолчанию выполняют один шаг (`stopWhen: stepCountIs(1)`), поэтому голый вызов там не может зациклиться и не помечается, а обычный `db.query(...)` никогда не принимается за вызов агента. Если ничего не найдено, выводится `no uncapped agent loops found`. ## Как читать вердикт | Вердикт | Значение | | ---------- | --------------------------------------------------------------------------------------------------- | | `uncapped` | Вызов среды выполнения `query` без ограничения (JS) или явное снятие ограничения (`=None`, Py). | | `safe` | Вызов `query` с ограничением, генерация в один шаг или вызов фреймворка, ограниченный по умолчанию. | | `invalid` | Во фрагменте нет узнаваемого вызова агента, который можно оценить. | ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ------------- | ----------------------------------------------------------------------------------------- | | `--pattern` | фрагмент кода | Проверяет один вызов. Повторите, чтобы проверить несколько, по одному вердикту на строку. | | `--lang` | язык | Обязателен с `--pattern`: `javascript` или `python`. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует весь проект. `--pattern` требует `--lang` и не сочетается с `--dir` или `--file`. **По мере возможностей, а не исчерпывающе** Самописный цикл агента на любом языке недоступен статическому сканированию. Считайте результат надежным минимумом, а не полной инвентаризацией. **Совет** Хук решает только вопрос ограничения: разграничение возможностей, смешение уровней доверия и авторизация остаются вопросами суждения, которые по-прежнему охватывает [специализация `llm`](https://lagune.ai/ru-RU/docs/catalog). ## Частые вопросы ### Зачем ограничивать цикл агента? Агента без ограничений можно загнать в неограниченную рекурсию, расходы или эскалацию через prompt injection. Ограничения maxTurns, maxBudgetUsd, stopWhen или signal сдерживают его, а хук agent помечает вызов среды выполнения query, в котором не задано ни одного из них. --- # Хук cors: аудит источников CORS > Просканируйте исходный код на обходимый список разрешенных источников CORS или оцените отдельное значение источника на избыточно широкий доступ из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/cors Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/cors Последнее обновление: 2026-11-03 Хук `cors` представляет собой детерминированный движок, стоящий за [специализацией `http-request`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами. Он работает в двух режимах одной командой: **сканирование** проверяет исходный код на **обходимый список разрешенных источников** (регулярное выражение для проверки хоста, мимо которого проскальзывает хост злоумышленника), а **оценка** присваивает отдельному значению **источника CORS** вердикт `wildcard`, `null` или `safe`. ## Сканирование кодовой базы Без флага хук сканирует весь проект. **Весь проект** ```bash npx lagune read cors ``` **Директория** ```bash npx lagune read cors --dir src/server ``` **Один файл** ```bash npx lagune read cors --file internal/auth/origin.go ``` Хук перечисляет каждый обходимый список разрешенных источников под одним заголовком, сгруппировав по файлам. Проверка хоста, у которой `.+`/`.*` стоит в части authority перед суффиксом доверенного хоста (`^https?://.+\.trusted\.com`), пропускает хост злоумышленника вроде `your-site.com.attacker.com`. ```text Origin-allowlist patterns with a greedy wildcard (bypassable, review): internal/auth/origin.go ^https?://.+\.trusted\.com ``` Это повод для проверки, а не закрытая находка: по одному тексту нельзя определить, охраняет ли регулярное выражение настоящее решение о доверии, поэтому сканирование никогда не меняет код выхода. Прочитайте каждое и убедитесь, что список разрешенных источников сравнивает значения на полное равенство. Если ничего не найдено, выводится одна строка. ```bash npx lagune read cors --dir src/clean # => no bypassable origin allowlist found ``` ## Оценка источника Передайте каждый источник через `--origin`. Хук выводит по одному слову на источник и завершается с ненулевым кодом при любом `wildcard` или `null`. **Один источник** ```bash npx lagune read cors --origin '*' # => wildcard npx lagune read cors --origin 'null' # => null npx lagune read cors --origin 'https://app.example.com' # => safe ``` **Несколько источников** Повторите `--origin`, чтобы оценить весь список разрешенных источников за один вызов, по одному вердикту на строку, по порядку. ```bash npx lagune read cors \ --origin 'https://app.example.com' \ --origin '*' \ --origin 'null' # => safe # => wildcard # => null ``` | Вердикт | Значение | | ---------- | ------------------------------------------------------------------------------------------------------ | | `safe` | Не `*`, не `null` и не шаблон с `*`. Корректность формы источника не гарантируется. | | `wildcard` | `*` или шаблон поддомена, хоста или порта: ответ может прочитать любой сайт (или широкий круг сайтов). | | `null` | Источник `null`, который могут подделать изолированные iframe и перенаправления. | Разрешением считается только `safe`, а `--origin` служит оракулом значений: он оценивает значение, а не обработчик, поэтому обработчик подтвердите с помощью специализации `http-request`. ### Параметры CLI | Параметр | Значение | Описание | | ---------- | ---------- | ------------------------------------------------------------------------------------------- | | `--origin` | источник | Оценивает одно значение источника. Повторите, чтобы оценить несколько, по одному на строку. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует весь проект. `--origin` включает режим оценки и не сочетается с `--dir` или `--file`. **Чего он не охватывает** Сканирование распознает форму **обходимого регулярного выражения**, а `--origin` оценивает **значения** источников. Два шаблона на уровне исходного кода остаются вне досягаемости: отражение заголовка `Origin` из запроса (сервер возвращает входящий `Origin` обратно или сочетает его с учетными данными) и слишком мягкий список разрешенных источников на основе `endsWith` или поиска подстроки. Распознавайте их в коде и обрабатывайте так, как описывает [специализация `http-request`](https://lagune.ai/ru-RU/docs/catalog). ## Частые вопросы ### Чем опасен источник CORS null? Изолированные iframe и некоторые перенаправления отправляют Origin: null, поэтому список разрешенных источников, доверяющий null, дает этим контекстам доступ на чтение. Хук cors помечает его наравне с wildcard. ### Как поймать обходимый список разрешенных источников CORS? Запустите npx lagune read cors по кодовой базе. Хук помечает регулярное выражение для проверки хоста, у которого жадный шаблон стоит перед доверенным суффиксом, из-за чего хост злоумышленника вроде your-site.com.attacker.com проскальзывает мимо. --- # Хук crypto: обнаружение слабой криптографии > Проверьте кодовую базу на слабые криптографические примитивы или оцените отдельный фрагмент из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/crypto Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/crypto Последнее обновление: 2026-11-03 Хук `crypto` помечает **слабые криптографические примитивы** в месте вызова: устаревший шифр, небезопасный режим или взломанную хеш-функцию. Он **учитывает язык** и читает каждый файл по его собственным правилам, поэтому конструкция Python никогда не помечается в файле Rust. Это детерминированный движок, стоящий за [специализацией `crypto`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами в режиме **scan** или **check**. ## Запуск **Сканировать кодовую базу** ```bash npx lagune read crypto # scans the whole project npx lagune read crypto --dir src # scans a directory npx lagune read crypto --file hash.ts # scans a single file ``` **Проверить фрагмент** ```bash npx lagune read crypto --lang javascript --pattern 'createCipher("aes-256-cbc", k)' # => weak npx lagune read crypto --lang python --pattern 'hashlib.md5(data)' # => review npx lagune read crypto --lang go --pattern 'sha256.Sum256(data)' # => safe ``` Сканирование выводит до двух разделов. **Weak cryptography found** содержит находки (DES/3DES/RC4/Blowfish/RC2, режим ECB): каждая из них представляет собой взломанный примитив шифрования, поэтому хук завершается с ненулевым кодом. **Cryptography to review manually** содержит поводы для проверки, которые хук не может оценить сам: хеш MD5 или SHA-1 (непригоден для целей безопасности, но законен как обычная контрольная сумма, поэтому решает намерение), некриптографический генератор случайных чисел в контексте безопасности или сравнение, уязвимое к атакам по времени. Если ничего не найдено, выводится `no weak cryptography found`. ## Как читать вердикт | Вердикт | Значение | | --------- | -------------------------------------------------------------------------------------------------------------------------------- | | `weak` | Фрагмент использует взломанный примитив шифрования (DES/3DES, RC4, Blowfish, RC2 или режим ECB). | | `review` | Примитив, зависящий от намерения: хеш MD5 или SHA-1 либо некриптографический генератор случайных чисел в контексте безопасности. | | `safe` | Фрагмент использует криптографию, и слабых примитивов не найдено. | | `invalid` | Во фрагменте нет узнаваемой криптографической конструкции, которую можно оценить. | ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ------------- | -------------------------------------------------------------------------------------------------------- | | `--pattern` | фрагмент кода | Проверяет один фрагмент. Повторите, чтобы проверить несколько, по одному вердикту на строку. | | `--lang` | язык | Обязателен с `--pattern`: один из javascript, python, go, java, kotlin, php, ruby, rust, csharp, c, cpp. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует весь проект. `--pattern` требует `--lang` и не сочетается с `--dir` или `--file`. ### Поддерживаемые языки Сканирование читает эти языки, определяя их по расширению файла, и проверяет каждый по его собственным криптографическим API. | Язык | Слабые шифры (находка) и хеши или генераторы случайных чисел (проверка) | | --------------------------- | --------------------------------------------------------------------------------------------------------------- | | **JavaScript / TypeScript** | `createCipher`, `CryptoJS.DES/RC4`, `*-ecb` в кавычках; MD5/SHA-1 `createHash`/`subtle.digest`; `Math.random()` | | **Python** | pycryptodome `DES/ARC4/Blowfish.new`, `algorithms.TripleDES`, `MODE_ECB`; `hashlib.md5/sha1`; `random.*` | | **Go** | `des.NewCipher`, `rc4.NewCipher`, `blowfish.NewCipher`, `NewECBEncrypter`; `md5/sha1.Sum`; `math/rand` | | **Java / Kotlin** | `Cipher.getInstance("DES"/…/ECB")`; `MessageDigest.getInstance("MD5")`, `HmacMD5`; `java.util.Random` | | **PHP** | `openssl_encrypt("des-…"/"…-ecb")`, `mcrypt_*`; `md5()`/`sha1()`, `hash("md5", …)`; `rand()`/`mt_rand()` | | **Ruby** | `OpenSSL::Cipher.new("des-…")`, `:ECB`; `Digest::MD5/SHA1`; `rand()`/`Random` | | **Rust** | `Rc4::`, `Blowfish::`, `des::`, `ecb::`; `Md5::`, `Sha1::`, `Hmac`; `SmallRng`/`XorShiftRng` | | **C#** | `DES/TripleDES/RC2.Create`, `CipherMode.ECB`; `MD5/SHA1.Create`, `HMACMD5`; `new Random()` | | **C / C++** | OpenSSL `DES_*`/`RC4`/`EVP_des_*`, `EVP_*_ecb`; `MD5()`/`SHA1()`, `EVP_md5`; `rand()`/`random()` | **По мере возможностей, а не исчерпывающе** Хук читает исходный код как текст, поэтому примитив, собранный во время выполнения, спрятанный за псевдонимом или записанный в нераспознаваемой форме, может проскользнуть. Считайте таблицу надежной отправной точкой, а не полной инвентаризацией. **Совет** Хук гарантирует минимум (эти конструкции существуют): управление ключами, повторное использование IV и паддинг RSA остаются вопросами суждения, которые по-прежнему охватывает [специализация `crypto`](https://lagune.ai/ru-RU/docs/catalog). ## Частые вопросы ### Как просканировать кодовую базу на слабую криптографию? Запустите хук crypto без флага. Взломанные шифры и режим ECB считаются находками и дают ненулевой код выхода. Хеш MD5 или SHA-1 считается поводом для проверки, поскольку он непригоден для целей безопасности, но законен как обычная контрольная сумма. ### Помечает ли хук crypto Math.random()? Только как повод для проверки в контексте безопасности и никогда как автоматическую находку, поскольку случайность законна для джиттера или порядка элементов в интерфейсе. --- # Хук cvss: оценка вектора CVSS v4.0 > Оценивайте один или несколько векторов CVSS v4.0 из командной строки по той же арифметике, что и калькулятор FIRST, и читайте каждый из них простыми словами. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/cvss Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/cvss Последнее обновление: 2026-11-03 Хук `cvss` оценивает **вектор CVSS v4.0** и выводит его оценку и диапазон критичности, ту оценку, которую [`/lagune-plan`](https://lagune.ai/ru-RU/docs/commands/plan) пишет у каждого исправления, а [`/lagune-prove`](https://lagune.ai/ru-RU/docs/commands/prove) в каждом бюллетене. Это детерминированный движок, стоящий за этими оценками, с той же арифметикой, что и [калькулятор FIRST](https://www.first.org/cvss/calculator/4.0), и вы можете запускать его сами. ## Запуск Передайте каждый вектор через `--vector`. Хук выводит по одной строке на вектор: его оценку и диапазон. **Один вектор** ```bash npx lagune read cvss --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N' # => 9.3, Critical ``` **Несколько векторов** Повторите `--vector`, чтобы оценить несколько сразу, по одной строке на каждый, по порядку. ```bash npx lagune read cvss \ --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N' \ --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N/MAV:A' # => 9.3, Critical # => 8.7, High ``` **Простыми словами** Добавьте `--explain`, чтобы прочитать каждую метрику простыми словами. Если метрики Threat или Environmental сдвигают оценку, сначала выводится одна только оценка Base. ```bash npx lagune read cvss --explain --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N/MAV:A' # => 8.7, High # => Base metrics alone: 9.3, Critical # => Attack Vector: Network, modified to Adjacent # => Attack Complexity: Low # => ... ``` ## Как читать результат | Диапазон | Оценка | | ---------- | -------------- | | `None` | 0.0 | | `Low` | от 0.1 до 3.9 | | `Medium` | от 4.0 до 6.9 | | `High` | от 7.0 до 8.9 | | `Critical` | от 9.0 до 10.0 | Вектор только с метриками Base оценивает саму уязвимость, исходя из худшего: каждое требование безопасности High, а уязвимость атакуют в реальном мире. Метрики Environmental (`MAV` и остальные измененные метрики, а также `CR`, `IR` и `AR`) уточняют оценку для конкретного развертывания, а метрика Threat (`E`) для того, что известно об эксплуатации. Для некорректного вектора выводится `invalid vector:` и описание ошибки, а хук завершается с ненулевым кодом. ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ----------------- | ------------------------------------------------------------------------------------------------- | | `--vector` | вектор `CVSS:4.0` | Оценивает один вектор. Повторите, чтобы оценить несколько, по одной строке на вектор, по порядку. | | `--explain` | | Добавляет каждую метрику простыми словами под каждой строкой с оценкой. | Нужен хотя бы один `--vector`. Вектор никогда не передается как голый позиционный аргумент, поэтому его нельзя принять за флаг. **Почему значение флага** Каждый вектор передается как значение флага и никогда не подставляется в команду. Значение с кавычками или обратными кавычками остается инертным и не может внедриться в оболочку. Всегда заключайте его в одинарные кавычки, чтобы оболочка не раскрыла его раньше. **Чего он не охватывает** Только CVSS v4.0: вектор v2.0, v3.0 или v3.1 отклоняется, а не оценивается, поскольку **Lagune** оценивает каждую находку в v4.0. **Совет** Валидация фазы plan повторяет ту же арифметику для каждой строки CVSS, поэтому оценка, разошедшаяся со своим вектором, отлавливается до того, как план будет принят. ## Частые вопросы ### Как Lagune рассчитывает оценку CVSS? Хук cvss следует эталонному калькулятору FIRST для CVSS v4.0, поэтому вектор получает ровно ту же оценку, что и на сайте FIRST. ### Можно ли оценить им вектор CVSS v3.1? Нет. Lagune оценивает каждую находку в CVSS v4.0, а хук отклоняет любую другую версию, а не оценивает ее. ### Что делает флаг --explain? Читает каждую метрику простыми словами и показывает оценку Base рядом с итоговой, чтобы любой мог увидеть, что говорит вектор и как контекст проекта сдвинул оценку. --- # Хук infra: обнаружение ошибок конфигурации IaC > Проверьте Terraform, Dockerfile и GitHub Actions на ошибки конфигурации или оцените отдельный фрагмент из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/infra Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/infra Последнее обновление: 2026-11-03 Хук `infra` помечает **ошибки конфигурации инфраструктуры как кода**, которые можно определить по самому файлу: сеть, открытую всему миру, разрешение с подстановочным знаком, секрет в манифесте, контейнер, работающий от root, недоверенное значение в оболочке CI. Он читает только файлы IaC (`.tf`/`.tf.json`/`.hcl`, `Dockerfile*`, `.github/workflows/**`). Это детерминированный движок, стоящий за [специализацией `infra`](https://lagune.ai/ru-RU/docs/catalog), в режиме **scan** или **check**. ## Запуск **Сканировать кодовую базу** ```bash npx lagune read infra # scans every IaC file npx lagune read infra --dir infra # scans a directory npx lagune read infra --file Dockerfile # scans a single file ``` **Проверить фрагмент** Передайте фрагмент через `--pattern`, а его тип через `--kind` (`terraform`, `dockerfile` или `github-actions`). ```bash npx lagune read infra --kind terraform --pattern 'actions = ["*"]' # => iam-wildcard npx lagune read infra --kind dockerfile --pattern 'FROM node:20' # => mutable-tag ``` Сканирование выводит до двух разделов. **Infrastructure risks found** дает ненулевой код выхода и содержит дефекты, которые можно определить однозначно (входящий трафик `0.0.0.0/0` на чувствительный порт, инструкцию IAM с подстановочным знаком, секрет в манифесте, `encrypted = false`, незакрепленный git-модуль, образ, который явно запускается от root, `curl | sh`, внедрение в скрипт CI, `permissions: write-all`). **Infrastructure hardening advisories** не меняет код выхода (изменяемый тег базового образа, action, закрепленный по тегу). Если ничего не найдено, выводится `no infrastructure risks found`. ## Как читать вердикт Режим проверки выводит совпавший тег с наивысшей критичностью (например, `public-ingress`, `iam-wildcard`, `root-user`, `curl-pipe`, `script-injection`, `write-all`), рекомендательный тег (`mutable-tag`, `unpinned-action`) или `safe`. Ненулевой код выхода дает только тег уровня находки. ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ----------------------------------------------- | ----------------------------------------------------------------------------- | | `--pattern` | фрагмент | Проверяет один фрагмент. Требует `--kind`. Повторите для нескольких. | | `--kind` | `terraform` \| `dockerfile` \| `github-actions` | Тип, по которому оценивается фрагмент. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует каждый файл IaC в проекте. `--pattern` не сочетается с `--dir` или `--file`. **Совет** Хук ловит грубые, однозначно определяемые случаи: отсутствие шифрования, открытость через `pull_request_target` и правильный охват IAM остаются вопросами суждения, которые по-прежнему охватывает [специализация `infra`](https://lagune.ai/ru-RU/docs/catalog). ## Частые вопросы ### Какие файлы инфраструктуры читает хук infra? Terraform и HCL (.tf, .tf.json, .hcl), Dockerfile, а также YAML рабочих процессов и actions GitHub Actions в .github/. Он добирается до этих файлов, хотя сканеры исходного кода их пропускают. --- # Хук interpreter: поиск точек динамического выполнения кода > Проверьте кодовую базу на точки динамического выполнения кода на разных языках или оцените отдельный фрагмент из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/interpreter Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/interpreter Последнее обновление: 2026-11-03 Хук `interpreter` помечает **точки динамического выполнения кода** (sinks): конструкции, которые превращают данные в исполняемый код или передают их оболочке, от `eval` до нативной десериализации. Он учитывает язык и читает каждый файл по его собственным правилам. Это детерминированный движок, стоящий за [специализацией `interpreter`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами в режиме **scan** или **check**. ## Запуск **Сканировать кодовую базу** ```bash npx lagune read interpreter # scans the whole project npx lagune read interpreter --dir src # scans a directory npx lagune read interpreter --file app.py # scans a single file ``` **Проверить фрагмент** ```bash npx lagune read interpreter --lang javascript --pattern 'eval(x)' # => careful npx lagune read interpreter --lang python --pattern 'json.loads(x)' # => safe ``` Эти точки двойного назначения: дойдет ли до них ввод, на который влияет злоумышленник, статическое сканирование определить не может, поэтому каждое совпадение служит **предостережением для проверки**, а не подтвержденной находкой. Сканирование выводит один раздел **Dynamic-execution sinks to review**, сгруппированный по файлам. Если ничего не найдено, выводится `no dynamic-execution sinks found`. **Читайте помеченный код, но никогда не запускайте его!** Рассуждайте о каждой точке **статически**, прослеживая, доходит ли до нее недоверенный ввод. Никогда не выполняйте и не передавайте в `eval` помеченный код или любой удаленный код, загружаемый им во время выполнения, чтобы "проверить", что он делает. ## Как читать вердикт | Вердикт | Значение | | --------- | --------------------------------------------------------------------------------------------------------- | | `careful` | Фрагмент содержит точку динамического выполнения для своего языка. Проверяйте его чтением, а не запуском. | | `safe` | Для указанного языка точек динамического выполнения не найдено. | ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ------------- | -------------------------------------------------------------------------------------------------------- | | `--pattern` | фрагмент кода | Проверяет один фрагмент. Повторите, чтобы проверить несколько, по одному вердикту на строку. | | `--lang` | язык | Обязателен с `--pattern`: один из javascript, python, php, ruby, java, kotlin, go, rust, c, cpp, csharp. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует весь проект. `--pattern` требует `--lang` и не сочетается с `--dir` или `--file`. ### Поддерживаемые языки Сканирование читает эти языки, определяя их по расширению файла, и проверяет каждый по его собственному набору точек динамического выполнения. | # | Язык | Расширения | Что помечает | | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | 1 | **JavaScript / TypeScript** | `.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.astro`, `.vue`, `.svelte`, `.marko`, `.riot` | `eval()`, конструктор Function, `setTimeout`/`setInterval` со строковым телом, модуль `vm`, exec из `child_process`, динамический `require()`, динамический `import()` | | 2 | **Python** | `.py`, `.pyi` | `eval`/`exec`, `__import__()`, `os.system`/`os.popen`, `subprocess` с `shell=True`, `pickle.load`/`loads`, `yaml.load` (небезопасный) | | 3 | **Ruby** | `.rb` | семейство eval (`instance_eval`/`class_eval`/`module_eval`/`eval`), `system`/`exec`, обратные кавычки или `%x`, `Kernel#open` / `IO.popen`/`read`/`binread` / `Open3`, `Process.spawn`, `Marshal.load` | | 4 | **Go** | `.go` | `exec.Command`/`exec.CommandContext`, `plugin.Open` | | 5 | **PHP** | `.php` | `eval()`, `assert()` со строкой, `create_function()`, выполнение в оболочке (`system`/`exec`/`shell_exec`/`passthru`/`popen`/`proc_open`), `call_user_func`/`call_user_func_array`, `include`/`require` с путем, вычисляемым во время выполнения | | 6 | **Rust** | `.rs` | `Command::new`, `process::Command` | | 7 | **Java** | `.java` | `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject` | | 8 | **Kotlin** | `.kt`, `.kts` | Точки JVM: `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject` | | 9 | **C#** | `.cs` | `Process.Start` / `new Process`, `BinaryFormatter`, `Assembly.Load` | | 10 | **C** | `.c`, `.h` | `system()`, `popen()`, семейство `exec*` (`execl`, `execve`, `execvp`, …) | | 11 | **C++** | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx` | `system()`, `popen()`, семейство `exec*` (`execl`, `execve`, `execvp`, …) | **По мере возможностей, а не исчерпывающе** Хук читает исходный код как текст, поэтому точка, собранная во время выполнения, спрятанная за псевдонимом или записанная в нераспознаваемой форме, может проскользнуть. Считайте таблицу надежной отправной точкой, а не полной инвентаризацией. **Совет** Хук гарантирует минимум (эти точки существуют, и известно где): доходит ли до них на самом деле недоверенное значение, решает суждение, которое охватывает [специализация `interpreter`](https://lagune.ai/ru-RU/docs/catalog). ## Частые вопросы ### Подтверждает ли хук interpreter уязвимость? Нет. Он помечает точки динамического выполнения как предостережение для проверки, а не как подтвержденную находку, потому что статическое сканирование не может определить, доходит ли до точки ввод, на который влияет злоумышленник. ### Какие языки охватывает хук interpreter? Он читает языки из таблицы поддерживаемых языков, определяя их по расширению файла, и проверяет каждый по его собственному набору точек. Для других языков точки не выдаются. --- # Хук jwt: обнаружение проверки JWT без закрепленного алгоритма > Проверьте кодовую базу на проверку JWT без закрепленного алгоритма или оцените отдельный вызов из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/jwt Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/jwt Последнее обновление: 2026-11-03 Хук `jwt` помечает **проверку JWT без закрепленного алгоритма**, дыру подмены алгоритма (algorithm confusion), при которой проверяющий код доверяет заголовку `alg` из самого токена, а также **полностью отключенную проверку**. Он **учитывает язык** и читает каждый файл с учетом его собственной библиотеки JWT. Это детерминированный движок, стоящий за [специализацией `federation`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами в режиме **scan** или **check**. ## Запуск **Сканировать кодовую базу** ```bash npx lagune read jwt # scans the whole project npx lagune read jwt --dir src # scans a directory npx lagune read jwt --file auth.ts # scans a single file ``` **Проверить вызов** ```bash npx lagune read jwt --lang javascript --pattern 'jwt.verify(token, secret)' # => unpinned npx lagune read jwt --lang python --pattern 'jwt.decode(t, k, options={"verify_signature": False})' # => unpinned npx lagune read jwt --lang python --pattern 'jwt.decode(t, k, algorithms=["HS256"])' # => safe ``` Каждая строка в разделе **Unpinned JWT verification found** представляет собой вызов проверки, который не задает список разрешенных алгоритмов `algorithms` (там, где библиотеке он нужен), принимает небезопасный список (`none` или асимметричный алгоритм вперемешку с HMAC) или вовсе отключает проверку подписи и поэтому доверяет `alg` из самого токена. Это подтвержденная уязвимость, поэтому хук завершается с ненулевым кодом. Если ничего не найдено, выводится `no unpinned JWT verification found`. ## Как читать вердикт | Вердикт | Значение | | ---------- | ------------------------------------------------------------------------------------------------------------------------- | | `unpinned` | Вызов проверки без списка разрешенных алгоритмов (там, где он нужен), с небезопасным списком или с отключенной проверкой. | | `safe` | Вызов проверки, который закрепляет надежный список разрешенных алгоритмов или чья библиотека закрепляет его неявно. | | `invalid` | Во фрагменте нет узнаваемого вызова проверки, который можно оценить. | ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ------------- | ------------------------------------------------------------------------------------------------ | | `--pattern` | фрагмент кода | Проверяет один вызов. Повторите, чтобы проверить несколько, по одному вердикту на строку. | | `--lang` | язык | Обязателен с `--pattern`: один из javascript, python, go, java, kotlin, php, ruby, rust, csharp. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует весь проект. `--pattern` требует `--lang` и не сочетается с `--dir` или `--file`. ### Поддерживаемые языки Сканирование читает эти библиотеки, определяя язык по расширению файла. Некоторые из них закрепляют алгоритм неявно (отсутствие явного списка там безопасно), поэтому правило "нет списка разрешенных алгоритмов ⇒ unpinned" применяется только там, где библиотека ожидает явный список, и правильно настроенный вызов никогда не помечается. | Язык | Библиотека | Помечает отсутствие списка как unpinned? | Помечает всегда | | --------------------------- | ----------------------- | ----------------------------------------------------------------------- | ----------------------------------------------- | | **JavaScript / TypeScript** | jsonwebtoken, jose | Да | `none`, смесь асимметричного алгоритма и HMAC | | **Python** | PyJWT, python-jose | Да (PyJWT требует список, у python-jose по умолчанию `algorithms=None`) | `none`, `verify_signature: False` | | **Go** | golang-jwt | Да (без `WithValidMethods`) | `none`, `ParseUnverified` | | **Ruby** | ruby-jwt | Да | `none`, `verify = false` | | **Java / Kotlin** | jjwt, nimbus | Нет (алгоритм выводится из ключа) | `none`, неподписанный или `unsecured` парсер | | **PHP** | firebase/php-jwt | Нет (`Key` несет алгоритм) | `none` | | **Rust** | jsonwebtoken | Нет (`Validation` требует список) | `none`, `insecure_disable_signature_validation` | | **C#** | Microsoft.IdentityModel | Нет (параметры на нескольких строках) | `none`, `RequireSignedTokens = false` | **Совет** Хук решает только вопрос закрепления алгоритма: проверки claims, ключей и потока остаются вопросами суждения, которые по-прежнему охватывает [специализация `federation`](https://lagune.ai/ru-RU/docs/catalog). ## Частые вопросы ### Что такое подмена алгоритма JWT? Проверяющий код, который читает алгоритм из заголовка токена, позволяет злоумышленнику заменить RS256 на HS256 и подписать токен открытым ключом. Закрепление надежного списка разрешенных алгоритмов в коде предотвращает это, а хук jwt помечает вызов проверки, который не задает список или задает небезопасный. --- # Хук network: оценка URL на SSRF > Оценивайте один или несколько адресов загрузки на SSRF прямо из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/network Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/network Последнее обновление: 2026-11-03 Хук `network` решает, защищен ли адрес серверной загрузки от **SSRF** (запроса, который можно направить на внутренние сервисы, облачные метаданные или приватные хосты). Это детерминированный движок, стоящий за [специализацией `network`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами. ## Запуск Передайте каждый адрес через `--url`. Хук выводит по одному слову на адрес, значения которых описаны в таблице ниже. **Один адрес** ```bash npx lagune read network --url 'http://example.com/' # => safe npx lagune read network --url 'http://0x7f000001/' # => private-target ``` **Несколько адресов** Повторите `--url`, чтобы оценить весь список разрешенных или запрещенных адресов за один вызов, по одному вердикту на строку, по порядку. ```bash npx lagune read network \ --url 'http://example.com/' \ --url 'http://[::1]/' \ --url 'http://allowed.com@evil.example/' # => safe # => private-target # => parser-divergent ``` Хук разрешает хост так же, как это делает сеть, поэтому закодированные формы внутреннего адреса не проскальзывают: шестнадцатеричная, восьмеричная, десятичная без точек, сокращенная запись, IPv6 и IPv4-mapped получают вердикт `private-target`. А там, где небрежная проверка и настоящий загрузчик прочитали бы разные хосты, вердикт будет `parser-divergent`. ## Как читать вердикт | Вердикт | Значение | | ------------------ | ------------------------------------------------------------------------------------------------------------ | | `safe` | Адрес ведет к публичному хосту, и небрежная проверка прочитала бы тот же хост. | | `private-target` | Хост разрешается в приватный, loopback, link-local, неуказанный адрес или адрес облачных метаданных. | | `parser-divergent` | Небрежная текстовая проверка прочитала бы другой настоящий хост, чем тот, к которому подключается загрузчик. | | `invalid url` | Строка не разбирается как URL, поэтому загружать нечего. | Разрешением считается только `safe`. Считайте `private-target`, `parser-divergent` и `invalid url` блокировкой. ### Параметры CLI | Параметр | Значение | Описание | | -------- | ------------ | ----------------------------------------------------------------------------------------- | | `--url` | URL или хост | Проверяет один адрес. Повторите, чтобы проверить несколько, по одному вердикту на строку. | Нужен хотя бы один `--url`. Адрес никогда не передается как голый позиционный аргумент, поэтому его нельзя принять за флаг. **Почему значение флага** Каждый адрес передается как значение флага и никогда не подставляется в команду. Значение с кавычками или обратными кавычками остается инертным и не может внедриться в оболочку. Всегда заключайте его в одинарные кавычки, чтобы оболочка не раскрыла его раньше. **Чего он не охватывает** Хук чистый и никогда не разрешает DNS, поэтому два пробела времени выполнения находятся вне его охвата: **DNS rebinding** (имя, которое при проверке разрешается в публичный адрес, а при загрузке во внутренний) и **цепочки перенаправлений** (первый шаг проходит проверку, а затем перенаправляет внутрь). Закрывайте их, разрешая имя один раз и подключаясь к проверенному адресу, а также отказываясь следовать перенаправлениям. Зарезервированные loopback-имена (`localhost` и семейство `.localhost`) хук без поиска считает внутренними, но любое другое DNS-имя получает `safe`, потому что утверждать, что оно разрешается внутрь, можно было бы только после разрешения: такие имена охраняет список разрешенных адресов, и именно его проверяет этот инструмент. **Совет** Это та же проверка, которую запускает [специализация `network`](https://lagune.ai/ru-RU/docs/catalog), чтобы доказать, что фильтр адресов действует. ## Частые вопросы ### Как проверить URL на SSRF? Запустите хук network. Он оценивает адрес загрузки и возвращает safe, private-target, parser-divergent или invalid url. Разрешением считается только safe. ### Что такое URL с расхождением парсеров (parser-divergent)? URL, который разные парсеры читают по-разному, классический способ обойти защиту от SSRF. Хук network помечает его, а не пропускает. --- # Хук regex: обнаружение шаблонов, уязвимых к ReDoS > Проверьте кодовую базу на регулярные выражения, уязвимые к ReDoS, или оцените отдельный шаблон из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/regex Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/regex Последнее обновление: 2026-11-03 Хук `regex` представляет собой детерминированный движок проверки безопасности регулярных выражений, который запускает [специализация `regex`](https://lagune.ai/ru-RU/docs/catalog), и вы можете запускать его сами. Он работает в двух режимах одной командой: **сканирование** проверяет кодовую базу на шаблоны, уязвимые к **ReDoS** или собираемые во время выполнения, а **проверка** оценивает отдельный шаблон, который вы ему передаете. ## Сканирование кодовой базы Без флага хук сканирует весь проект. `--dir` ограничивает сканирование директорией, `--file` одним файлом. Оба флага можно повторять и сочетать в одном отчете, и каждый файл указывается один раз, даже если его охватывает несколько целей. **Весь проект** ```bash npx lagune read regex ``` **Директория** ```bash npx lagune read regex --dir src/services ``` **Один файл** ```bash npx lagune read regex --file bin/import.pl ``` **Несколько целей** ```bash npx lagune read regex --dir core --dir workers --file Sources/App/Router.swift ``` **С лимитом** `--limit` задает порог ReDoS для сканирования (по умолчанию 25), тот же лимит, что принимает режим проверки. Чем ниже лимит, тем строже проверка. ```bash npx lagune read regex --dir src/services --limit 15 ``` Вывод представляет собой простой текст, заголовки которого объясняют, как читать каждый раздел. Раздел показывается, только если в нем есть находки. ```text Vulnerable regular expressions found: cmd/server/main.go ([a-z]+)+$ (exponential, search) Dynamically built regular expressions (review manually by simulating a constructed regex): app/payments.php crates/parser/lexer.rs lib/validate.py Static regex wrapped in a constructor (use a literal instead): config/token.rb ``` Если ничего не найдено, выводится одна строка. ```bash npx lagune read regex --dir src/clean # => no unsafe patterns found ``` ### Как читать разделы | Раздел | Значение | | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Vulnerable regular expressions found` | Шаблоны, уязвимые к ReDoS, сгруппированные по файлам: каждый шаблон с отступом под своим файлом, а за ним в скобках причина, по которой он небезопасен, и, если есть, его область действия и флаги. Каждая строка небезопасна, поэтому вердикт не повторяется. | | `Regular expressions the analysis could not settle (review manually)` | Шаблоны, которые анализ не смог оценить в пределах своего лимита работы, в том же виде. | | `Dynamically built regular expressions (review manually by simulating a constructed regex)` | Файлы, которые собирают регулярное выражение из переменной, конкатенации или интерполяции. | | `Static regex wrapped in a constructor (use a literal instead)` | Файлы, которые передают обычный строковый литерал в конструктор регулярного выражения там, где литерал регулярного выражения проще и не требует компиляции во время выполнения. | Первый раздел содержит находки безопасности. Второй и третий сами по себе находками не являются: они указывают на код, который статическая проверка не может оценить, поэтому требуют, чтобы его прочитал человек. Четвертый служит подсказкой для ясности кода, а не находкой безопасности. ### Параметры CLI | Параметр | Значение | Описание | | ----------- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------- | | `--pattern` | исходный текст регулярного выражения | Проверяет один шаблон. Повторите, чтобы проверить несколько, по одному вердикту на шаблон, по порядку. | | `--flags` | флаги регулярного выражения | Проверяет каждый `--pattern` с этими флагами, например `im`. Действует только в режиме проверки. | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | | `--limit` | неотрицательное целое число | Задает лимит повторений ReDoS (по умолчанию 25). Действует в обоих режимах. Чем ниже лимит, тем строже проверка. | Без параметров хук сканирует весь проект. `--pattern` включает режим проверки и не сочетается с `--dir` или `--file`. ### Поддерживаемые языки Сканирование читает эти языки, определяя их по расширению файла, каждый по его собственным правилам, поэтому шаблон из одного языка никогда не проверяется по правилам другого. Все остальное пропускается, а не сканируется по неправильным правилам. | # | Язык | Расширения | | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | | 1 | **JavaScript / TypeScript** | `.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.astro`, `.vue`, `.svelte`, `.marko`, `.riot` | | 2 | **Python** | `.py`, `.pyi` | | 3 | **Ruby** | `.rb` | | 4 | **Go** | `.go` | | 5 | **PHP** | `.php` | | 6 | **Rust** | `.rs` | | 7 | **Java** | `.java` | | 8 | **C#** | `.cs` | | 9 | **C** | `.c`, `.h` | | 10 | **C++** | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx` | | 11 | **Kotlin** | `.kt`, `.kts` | | 12 | **Swift** | `.swift` | | 13 | **Scala** | `.scala`, `.sc` | | 14 | **Dart** | `.dart` | | 15 | **PowerShell** | `.ps1`, `.psm1`, `.psd1` | | 16 | **Elixir** | `.ex`, `.exs` | | 17 | **Objective-C** | `.m`, `.mm` | | 18 | **R** | `.r` | | 19 | **Julia** | `.jl` | | 20 | **Clojure** | `.clj`, `.cljs`, `.cljc`, `.edn` | | 21 | **Crystal** | `.cr` | | 22 | **Nim** | `.nim`, `.nims` | | 23 | **V** | `.v` | | 24 | **D** | `.d` | | 25 | **Perl** | `.pl`, `.pm` | **По мере возможностей, а не исчерпывающе** Хук читает исходный код как текст, поэтому не может оценить шаблон, собранный во время выполнения, а шаблон, разбитый на несколько строк, спрятанный за псевдонимом или записанный в нераспознаваемой форме, может проскользнуть. Считайте разделы надежной отправной точкой, а не полной инвентаризацией, и продолжайте читать код там, куда они не дотягиваются. ## Проверка отдельного шаблона Передайте `--pattern` с исходным текстом шаблона, чтобы оценить его. Хук выводит одно слово: `safe`, `unsafe`, `undetermined`, если анализ достиг своего лимита работы, не успев оценить шаблон, или `invalid regex`. Повторите `--pattern`, чтобы оценить несколько сразу, по одному вердикту на шаблон, по порядку. **Один шаблон** ```bash npx lagune read regex --pattern '(a+)+$' # => unsafe npx lagune read regex --pattern '^[a-z0-9_]{3,20}$' # => safe ``` **Несколько шаблонов** ```bash npx lagune read regex --pattern '(a+)+$' --pattern '^[a-z]+$' # => unsafe # => safe ``` **С флагами** `--flags` проверяет каждый `--pattern` в вызове с теми флагами, с которыми он выполняется, поскольку флаг меняет, какие символы совпадают с шаблоном. ```bash npx lagune read regex --pattern '^(?:a|A)+$' # => safe npx lagune read regex --pattern '^(?:a|A)+$' --flags 'i' # => unsafe ``` **С лимитом** `--limit` задает лимит повторений (по умолчанию 25) и действует для каждого `--pattern` в вызове. Чем ниже лимит, тем строже проверка. ```bash npx lagune read regex --pattern 'a?a?a?' --limit 2 # => unsafe ``` **Почему аргумент в кавычках** Каждый шаблон передается как значение флага и никогда не подставляется в команду. Значение с кавычками или обратными кавычками остается инертным и не может внедриться в оболочку. Всегда заключайте шаблон в одинарные кавычки, чтобы оболочка не раскрыла его раньше. **Совет** Это тот же движок, который запускает [специализация `regex`](https://lagune.ai/ru-RU/docs/catalog): сканирование открывает проход по ReDoS, а проверка подтверждает найденный им шаблон. ## Частые вопросы ### Как проверить регулярное выражение на ReDoS из CLI? Выполните npx lagune read regex --pattern ''. Команда возвращает safe, unsafe, undetermined или invalid regex. ### Как просканировать весь проект на небезопасные регулярные выражения? Запустите хук regex в режиме сканирования по кодовой базе. Он сообщает о шаблонах, уязвимых к ReDoS, на 25 поддерживаемых языках. --- # Хук secrets: обнаружение жестко заданных секретов > Проверьте кодовую базу на жестко заданные учетные данные из командной строки. Канонический URL: https://lagune.ai/ru-RU/docs/hooks/secrets Язык: ru-RU Оригинал: https://lagune.ai/docs/hooks/secrets Последнее обновление: 2026-11-03 Хук `secrets` помечает **учетные данные, вкомпилированные в исходный код**, вместо того чтобы читаться из окружения. Он ориентируется на **происхождение** значения (литерал или чтение из окружения), а не на его содержимое, поэтому ему не нужен исчерпывающий каталог префиксов провайдеров, и он почти не дает ложных срабатываний. Это детерминированный движок, стоящий за [специализацией `secrets`](https://lagune.ai/ru-RU/docs/catalog). Сигнатуры форматов провайдеров, учетные данные в строках подключения и литерал, привязанный к идентификатору с именем секрета, **не зависят от языка**: одна и та же строка читается одинаково в любом файле. Две эвристики, зависящие от синтаксиса, чтение из окружения с жестко заданным значением по умолчанию и секрет, попадающий в sink логов, **учитывают язык**, поэтому `console.log` из JavaScript никогда не ищется в файле Rust, а `os.getenv("X", "default")` из Python распознается отдельно. ## Запуск ```bash npx lagune read secrets # scans the whole project npx lagune read secrets --dir src # scans a directory npx lagune read secrets --file config.ts # scans a single file ``` Сканирование выводит до двух разделов. **Hardcoded secrets found** содержит находки (жестко заданное значение по умолчанию для переменной окружения с именем секрета, учетные данные, встроенные в строку подключения, или значение, совпадающее с тщательно отобранным форматом провайдера), поэтому хук завершается с ненулевым кодом. **Secret handling to review manually** содержит поводы для проверки: обычный литерал, привязанный к идентификатору с именем секрета (его происхождение определить можно, а вот является ли значение настоящим секретом, нельзя), и значение с именем секрета, попадающее в sink логов или ответа. Если ничего не найдено, выводится `no hardcoded secrets found`. ### Параметры CLI | Параметр | Значение | Описание | | -------- | ---------- | ----------------------------------------------------------------------------- | | `--dir` | директория | Ограничивает сканирование директорией. Можно повторять и сочетать с `--file`. | | `--file` | файл | Ограничивает сканирование одним файлом. Можно повторять и сочетать с `--dir`. | Без параметров хук сканирует весь проект. ### Охват языков Находка с запасным значением из окружения и повод для проверки с sink логов читают формы, свои для каждого языка, поэтому охватывают языки ниже и молчат в остальных. Три других сигнала работают для **каждого** файла. | Сигнал | Языки | | ---------------------------------- | ------------------------------------------------------------------------------- | | Значение по умолчанию из окружения | JavaScript/TypeScript, Python, Ruby, PHP, Kotlin, Java, Go (`cmp.Or`), Rust, C# | | Sink логов или ответа | JavaScript/TypeScript, Python, Ruby, PHP, Java, Kotlin, Go, Rust, C, C++, C# | **Это не нарушение политики?** Нет. Распознавание формата секрета, чтобы предупредить, что он попал в коммит, представляет собой стандартный защитный инструментарий, ту же операцию выполняют gitleaks, trufflehog и push protection в GitHub. Хук поставляет сигнатуры для обнаружения (публичные **форматы** токенов), а не настоящие секреты, и проводит аудит и объясняет, а не выносит данные наружу. ## Частые вопросы ### Как хук secrets избегает ложных срабатываний? Он ориентируется на происхождение, а не на содержимое значения. Форматы с высокой степенью уверенности (токены провайдеров, запасные значения из окружения, строки подключения) считаются находками и дают ненулевой код выхода. Обычный литерал, привязанный к идентификатору с именем секрета, служит поводом для проверки, который нужно подтвердить, а тот же идентификатор, прочитанный из process.env, вообще не помечается. --- # Примеры промптов Lagune: автоматизируйте процесс Blue Team > Готовые промпты Lagune: сканирование только для чтения, полный процесс Blue Team и аудит Zero Trust, а также обнаружение, ограниченное коммитом, diff ветки или PR либо реальным инцидентом. Канонический URL: https://lagune.ai/ru-RU/docs/examples/prompts Язык: ru-RU Оригинал: https://lagune.ai/docs/examples/prompts Последнее обновление: 2026-11-03 Готовые промпты Lagune, которые можно сразу вставить в своего ИИ-агента. ## 💧 Поверхностное сканирование Проверка только для чтения, которая сама читает код и сообщает о каждой уязвимости с исправлением, не запуская процесс Blue Team и ничего не записывая в отслеживание Lagune. **Совет** Лучше работает в режиме планирования и с заданными принципами безопасности (`/lagune-charter`). **🪼 По умолчанию** | Аспект | Компромисс | Уровень | | ------------------ | ------------------------------------------------------------- | ------------------- | | **Усилия** | Один агент сканирует и составляет отчет, без субагентов. | 1/5 | | **Время** | Быстро. Один проход только для чтения, ничего не применяется. | 2/5 | | **Расход токенов** | Умеренный, общий. Все сканирование идет в одном контексте. | 2/5 | ```md /lagune Ты исследователь кибербезопасности с глубокой экспертизой в защитной безопасности и используешь Lagune, чтобы повысить свои знания и точность. Самостоятельно просканируй рабочее пространство и подбери к каждой найденной уязвимости конкретное исправление. Это отдельная проверка, а не процесс Blue Team: не запускай detect, plan, harden или verify и ничего не записывай в отслеживание Lagune. В конце перечисли все найденные уязвимости, у каждой укажи критичность и конкретное исправление. ``` **🐬 Мультиагентный режим** | Аспект | Компромисс | Уровень | | ------------------ | ---------------------------------------------------------------------------------- | ------------------- | | **Усилия** | Один субагент на файл, их число зависит от размера кодовой базы. | 2/5 | | **Время** | Параллельно по файлам, затем все сводится в один отчет. По-прежнему только чтение. | 3/5 | | **Расход токенов** | Выше, но изолированно. Каждый субагент сканирует в своем контексте. | 3/5 | ````md /lagune Ты оркестратор кибербезопасности и используешь Lagune, чтобы перечислить пути, отправить по субагенту на каждый путь и объединить их отчеты (все содержимое читают субагенты). Ты должен делегировать задачу субагентам в зависимости от размера текущего проекта: чем больше кодовая база, тем больше субагентов нужно отправить, всех параллельно, и каждому дать промпт ниже: ```prompt /lagune Ты исследователь кибербезопасности с глубокой экспертизой в защитной безопасности и используешь Lagune, чтобы повысить свои знания и точность. Самостоятельно просканируй и подбери к каждой найденной уязвимости конкретное исправление. Это отдельная проверка, а не процесс Blue Team: не запускай detect, plan, harden или verify и ничего не записывай в отслеживание Lagune. В конце перечисли все уязвимости в , у каждой укажи критичность и конкретное исправление. ``` В конце объедини отчеты всех субагентов в один упорядоченный по приоритету список уязвимостей и исправлений. ```` **Предупреждение** Быстрое сканирование представляет собой один широкий промпт без ограничений, поэтому некоторые агенты чаще отказываются его выполнять или обрывают его. Если ваш агент сопротивляется, запустите вместо этого полный **процесс Blue Team** ниже: его ограниченные пошаговые фазы блокируются гораздо реже. --- ## 🌊 Автоматический аудит по процессу Blue Team Запускает [полный процесс команд](https://lagune.ai/ru-RU/docs/get-started/commands) от начала до конца, не останавливаясь, чтобы спросить вас. **🪼 По умолчанию** | Аспект | Компромисс | Уровень | | ------------------ | ------------------------------------------------------------------------------------------------------------------- | ------------------- | | **Усилия** | Один агент, без субагентов, независимо от размера кодовой базы. | 3/5 | | **Время** | Среднее, но в больших кодовых базах проверка менее тщательная. Каждая команда запускается один раз, одна за другой. | 4/5 | | **Расход токенов** | Ниже, но с меньшей изоляцией. Все команды делят один контекст. | 4/5 | ```md Выполни следующие команды одну за другой: `/lagune-charter`, `/lagune-detect`, `/lagune-plan`, `/lagune-harden` и `/lagune-verify`. ## Цикл Когда `/lagune-verify` отклоняет одно или несколько исправлений, повторяй `/lagune-harden`, а затем `/lagune-verify`, пока все находки не будут как следует устранены. ## Важно - Не останавливайся и не спрашивай: если сомневаешься, делай все в режиме "full". ``` **🐋 Мультиагентный режим (глубокое сканирование)** | Аспект | Компромисс | Уровень | | ------------------ | ------------------------------------------------------------------------------------------------------------------------- | ------------------- | | **Усилия** | Число субагентов зависит от размера кодовой базы. | 5/5 | | **Время** | Дольше, но тщательнее. Отправляет несколько субагентов, чтобы параллельно обнаруживать, планировать и исправлять находки. | 5/5 | | **Расход токенов** | Выше, но надежнее. У каждого субагента свой изолированный контекст без предвзятости. | 5/5 | ````md Выполни следующие команды, каждую в отдельном субагенте, по одной за раз (без обратных кавычек, только команду): Промпт субагента 1: `/lagune-charter` Промпт субагента 2: `/lagune-detect` Промпт субагента 3: `/lagune-plan` Промпт субагента 4: `/lagune-harden` Промпт субагента 5: `/lagune-verify` В командах `/lagune-detect`, `/lagune-plan`, `/lagune-harden` и `/lagune-verify` ты должен делегировать задачу субагентам в зависимости от размера текущего проекта: чем больше кодовая база, тем больше субагентов нужно отправить. Например: ```prompt /lagune-detect ``` ```prompt /lagune-plan ``` ```prompt /lagune-harden ``` ```prompt /lagune-verify ``` - Несколько агентов на одной команде нужно отправлять параллельно. - Когда все субагенты `/lagune-detect` закончат, выполни: ```prompt /lagune-detect объедини равнозначные находки. Не ищи новые находки и не сканируй кодовую базу заново. ``` ## Цикл Когда `/lagune-verify` отклоняет одно или несколько исправлений, повторяй `/lagune-harden`, а затем `/lagune-verify`, пока все находки не будут как следует устранены. ## Важно - Не останавливайся и не спрашивай: если сомневаешься, делай все в режиме "full". ```` --- ## 🪄 Ограниченное обнаружение Направьте [`/lagune-detect`](https://lagune.ai/ru-RU/docs/commands/detect) на часть проекта, а не на весь проект целиком. Опишите охват простыми словами (коммит, pull request или реальная ситуация), и команда выявит находки, важные для безопасности, только там. **Совет** Все, что команда здесь обнаружит, становится обычной находкой, поэтому ее можно сразу передать в `/lagune-plan`, `/lagune-harden` и `/lagune-verify`, ограничив охват только этими элементами. **📌 С момента коммита** Проведите отдельную проверку безопасности свежей пачки коммитов, ограничив охват только тем, что они изменили, например: ```prompt /lagune-detect Ограничь обнаружение всем, что изменилось с коммита `a1b2c3d`. ``` **🔀 Diff ветки или PR** Проверьте pull request на безопасность до слияния, ограничив охват только его diff, например: ```prompt /lagune-detect Ограничь обнаружение изменениями, которые эта ветка вносит относительно `main`. ``` **⛑️ После инцидента** Опишите, что случилось, своими словами. Lagune читает ситуацию, а не флаг, и превращает ее в целенаправленный поиск, например: ```prompt /lagune-detect Несколько недель назад у нашего сайта была утечка данных. Я точно не знаю, как это произошло, и боюсь, что какая-то дыра все еще открыта и данные могут утечь снова. Внимательно пройдись по коду, сосредоточься на всех местах, где чувствительные данные читаются, хранятся или раскрываются, и выяви все, что все еще может стать путем наружу. Отнесись к этому как к реальному инциденту, а не к учениям. ``` --- ## 🚨 Аудит Zero Trust Считает все рабочее пространство и каждую зависимость враждебными: ищет интерпретаторы, сетевые вызовы, закодированные payload и код, спрятанный в неожиданных местах, чтобы проскользнуть мимо сканеров, а в конце выносит вердикт "да или нет" о том, безопасно ли использовать проект. Промпты напрямую загружают специализации, на которые опирается этот аудит, какие бы категории ни были у вашего проекта. Чтобы `/lagune` сопоставил и остальной каталог, убедитесь, что проект использует **OWASP**, **ИИ / LLM** и категорию своего стека (например, **JavaScript**, **Python** и т. д.): ```bash npx lagune write add --categories owasp ai javascript ``` **Опасно** Будьте осторожны, запуская в локальном окружении проекты из недоверенных источников. Используйте изолированное окружение, например **песочницу** (рекомендуется), **виртуальную машину** или что-то подобное, чтобы вредоносный код не повлиял на вашу систему. **🪼 По умолчанию** | Аспект | Компромисс | Уровень | | ------------------ | ---------------------------------------------------------------------------------- | ------------------- | | **Усилия** | Один агент проверяет все рабочее пространство, без субагентов. | 2/5 | | **Время** | Среднее. Один агент последовательно проходит код и его зависимости. | 3/5 | | **Расход токенов** | Умеренный, но общий. Специализации, код и зависимости загружаются в один контекст. | 3/5 | ```md /lagune Ты исследователь кибербезопасности с глубокой экспертизой в защитной безопасности по модели zero trust и используешь Lagune, чтобы повысить свои знания и точность. Рассматривай все рабочее пространство как недоверенный источник и потенциально вредоносную область. Каждый интерпретатор, fetch, base64 и подобное нужно считать потенциальной угрозой. Распространи анализ на зависимости и вложенные зависимости: проект может пытаться спрятать вредоносный код в неожиданном месте, чтобы проскользнуть мимо сканеров. Обязательные специализации (загружай их по одной с помощью `npx lagune read catalog `): - interpreter - secrets - llm - path Для ясности: каждую выявленную уязвимость нужно считать потенциальной угрозой, без исключений. В конце вынеси вердикт, безопасен ли проект и можно ли мне ему доверять и его использовать. ``` **🐋 Мультиагентный режим (глубокое сканирование)** | Аспект | Компромисс | Уровень | | ------------------ | --------------------------------------------------------------------------------------------------------- | ------------------- | | **Усилия** | Один субагент на файл, их число зависит от размера кодовой базы. | 5/5 | | **Время** | Дольше, но тщательнее. Файлы проверяются параллельно, затем все сводится в один вердикт. | 4/5 | | **Расход токенов** | Самый высокий, но и самый надежный. Каждый субагент читает специализации в своем изолированном контексте. | 5/5 | ````md /lagune Ты оркестратор кибербезопасности и используешь Lagune, чтобы перечислить файлы, отправить по субагенту на каждый файл и составить отчеты (все содержимое читают субагенты). Отправь по одному субагенту на каждый файл, всех параллельно, и дай каждому промпт ниже, ограниченный его файлом: ```prompt /lagune Ты исследователь кибербезопасности с глубокой экспертизой в защитной безопасности по модели zero trust и используешь Lagune, чтобы повысить свои знания и точность. Рассматривай как недоверенный источник и потенциально вредоносную область. Каждый интерпретатор, fetch, base64 и подобное нужно считать потенциальной угрозой. Распространи анализ на все, что импортирует , включая зависимости и вложенные зависимости, где может прятаться вредоносный код, чтобы проскользнуть мимо сканеров. Обязательные специализации для каждого субагента (загружай их по одной с помощью `npx lagune read catalog `): - interpreter - secrets - llm - path Для ясности: каждую выявленную уязвимость нужно считать потенциальной угрозой, без исключений. В конце вынеси вердикт, безопасен ли проект и можно ли мне ему доверять и его использовать. ``` В конце объедини отчеты всех субагентов в один итоговый вердикт. ```` --- # Security-Driven Hardening: конвенция для эпохи разработки с помощью ИИ > Методология Security-Driven Hardening (SDH): конвенция Blue Team с учетом контекста для аудита и усиления защиты ПО, созданного с помощью ИИ и в стиле вайб-кодинга. Канонический URL: https://lagune.ai/ru-RU/docs/references/paper Язык: ru-RU Оригинал: https://lagune.ai/docs/references/paper Последнее обновление: 2026-11-03 - **Weslley Araújo** - **Статья о методологии, 2026.** --- ## Аннотация Security-Driven Hardening (SDH) представляет собой структурированную методологию безопасности на основе ИИ, ориентированную только на защиту и созданную для эпохи, в которой программы все чаще пишут ИИ-агенты и люди, не являющиеся специалистами по безопасности. Вместо проверки по общему чек-листу SDH сначала выявляет, что на самом деле делает система (вход в систему, загрузка файлов, платежи, раскрытие данных и так далее), а затем ведет работу по безопасности, характерную именно для этого контекста. Ею управляют принципы безопасности по умолчанию, она целиком построена вокруг защиты и выражена простым языком, чтобы любой пользователь мог действовать на ее основе. В этом документе утверждается, что SDH представляет собой недостающую конвенцию, а не отдельный инструмент. Знания о безопасности заложены в методологию и ее специализации, загружаемые по запросу, это базовый уровень, на который может опереться любой пользователь, и именно это позволяет обслуживать новичка и эксперта через один и тот же процесс. Два свойства отличают ее от прежних подходов, основанных на спецификации `[1]`. SDH **не зависит от состояния**: она подстраивается под пустую директорию, проект в процессе разработки, отдельный pull request или большую унаследованную кодовую базу на любом стеке. И SDH **закрываема**: риск, проверенный и закрытый, снимается с учета во всем процессе, поэтому находка достигает устойчивого состояния и открывается снова, только когда меняется код. SDH не заменяет специалистов по безопасности или специализированные инструменты Blue Team. Она расширяет собственные знания разработчика, и чем лучше разработчик понимает безопасность, тем больше он может ею управлять. **Lagune** является эталонной реализацией и доказывает, что методологию можно построить и перенести. SDH предлагается как конвенция, которую могут принять другие. > **Ключевые слова** > > разработка с помощью ИИ, безопасность ПО, защитная безопасность, разработка на основе спецификаций, усиление безопасности, рабочие процессы под управлением агентов, закрываемость, безопасность с учетом контекста, знания по запросу, инструменты, независимые от агента. --- ## I. Введение: брешь в безопасности, которую открыла разработка с помощью ИИ Программы все чаще выпускают люди и ИИ-агенты, которые не могут надежно распознать небезопасный шаблон: утекший секрет, отсутствующую проверку авторизации, запрос, уязвимый к инъекции. Это не экзотические риски. Они входят в классы рисков, которые преобладают в реальных инцидентах и годами документируются в публичных источниках `[6]`, `[7]`, а недавние исследования сообщают, что заметная доля кода, сгенерированного ИИ, выходит именно с такими дефектами `[8]`. ИИ-ассистенты для программирования обострили проблему, позволив не разработчикам выпускать настоящие программы, но брешь шире любой отдельной аудитории. Большинство проектов так и не проходят проверку безопасности, учитывающую то, что они на самом деле делают. Экосистема становится все более хрупкой с каждым преждевременным решением "работает, выпускаем". Общие советы по безопасности эту брешь не закрывают. Статический чек-лист не учитывает, что делает система, поэтому заваливает небольшой проект нерелевантными пунктами и все равно упускает риск, важный именно для этого проекта. Проблема не в нехватке знаний о безопасности в мире. Проблема в том, чтобы сопоставить нужные знания с системой, которая на самом деле перед пользователем, и сделать это для того, кто может не знать, о чем спрашивать. SDH отвечает на это одной инверсией: **знания о безопасности заложены в спецификацию и ее специализации, загружаемые по запросу, это базовый уровень, на который может опереться любой пользователь**. Методология выявляет контекст, сортирует риски, которые этот контекст несет, и направляет исправления, поэтому разработчик и не разработчик проходят один и тот же процесс. Находки и рекомендации остаются на простом языке, поэтому на их основе можно действовать независимо от технической подготовки читателя. Эксперта это не ограничивает, а усиливает, и эту двойственность мы развиваем в `§VI`. > **Ключевая мысль** > > **Основная инверсия:** знания о безопасности заложены в спецификацию и ее специализации, загружаемые по запросу, это базовый уровень, на который может опереться любой пользователь. Методология узнает, что делает система, подбирает под нее работу по безопасности и расширяет то, что пользователь уже знает. Представьте разработчика, который говорит ИИ-ассистенту: "мое приложение позволяет пользователям загружать фото профиля". Без проверки безопасности ассистент выдает работающий код, который молча доверяет всему, что присылает клиент: заявленному типу файла, имени файла, размеру. Загрузка выходит в продакшен, и файл, замаскированный под изображение, может нести код, специально сформированное имя может вырваться за пределы пути хранения, а слишком большой файл может исчерпать ресурсы сервера. Ничего из этого не видно на демонстрации, поэтому все это выходит в продакшен. Тот же код, пропущенный через SDH, ведет себя иначе. Методология выявляет, что система принимает файлы извне (detect), сортирует это по рискам, которые несет загрузка (triage), предлагает проверять настоящий тип и размер файла, переименовывать его при сохранении и хранить там, где код не может выполниться (remediate), а затем читает результат и подтверждает, что каждая мера защиты действительно действует (verify). Разработчику не нужно было знать фразу "unrestricted file upload". Методология подставила ее за него. Этот документ вносит следующий вклад: - Точное определение SDH как методологии, независимой от какой-либо одной реализации, вместе с ее принципами проектирования (`§III`). - Пятифазный защитный жизненный цикл, в котором вкладом является само разделение обязанностей: обнаружение никогда не выдумывает, планирование никогда не читает код, только одна фаза меняет код, а проверка никогда не смягчает свое суждение (`§IV`). - **Закрываемость** как методологическая позиция: у отдельной находки есть конечное состояние, а не бесконечный цикл (`§V`). - Двойственность **расширителя знаний разработчика**: один процесс, который защищает новичка и усиливает эксперта (`§VI`). - **Невызываемые специализации и промпт по запросу**: профильные знания о безопасности, которые агент загружает, когда этого требует контекст проекта, и никогда по умолчанию (`§VII`). - **Независимость от состояния** и **неавторитарная адаптивность**: SDH подходит для любого состояния разработки и подстраивается под сценарий, а не навязывает фиксированный охват (`§VIII`). - **Превентивный режим**: та же защита, запускаемая во время обычной работы, чтобы код появлялся безопасным по умолчанию, а фазам оставалось меньше исправлять (`§IX`). - Отдельное сравнение со Spec-Driven Development, линией, из которой SDH выросла и от которой затем отошла (`§X`). - Инженерные дисциплины, которые позволяют методологии пережить рефакторинг и оставаться независимой от любого агента: отслеживание с идентификацией по имени (`§XI`) и носитель, независимый от агента (`§XII`). --- ## II. Предпосылки и связанные работы SDH опирается на предшествующие работы. Она наследует проверенную структуру разработки на основе спецификаций под управлением агентов `[1]`, `[2]`, `[3]`: шаблоны, slash-команды, которые потребляет агент, управляющий документ и агента, который проходит фазы. Она реализует эту структуру заново с защитной целью. Эта преемственность сознательна, и один из рабочих принципов SDH прямо ее называет: строить рабочий процесс на проверенной структуре, а затем нацеливать его на безопасность. SDH не является статическим чек-листом общих рекомендаций. Чек-лист много знает о безопасности в целом и ничего не знает о проекте перед ним. SDH переворачивает этот акцент. Первые усилия она тратит на обнаружение, на то, чтобы узнать, что делает система, и только потом обращается к знаниям, которые это обнаружение делает релевантными. SDH также не заменяет специалистов по безопасности или специализированные инструменты Blue Team. Она расширяет знания разработчика (`§VI`). Команде с выделенной функцией безопасности стоит ее сохранить. SDH дает такой команде структурированный носитель, а команде без нее дает обоснованный базовый уровень. SDH также соседствует с детерминированными сканерами безопасности (статический анализ, линтеры) `[4]`, `[5]`. Эти инструменты ценны именно тем, что детерминированы и воспроизводимы. SDH по большей части опирается на рассуждения агента, что меняет строгую детерминированность на учет контекста. Методология не делает вид, что это не так. Там, где важна детерминированность, она встраивает детерминированный движок в рассуждение (`§VII`): агент решает, стоит ли проверять входные данные, а детерминированная программа решает, опасны ли эти данные. Самый прямой предшественник представляет собой Spec-Driven Development (SDD), семейство методологий на основе спецификаций, которые ведут разработку вперед от исполняемой спецификации. Мы рассматриваем SDD как класс. Наиболее четко она изложена как практическая методология в отчете Piskala `[1]`, ее самый заметный инструментарий под управлением агентов представляет собой Spec Kit от GitHub `[2]`, а OpenSpec `[3]` служит вторым инструментом из того же семейства. Это канонические источники для сравнения в `§X`. --- ## III. SDH: определение и принципы проектирования **Security-Driven Hardening** представляет собой структурированную методологию безопасности на основе ИИ, которая делает кодовую базу безопаснее, ведя работу по спецификации, которую выполняет агент, а не через разрозненные исправления. Название вдохновлено **Blue Teams**, защитниками в безопасности. SDH посвящена защите, усилению защиты и проверке и никогда не нападению. > **Определение** > > **Security-Driven Hardening (SDH):** структурированная методология безопасности на основе ИИ, ориентированная только на защиту, которая сначала выявляет, что на самом деле делает система, а затем ведет работу по безопасности под этот контекст, следуя принципам безопасности по умолчанию и используя простой язык. SDH определяется набором обязательных принципов. Каждый из них является правилом, и каждый дает пользователю конкретную гарантию. | Принцип | Правило | Что он гарантирует пользователю | | ------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Безопасность по умолчанию, простым языком, для всех одинаково | Каждое значение по умолчанию, сообщение и исправление безопасно сразу и понятно любому читателю, разработчику или нет. Ни один уровень пользователей не имеет преимуществ. | Новичок получает безопасный базовый уровень, не прося об этом, и читает результат в понятных ему терминах. | | Учет контекста вместо общих решений | Каждая фаза начинает с контекста, выявленного в detect, и действует исходя из того, что на самом деле делает система. | Рекомендации подходят проекту, а не чек-листу. Знания о безопасности заложены в спецификацию и ее специализации, загружаемые по запросу, и расширяют то, что приносит пользователь. | | Гибкость вместо жесткости | Принципы, требования и рекомендации служат отправной точкой. Пользователь может переформулировать, убрать, добавить или сузить что угодно. | Методология подстраивается под проект и пользователя и никогда не бывает жестче, чем хочет пользователь. Гибкость никогда не ослабляет базовый уровень безопасности по умолчанию. | | Сверять, а не только дописывать | Артефакты представляют собой живые документы, а не журналы. Каждый запуск перепроверяет каждую запись: сохраняет то, что верно, переписывает то, что изменилось, удаляет то, что больше не применимо. | Запись всегда отражает настоящее, поэтому никогда не превращается в устаревший бэклог. | | Только защита | SDH проводит аудит, усиливает защиту и проверяет. Она никогда не создает наступательных инструментов, эксплойтов для злонамеренного использования или способов обхода обнаружения во вред. | Методологию нельзя превратить в оружие. Материалы двойного назначения появляются только в явно защитном контексте. | | Сначала спецификация, под управлением агента, с прицелом на безопасность | Рабочий процесс строится из шаблонов, команд, управляющих принципов безопасности и агента, который проходит фазы. | Проверенная структура разработки, перепрофилированная так, чтобы основную работу по безопасности выполнял агент. | **Таблица 1.** Принципы проектирования SDH и гарантия, которую каждый из них дает пользователю. Эти принципы не декоративны. Это ограничения, которые обязана соблюдать каждая из описанных ниже фаз, и обсуждение в `§XV` возвращается к ним, чтобы обозначить пределы методологии. Остальная часть документа развивает девять именованных опор. Это части, которые читатель должен держать в голове, и части, которые другая команда реализовала бы заново, чтобы утверждать, что она применяет SDH. | Опора | Что она дает | Раздел | | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | | Инверсия с учетом контекста | Знания о безопасности заложены в спецификацию и ее специализации, загружаемые по запросу, поэтому новичок и эксперт проходят один процесс. | `§I`, `§VI` | | Пятифазный защитный жизненный цикл | Разделение обязанностей: политика, обнаружение, сортировка, исправление, проверка, у каждой одна задача. | `§IV` | | Закрываемость | У находки есть конечное состояние, а не бесконечный цикл. Закрытая работа снимается с учета. | `§V` | | Двойственность расширителя знаний разработчика | Один процесс, который защищает новичка и усиливает эксперта, никого из них не заменяя. | `§VI` | | Промпт по запросу, невызываемые знания | Нужные знания о безопасности загружаются под то, чем является проект, и никогда по умолчанию. | `§VII` | | Независимость от состояния и неавторитарная адаптивность | Подходит для любого состояния разработки на любом стеке и подстраивается под сценарий, а не навязывает охват. | `§VIII` | | Превентивный режим | Та же защита работает во время создания новой работы, поэтому код появляется безопасным по умолчанию. | `§IX` | | Отслеживание с идентификацией по имени | Находка остается одним элементом во всех фазах, а переименование ломает связь в одном месте. | `§XI` | | Носитель, независимый от агента | Ценность для безопасности записана один раз и не зависит ни от агента, ни от стека. | `§XII` | **Таблица 2.** Девять именованных опор SDH и раздел, где развивается каждая. --- ## IV. Пятифазный процесс Blue Team SDH выстраивает работу как пятифазный защитный жизненный цикл (рисунок 1). Каждая фаза построена вокруг защиты, каждая опирается на предыдущую, и фазы повторяют реальную деятельность Blue Team: установить политику, обнаружить, отсортировать, исправить, проверить. ```mermaid flowchart TB charter["1 · charter (политика)
читает: проект и описание пользователя, если оно есть
пишет: принципы безопасности
принципы называют риск, который предотвращают, простым языком"] detect["2 · detect (обнаружение)
читает: код пользователя
пишет: карту обнаружения
обнаруживать, а не выдумывать: фиксировать только то, что подтверждает код"] plan["3 · plan (сортировка)
читает: карту обнаружения, но никогда не код
пишет: план защиты
каждое исправление указывает на то, что действительно выявила detect"] harden["4 · harden (исправление)
читает: план защиты и код, который он затрагивает
пишет: код и журнал усиления защиты
единственная фаза, которая меняет код, по одному исправлению, наименьшим изменением, которое действует"] verify["5 · verify (проверка)
читает: код и журнал усиления защиты
пишет: каждый открытый вердикт в журнал усиления защиты
сопоставление кода с журналом, статически и без смягчения"] charter --> detect --> plan --> harden --> verify verify -.->|"отклонено: работа снова открыта для harden,
повторное применение с учетом записанной причины"| harden verify -.->|"закрытие: снимает доказанно закрытое
с учета во всей цепочке,
одна строка в истории"| detect ``` **Рисунок 1.** Пятифазный процесс: что читает каждая фаза, что она пишет и на каком инварианте держится. Verify управляет обоими возвратами: отклоненная мера защиты снова открывает harden, а доказанно закрытая находка снимается с учета во всей цепочке, оставляя одну строку в истории. Вкладом является само разделение обязанностей. Поскольку у каждой фазы одна задача, сбой ограничен одним местом, и читатель может доверять тому, что утверждает каждый артефакт. > **Ключевая мысль** > > **Применено не значит проверено:** harden фиксирует, что исправление применено. Verify проверяет его, сопоставляя код с этой записью, и вердикт никогда не смягчается ради соответствия записи. Мера защиты может присутствовать в коде и все равно оставлять риск достижимым, и тогда честный вердикт: "риск не закрыт". ### charter (политика) Charter задает принципы безопасности проекта, правила, которые обязана соблюдать каждая следующая фаза. Это управляющий уровень, своего рода проверка во время компиляции для уровня защищенности проекта. У каждого принципа есть понятное название, обязательное правило, которое можно проверить по коду, и строка `Why:`, называющая риск, который он предотвращает, а не только исправление. Charter всегда читает сам проект (его манифесты, структуру и зависимости), а описание пользователя, если оно есть, служит направлением, которое чтение затем расширяет за пределы названного пользователем. Без описания единственным источником остается проект. Эти два источника дополняют друг друга, а не соперничают, и charter фиксирует политику, которой должен придерживаться проект, а не состояние его кода. Не разработчик должен суметь прочитать его и понять и правило, и риск. ### detect (обнаружение) Detect читает код и выявляет, что на самом деле делает система такого, что имеет вес с точки зрения безопасности. Главное правило: "обнаруживать, а не выдумывать": фиксировать только то, что подтверждает код, со свидетельствами, которые нужны следующим фазам. Detect нейтральна. Она не подгоняет свои находки под принципы безопасности, потому что сопоставлять риски с правилами принципов безопасности должна фаза plan. Каждая находка состоит из трех частей: что это такое (описание простым языком), почему это важно (риск, а не только факт) и свидетельство (функция или маршрут, где она находится). Свидетельство не содержит пути к файлу. Путь хранится только в карте отслеживания (`§XI`), поэтому в тексте никогда нет пути, который может устареть. ### plan (сортировка) Plan превращает каждую находку в исправление, названное по классу риска (со ссылкой на признанные источники, CWE и OWASP, там, где они его обосновывают) и привязанное к принципу безопасности, который это исправление поддерживает. Приоритет (Critical, High, Medium, Low) не выбирается произвольно: plan оценивает каждую находку по методу CVSS v4.0 с метриками Base и Environmental, поэтому диапазон представляет собой оценку простыми словами, обоснованную одной строкой простым языком об открытости и ставках, и два запуска дают одинаковый порядок. Вектор служит точной опорой для эксперта, а диапазон и его обоснование представляют ту же оценку в виде, понятном любому. Plan работает только с картой обнаружения и никогда не читает код. Это сознательное ограничение, а не недостаток: оно заставляет каждое исправление указывать на то, что detect действительно обнаружила. Если какой-то охват так и не был выявлен, plan останавливается и отправляет пользователя обратно к detect, а не гадает. ### harden (исправление) Harden является единственной фазой, которая меняет код, поэтому действует осторожно. Нужно ли одобрение пользователя для правки, решает агент и режим разрешений, в котором он работает, поэтому harden не добавляет собственного шага подтверждения. Она применяет исправления по одному, сначала зависимости, затем самый высокий приоритет, чтобы каждое изменение оставалось небольшим, проверяемым и легко отменяемым. Она никогда не ослабляет существующую меру защиты, чтобы вписать новое исправление, и никогда не нарушает принцип безопасности. Если исправление противоречит принципу, harden останавливается и сообщает о конфликте, а не применяет его. Каждый блок фиксируется как Applied, Partial или Blocked. "Применено еще не значит проверено", и именно этим занимается следующая фаза. ### verify (проверка) Verify проверяет каждую примененную меру защиты, читая код и сопоставляя его с тем, что зафиксировала harden. Проверкой служит само это сопоставление кода с журналом, и оно статично: оно подтверждает, что мера защиты присутствует в коде и реализована правильно, а не то, что она выдерживает атаку на работающей системе. Такая проверка во время выполнения, при которой против работающей системы запускаются реальные или имитированные атаки, намеренно находится вне охвата. Verify выносит один из трех вердиктов: риск закрыт, риск не закрыт или по коду определить нельзя. Собственного артефакта она не создает: harden и verify делят журнал усиления защиты, harden владеет тем, что сделано, а verify вердиктом и его причиной, и ни одна из них никогда не пишет в поля другой. Отклоненная мера защиты становится снова открытой работой для harden, которая при следующем запуске считает вердикт приоритетнее собственного прочтения кода и применяет исправление заново, нацеливаясь ровно на тот пробел, который называет причина. Verify доверяет коду больше, чем журналу, потому что журнал может заявлять больше, чем дает код. Код пользователя она только читает и никогда не смягчает вердикт ради соответствия журналу. Мера защиты может присутствовать и все равно оставлять риск достижимым другим путем, и в этом случае честный вердикт: "риск не закрыт". Если при чтении verify замечает проблему безопасности, которую карта обнаружения так и не охватила, она не выдумывает для нее вердикт, поскольку обнаружение относится к задачам detect: она сообщает о проблеме и отправляет пользователя обратно к detect, чтобы находка вошла через тот же процесс, а не в обход него. > **Сквозной пример: загрузка файлов.** Одна находка показывает весь путь от начала до конца. > > - **detect** находит ее: система принимает файлы от пользователей, а обработчик загрузки доверяет MIME-типу, который присылает клиент, не проверяя настоящий тип файла. _Почему это важно:_ файл, замаскированный под изображение, может скрывать вредоносный код. > - **plan** определяет исправление с приоритетом **Critical**, поддерживающее принцип "Любой ввод считается недоверенным, пока не проверен": проверять настоящий тип и размер файла, переименовывать его при сохранении и хранить загрузки там, где их нельзя выполнить как код. > - **harden** применяет его со статусом **Applied**: теперь обработчик определяет настоящий тип по содержимому, ограничивает размер, отклоняет все неожиданное, переименовывает файл при сохранении и хранит его там, где код не может выполниться. > - **verify** читает обработчик, сопоставляет его с журналом и выносит вердикт **риск закрыт**: код делает ровно то, что заявлено в журнале. > > Одно и то же имя находки проходит через карту обнаружения, план и журнал усиления защиты, и verify работает с этим журналом под тем же именем: открытый вердикт записывается в блок находки, а доказанно закрытая находка снимается с учета (`§V`). Это общее имя служит ее идентификатором (`§XI`). --- ## V. Закрываемость: у находки есть конечное состояние Большинство инструментов безопасности оставляют пользователю бэклог, который только растет. SDH занимает другую позицию: **находка закрываема, поэтому у нее есть конечное состояние, а не жизнь в бесконечном бэклоге** (рисунок 2). Это прямо следует из принципа сверки. > **Определение** > > **Закрываемость:** риск, проверенный и закрытый, снимается с учета во всем процессе, поэтому находка достигает устойчивого состояния и открывается снова, только когда меняется код. У находки есть конечное состояние, хотя сама программа безопасности остается непрерывной. Артефакты SDH представляют собой живые документы, а не журналы событий. Каждый раз, когда фаза запускается заново, она перепроверяет каждую существующую запись по текущему положению дел и делает одно из трех: сохраняет то, что по-прежнему верно, переписывает то, что изменилось, или удаляет то, что больше не применимо. Находка, которая по коду теперь устранена, просто удаляется. Рабочая запись отражает настоящее, а не прошлое. Закрытие представляет собой ту же сверку, дошедшую до завершения. Когда verify проверяет, что риск закрыт, она снимает находку с учета во всем процессе: в карте обнаружения, плане, журнале усиления защиты и карте отслеживания. Именно поэтому verify является единственной фазой, которая пишет в артефакты других фаз: это фаза, замыкающая цикл. Когда находка покидает цепочку, снятие с учета сводит ее к короткой записи в журнале истории, который находится вне рабочей цепочки и никогда не обрабатывается повторно. В этом граница между исчезновением и закрытием: находка, которую сверка удалила, потому что она перестала быть верной, ничего после себя не оставляет, а доказанно закрытая находка заслуживает строку в истории. Снятая с учета находка затем отсутствует во всех рабочих артефактах, и это отсутствие ожидаемо, а не признак сломанной цепочки. ```mermaid stateDiagram-v2 direction TB [*] --> OPEN: detect обнаруживает OPEN --> Plan: plan Plan --> Harden: harden Harden --> Verify: verify Verify --> StoodDown: риск закрыт StoodDown --> SETTLED SETTLED --> OPEN: изменения кода снова открывают находку Plan: plan Harden: harden Verify: verify StoodDown: STOOD DOWN · одна строка в истории ``` **Рисунок 2.** Конечный автомат закрываемости. Находка проходит путь OPEN → STOOD DOWN → SETTLED и открывается снова, только когда меняется код. Когда все в пределах охвата снято с учета, цикл приходит в устойчивое состояние, и у этого состояния есть конкретная форма: артефакт, последняя находка которого закрыта, удаляется целиком, поэтому полностью закрытая цепочка оставляет только принципы безопасности и историю, политику и доказательство. Цикл открывается снова, только когда меняется код. Методология дает каждой находке определенный конец, а именно этого не может дать бесконечный бэклог. --- ## VI. Двойственность расширителя знаний разработчика SDH не заменяет людей и не заменяет специализированные инструменты Blue Team. Она **расширяет собственные знания разработчика**. Чем лучше разработчик понимает безопасность, тем точнее он может управлять процессом и тем больше у него автономии. Разработчик, который понимает мало, все равно получает безопасный результат, потому что его оберегает автоматический режим. Инверсия из `§I`, согласно которой знания о безопасности заложены в спецификацию, действует в обе стороны. Для новичка это защита: ему не нужно знать, о чем просить, потому что спецификация предлагает сама. Для эксперта это усиление: та же спецификация позволяет ему точно нацеливать процесс, а не бороться с фиксированным чек-листом. Каждая фаза несет эту двойственность в собственной работе (рисунок 3). Запущенная без входных данных, она действует на весь охват от имени пользователя. Получив направление, та же фаза сужается ровно до того, на что ее нацелил пользователь. ```mermaid flowchart TB inversion["одна инверсия, два направления:
знания о безопасности заложены в спецификацию"] inversion --> auto["автоматический режим (без входных данных)
фаза предлагает и действует
на весь охват"] inversion --> directed["направленный режим (с входными данными)
фаза сужается ровно до того,
на что ее нацелил пользователь"] auto --> novice["новичок под защитой:
безопасный результат без знания
того, о чем просить"] directed --> expert["эксперт с усилением:
процесс нацелен точно,
а не по фиксированному чек-листу"] novice -.-> phases["одни и те же пять фаз служат обоим:
charter · detect · plan · harden · verify"] expert -.-> phases ``` **Рисунок 3.** Двойственность расширителя знаний разработчика. Одна инверсия служит двум аудиториям: автоматический режим защищает новичка, а направленный режим усиливает эксперта, через одни и те же пять фаз. Специализации, загружаемые по запросу (`§VII`), делают эту двойственность явной в собственном тексте. Каждая из них говорит агенту, что ее знания "расширяют твое суждение", и велит продолжать рассуждать за пределами того, что дает специализация. Знания служат полом, а не потолком. Именно это обслуживает обе аудитории в том балансе, на который рассчитан документ: сообщество разработчиков получает весомый инструмент, а практик Blue Team получает структурированный носитель, который не делает вид, что выполняет его работу за него. --- ## VII. Невызываемые специализации и промпт по запросу Это самый новаторский шаблон методологии. SDH несет профильные знания о безопасности в виде специализаций, которые загружаются **только по запросу**, и агент сам решает, какие загрузить, сопоставляя их с контекстом проекта. Мы называем это **промптом по запросу**: способом, которым агент выбирает, какие знания активировать, исходя из охвата проекта, в котором он находится, вместо того чтобы запускать все проверки по умолчанию. Специализации эволюционируют, и любую из них можно в любой момент изменить или заменить. Вкладом является шаблон, а не сами специализации. > **Определение** > > **Промпт по запросу:** агент выбирает, какие знания о безопасности активировать, сопоставляя их с охватом проекта перед ним, поэтому нужные знания подключаются под то, чем проект является на самом деле, а не все проверки запускаются по умолчанию. > **Определение** > > **Невызываемая специализация:** профильная единица знаний о безопасности, независимая от языка, для одного контекста, например загрузки файлов или кода, выполняемого в браузере. Она проводит аудит и объясняет, никогда не переписывает код и никогда не создает атакующих входных данных. Это не команда: она загружается, когда охватываемый ею контекст находится в пределах охвата, или когда промпт просит ее по имени. Каждая специализация называет более безопасные формы для рисков, которые охватывает, и говорит агенту, как действовать с находкой в каждой фазе, которая ее использует: как оценить ее при обнаружении, как безопасно применить исправление при исправлении и как доказать его при проверке. Определяющая черта специализации в том, что она **сама по себе невызываема**: это не команда, и внутри процесса ее загружает совпадение. Фаза обнаружения один раз получает каталог, сопоставляет контекст проекта с тем, что охватывает каждая запись, и загружает только специализации, чей контекст присутствует в пределах охвата. Следующие фазы повторно используют этот подобранный список, а не получают каталог заново, поэтому одно сопоставление служит всей цепочке, а превентивный режим (`§IX`) выполняет то же сопоставление для работы, которую предстоит создать. Специализация, чей контекст отсутствует, пропускается, и за пропуск отвечают так же, как за загрузку: каждая запись в каталоге получает явный вердикт, применена или пропущена, с причиной, прочитанной из кода, поэтому смутное ощущение нерелевантности никогда не подменяет отсутствие. Не найти ни одной применимой специализации тоже допустимый результат. Каталог представляет собой данные, и рост означает один файл знаний плюс одну строку каталога, а не новую команду. Встроенные специализации сгруппированы по категориям, таким как OWASP, язык или интеграции с ИИ, а каталог, который использует проект, содержит встроенные специализации выбранных категорий плюс собственные специализации проекта. Проект фиксирует этот выбор вместе с остальным своим состоянием, поэтому вся команда сопоставляет код с одним и тем же каталогом. Это тот же принцип учета контекста, что и у фаз, примененный к знаниям: нужные знания подключаются под то, чем проект является на самом деле, а не все проверки запускаются по умолчанию. То же свойство позволяет пополнять каталог не только мейнтейнеру, но и пользователю: источник или тема по безопасности, которые дает пользователь, превращаются в новую специализацию, принадлежащую проекту, которая попадает в его каталог при любых категориях и загружается точно так же, как встроенная, заменяя встроенную с тем же именем. Создание специализации само по себе ориентировано только на защиту и подчиняется той же границе, которую соблюдают специализации: разбор атаки может быть источником, но полученная специализация проводит аудит и объясняет и никогда не выдает работающий эксплойт. Так инверсия из `§I`, согласно которой интеллект живет в спецификации, распространяется на сам каталог, который пользователь может углублять под свой контекст, не написав ни строки кода. Промпт по запросу хорошо показывает короткий пример. Detect читает папку с кодом, который выполняется в браузере. Она находит этот контекст в каталоге, загружает специализацию, которая его охватывает, и выводит находку на стороне клиента через обычные шаги detect. Специализации, чей контекст в этом охвате отсутствует, не совпадают, поэтому никогда не загружаются, и каждая из них фиксируется как пропущенная. Какие знания релевантны, решил проект, а не фиксированная конфигурация. Детерминированность появляется именно там, где она важна. Специализация может нести детерминированную проверку, а не только текст: там, где у класса рисков есть четкая процедура принятия решения, небольшая программа возвращает фиксированный вердикт для заданных входных данных, например одно из короткого набора слов, такого как `safe`, `unsafe` или `invalid input`. Некоторые классы рисков детерминированно разрешимы именно таким образом, и за процедурой принятия решения стоит корпус предшествующих работ `[9]`, `[10]`, `[11]`. Проверка либо оценивает кандидатов, которых предоставляет агент, либо сама сканирует охват, чтобы их найти, и в обоих случаях вердикт возвращает проверка, а не агент. Достаточно универсальную специализацию можно пометить в каталоге как обязательную, и тогда она применяется всегда, а ее проверка запускается по всему охвату. Это единственный случай, когда знания загружаются без совпадения контекста, и он объявлен в данных каталога, а не решается агентом в моменте. Именно здесь SDH закрепляет рассуждения агента на чем-то воспроизводимом, не делая вид, что весь процесс детерминирован. Наконец, специализации **отделяемы**. Поскольку знания самодостаточны, пользователь может запустить специализацию напрямую в промпте, который никак не связан с полным процессом SDH, сохраняя безопасность рядом с обычной разработкой. Специализация с детерминированной проверкой может, например, отсеивать каждого кандидата, созданного во время обычного программирования, и оставлять только безопасных. Эта отделяемость отчасти объясняет, почему SDH подстраивается под столько ситуаций, о чем идет речь в `§VIII`, а наиболее полно она выражена в превентивном режиме (`§IX`), где те же знания охраняют обычную разработку от начала до конца. --- ## VIII. Независимость от состояния и неавторитарная адаптивность Два свойства отличают SDH от жестких методологий на основе спецификаций. ### Независимость от состояния > **Определение** > > **Независимость от состояния:** методология не зависит от состояния разработки. Она подходит для пустой директории, проекта в процессе разработки, отдельного pull request или большой унаследованной кодовой базы на любом стеке, потому что узнает отправную точку, читая ее. Каждая фаза работает одинаково, будь проект совсем новым или уже существующим. Charter выводит принципы из любого присутствующего кода. Detect выявляет то, что есть в коде, даже если кода совсем мало. Никакой предполагаемой отправной точки нет. ### Неавторитарная адаптивность > **Определение** > > **Неавторитарная адаптивность:** методология подстраивается под сценарий, а не навязывает фиксированный охват, которому пользователь обязан следовать. Когда пользователь не знает, что сказать, она читает окружение, в котором ее вызвали, формирует контекст и задает вопросы, определяющие ее дальнейшие действия. Самый наглядный случай представляет собой режим предложения в charter: SDH выводит безопасные по умолчанию принципы безопасности, анализируя проект, спрашивает пользователя только тогда, когда пробел действительно меняет результат, затем записывает их и представляет каждый принцип простым языком вместе с риском, который он предотвращает. Принципы безопасности служат живым документом, который пользователь перерабатывает повторными запусками, а не контрактом, закрытым за запросом одобрения, поэтому от пользователя никогда не требуется знать, о чем просить. Эта адаптивность проявляется как чувствительность к форме входных данных: одна и та же фаза читает то, что ей дали, и выбирает режим (рисунок 4). Файл в промпте, находка из списка, опасение, целенаправленная миссия против известного слабого места или просьба о полном сканировании методом перебора: каждый вариант отвечает потребности пользователя, потому что процесс неавторитарен по замыслу. Ничто из этого не ослабляет базовый уровень безопасности по умолчанию. Гибкость определяет, как применяется базовый уровень, но никогда его не понижает. ```mermaid flowchart TB shape["фаза читает форму
того, что ей дали"] shape --> none["без входных данных"] shape --> paths["один или несколько путей"] shape --> concern["описанное опасение"] shape --> finding["находка по имени"] shape --> band["диапазон приоритета"] none --> auto["автоматический режим:
предложить или просканировать
весь охват"] paths --> focus["сосредоточиться только на этих
файлах или директориях"] concern --> scoped["ограничиться этим
одним опасением"] finding --> item["работать с этим одним
отслеживаемым элементом"] band --> priority["работать только с Critical,
High, Medium или Low"] ``` **Рисунок 4.** Неавторитарная адаптивность. Одна и та же фаза читает форму своих входных данных и выбирает режим, поэтому охват всегда принадлежит пользователю и никогда не навязывается. --- ## IX. Универсальный превентивный режим: та же защита во время создания работы SDH несет один дополняющий режим: обычную разработку, во время которой при написании кода активна та же защита. Пользователь просит саму работу, страницу входа, загрузку, эндпоинт, а методология охраняет разработку по ходу дела, поэтому результат безопасен по умолчанию с момента появления, а не после более позднего прохода по усилению защиты. > **Определение** > > **Превентивный режим:** обычная разработка, идущая под управляющим уровнем и знаниями SDH. Принципы безопасности связывают разработку, специализации, релевантные тому, что предстоит создать, загружаются по запросу, а результат сопоставляется ровно с той защитой, которая использовалась, прежде чем работа будет признана завершенной. Режим повторно использует каждую часть, которую уже несут фазы, направляя ее на код, которого еще не существует. Выявление контекста переходит от кода к намерению: агент продумывает, что он собирается создать и какие границы пересекает эта работа (вход в систему подразумевает учетные данные, сессию и ввод извне), и именно с этим рассуждением сопоставляется каталог знаний. Промпт по запросу (`§VII`) здесь обобщается: контекст можно выявить в плане кода, а не только в уже существующем коде. Принципы безопасности управляют, как всегда, а просьба, которая нарушила бы принцип, выводится как конфликт и никогда не реализуется. Защита применяется прямо по ходу, в момент написания каждой части: проверка на границе и выбор безопасной конструкции с первого раза, поэтому работающей, но небезопасной версии, которую пришлось бы исправлять, просто не возникает. Режим заканчивается так, как начинается verify. Прежде чем работа будет признана завершенной, создатель сопоставляет собственный результат с использованной защитой: мера защиты должна стоять на пути риска, а не рядом с ним, она должна быть полной, а там, где специализация несет детерминированную проверку, вердикт проверки ставится выше собственного прочтения агента. Найденный здесь пробел закрывается в рамках той же работы, потому что закончить работу значит закончить ее безопасно. То, от чего режим отказывается, так же продуманно, как то, что он делает. Он создает только то, о чем просили, и ничего вокруг не проверяет: аудит существующего относится к фазам. Он не пишет артефактов и не отслеживает находок, потому что находка представляет собой риск, обнаруженный в существующем, а цель этого режима в том, чтобы небезопасная версия вообще не появилась. Два направления дополняют друг друга: фазы закрывают то, что уже есть (`§V`), а превентивный режим не дает новой работе открыть это снова. Цепочка в состоянии покоя остается в покое не потому, что разработка остановилась, а потому, что все, что создается, пока она в покое, создается под защитой. --- ## X. Security-Driven Hardening и Spec-Driven Development Security-Driven Hardening (SDH) выросла на основе Spec-Driven Development (SDD), а затем резко отошла от нее. Структурное наследие реально и признано: спецификация на первом месте, управление агентом, управляющий документ и набор поэтапных команд, которые выполняет агент. SDH сознательно повторно использует эту структуру. Различаются цель, модель полномочий, предполагаемое состояние и условие завершения. Мы рассматриваем SDD как класс, используя отчет Piskala `[1]` как каноническое изложение методологии, Spec Kit от GitHub `[2]` как канонический инструментарий для агентов, а OpenSpec `[3]` как второй инструмент из того же семейства. SDD переворачивает традиционную разработку, делая спецификации исполняемыми: спецификация напрямую порождает работающую реализацию, а не просто направляет ее `[1]`. Ее набор фаз ведет разработку вперед `[2]` (установить управляющие принципы, описать, что создавать, спланировать технологический стек, разбить план на задачи, затем реализовать). Ее управляющий документ, конституция принципов, представляет собой основу, которой агент обязан придерживаться на протяжении всей работы. В этом суть различия. Полномочия SDD текут от спецификации к разработке, и от реализации ожидается, что она будет ей следовать. SDH переворачивает почти каждую ось этого контракта (таблица 3). > **Ключевая мысль** > > **Главное различие:** полномочия SDD текут от спецификации к разработке, и от реализации ожидается, что она будет ей следовать. SDH неавторитарна и течет в обратную сторону, внутрь от выявленного контекста системы, усиливая защиту того, что уже есть. | Ось | SDD | SDH | | ------------------------- | --------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | | Цель | Поставлять функции. Спецификация становится работающей реализацией. | Усиливать защиту того, что существует или создается. Каждая фаза построена вокруг защиты. | | Модель полномочий | Авторитарная. Спецификация и конституция ограничивают разработку охватом, которому она обязана следовать. | Неавторитарная. SDH подстраивается под сценарий, а пользователь может переформулировать, убрать или сузить охват. | | Предположение о состоянии | Разработка вперед от спецификации. | Независимость от состояния: пустая директория, проект в процессе разработки, отдельный PR или унаследованный код. | | Условие завершения | Заканчивается, когда функция создана. | Закрываемость. Находка достигает устойчивого состояния и открывается снова, только когда меняется код. | | Управляющий документ | Конституция принципов, которой агент обязан придерживаться. | Принципы безопасности, сформулированные через риски (у каждого есть строка `Why:`), явно не фиксированный контракт. | | Как растут знания | Добавить команду (или расширить набор фаз). | Добавить невызываемую специализацию, которую агент загружает по запросу: один файл плюс одна строка каталога, без новой команды. | | Кому служит | Тому, кто создает функцию и ведет ее вперед. | Любому пользователю, разработчику или нет, через один и тот же процесс. | | Что меняет код | Фаза реализации порождает сборку. | Код меняет только фаза harden, по одному исправлению. | **Таблица 3.** SDD и SDH по восьми осям. Заимствованная структура, перевернутый контракт. Справедливости ради по отношению к истокам: SDD является проверенной предшествующей работой, и SDH обязана ей структурой, на которой работает. Расхождение не является критикой SDD, которая хорошо решает другую задачу (разработку вперед). SDH берет тот же проверенный механизм и направляет его на защиту, адаптивность и закрытие. OpenSpec `[3]`, построенный вокруг предложений изменений, списков задач и спецификаций для каждого изменения, подтверждает шаблон: семейство ведет разработку вперед от спецификации, а SDH усиливает защиту системы внутрь от ее выявленного контекста. Даже превентивный режим SDH (`§IX`), единственное место, где она сопровождает разработку вперед, сохраняет перевернутый контракт: он управляет тем, как создается работа, и никогда не решает, что создавать. --- ## XI. Инженерная строгость: дисциплина отслеживания Дисциплине "сверять, а не дописывать" (`§V`) нужна основа, которая переживает рефакторинг. Находка должна оставаться одним элементом во всех фазах, которые с ней работают, а переименованный или перемещенный файл не должен ломать цепочку. SDH решает это с помощью **идентификации по имени** и **путей, которые хранятся только в отслеживании**. > **Определение** > > **Идентификация по имени:** идентификатор находки представляет собой ее имя, записанное одинаково в каждом артефакте. Текст несет имя, но никогда не путь. Пути к файлам хранятся только в карте отслеживания, поэтому переименование или перемещение файла ломает связь ровно в одном месте. Каждая находка detect представляет собой один отслеживаемый элемент. Его идентификатор представляет собой **имя**, заголовок раздела, записанный одинаково в карте обнаружения, плане и журнале усиления защиты. Следующие фазы дословно повторяют это имя, работая с тем же элементом, а verify записывает свой вердикт в журнал усиления защиты под тем же именем. Карта отслеживания хранит отслеживание и ничего больше, по одной записи на элемент: ```json { "name": "File uploads", "paths": ["src/routes/upload.ts"] } ``` Карта не хранит ни текста, ни аннотаций, ни отдельного идентификатора, ни фазы. Текстовые артефакты несут формулировки, а карта несет только идентификатор и пути. Пути к файлам представляют собой единственное изменчивое, и они хранятся только здесь. Переименование или перемещение файла может сломать связь ровно в одном месте, а не в двух расходящихся копиях. ```mermaid flowchart TB detect["карта обнаружения"] --> name plan["план защиты"] --> name harden["журнал усиления защиты
сюда verify записывает свой вердикт"] --> name name["name = "File uploads"
текст несет имя, но никогда не путь"] name -.-> tracking tracking["карта отслеживания
{ name: "File uploads",
paths: ["src/routes/upload.ts"] }
путь хранится только здесь, поэтому переименование исправляет только эту запись"] ``` **Рисунок 5.** Конвейер идентификации. Одно имя находки проходит через каждый артефакт, а ее путь хранится только в карте отслеживания, поэтому переименование исправляется в одном месте. В обычном процессе карту поддерживают два действия, а третье стоит особняком как обслуживание. **Track** выполняет регистрацию с добавлением: фаза сообщает о находках, которые записала, а движок фиксирует новые и для остальных следует за переименованным путем, классифицируя каждую как новую, перемещенную или неизменную. Он никогда не удаляет ничего, о чем фаза не сообщила. **Untrack** снимает с учета находки, которые закрыла verify: за один детерминированный проход сводит каждую к записи в истории, удаляет весь ее раздел из артефактов, удаляет артефакт, последняя находка которого исчезла, и убирает ее запись отслеживания, поэтому агенту не приходится делать ничего из этого вручную. Там, где детерминированный проход не может безопасно действовать, например когда имя снятой с учета находки все еще цитируется в тексте другой находки, он помечает это место для агента, а не гадает с правкой. Эти два действия фазы вызывают по ходу работы. **Repair** представляет собой действие по обслуживанию: фаза автоматически делегирует ему работу, когда ее собственная сверка находит отслеживание несогласованным (записанный путь больше не существует), а в остальных случаях его запускают по требованию. Он выравнивает всю карту сразу, читая каждый артефакт и текущий код, исправляя пути каждого элемента и выводя то, что не может решить сам: сироту (отслеживаемый элемент, который больше не называет ни один артефакт) или кандидата на переименование (элемент, пути которого совпадают с другим сообщенным именем). Repair является обслуживанием, а не шестой фазой. Он не трогает ни код пользователя, ни текстовые артефакты, только отслеживание. Исходный код пользователя он читает только по одной причине: чтобы узнать новый путь переименованного файла, и никогда не пишет содержимое о безопасности. Последнее слово остается за человеком в том единственном вопросе, в котором движок отказывается гадать: была ли исчезнувшая находка устранена или просто переименована. Лучше спросить, чем гадать, потому что ошибочно удаленный элемент ломает цепочку. Методология применяет собственную защитную дисциплину к самой себе. Детерминированные движки вызываются как программы командной строки, и каждое входное значение передается отдельным аргументом процесса, что делает его инертным, поэтому значение с кавычками или обратными кавычками никогда не может внедриться в команду. Неизвестная проверка завершается ошибкой, а не отвечает, поэтому проверка с опечаткой в имени никогда не выглядит как чистый результат. SDH не освобождает собственную инфраструктуру от принципа безопасности по умолчанию. --- ## XII. Носитель: архитектура, независимая от агента, как доказательство переносимости Чтобы SDH стала конвенцией, которую принимают другие, она не должна быть привязана к одному агенту или одному стеку, поэтому ее носитель разделяет три области ответственности (рисунок 6). Lagune доказывает, что это достижимо. **Ценность для безопасности** записана один раз и ничего не знает о том, какой агент ее выполняет: инструкции фаз и шаблоны, которые они заполняют, каталог знаний и детерминированные движки. **Доставка** тонкая: ее единственная задача в том, чтобы донести эту ценность до конкретного агента в той форме и в то место, которые агент ожидает, и собственной логики безопасности она не несет. **Состояние проекта** принадлежит проекту: принципы безопасности, артефакты фаз, карта отслеживания, выбранные категории и собственные специализации, которые коммитятся и проверяются, как любая другая часть его кода. ```mermaid flowchart TB value["ценность для безопасности, записанная один раз
инструкции фаз · шаблоны · каталог знаний · детерминированные движки
ничего не знает о том, какой агент ее выполняет"] delivery["доставка
доносит эту ценность до каждого агента в ожидаемой им форме
не несет логики безопасности"] agent["агент
проходит фазы"] project["состояние проекта
коммитится вместе с кодом
принципы безопасности · артефакты фаз · отслеживание · категории · собственные специализации"] value --> delivery --> agent agent -->|"читает и пишет"| project ``` **Рисунок 6.** Носитель, независимый от агента. Ценность для безопасности записана один раз, тонкая доставка доносит ее до каждого агента, а состояние остается за проектом. Поскольку доставка не несет логики безопасности, то, как она построена, ничего не меняет в SDH. Носитель может построить доставку сам или передать ее экосистеме, которая уже распространяет навыки для агентов, как это делает эталонная реализация, и фазы, их артефакты и их гарантии остаются прежними. Ничто из этого не привязано и к языку или среде выполнения. Эталонная реализация написана на одном конкретном стеке, но методология определяется границей между этими областями ответственности, а не инструментарием, которым они построены. Тот же замысел можно было бы заново реализовать на совсем другом языке, не меняя того, чем является SDH. --- ## XIII. Сквозной случай: SDH от начала до конца > **Сквозной случай** > > **Защитное усиление поверхности загрузки и администрирования.** > **Контекст:** небольшое приложение, которое принимает загрузку файлов от пользователей и показывает их на странице администратора. > **Схема:** charter → detect (со знаниями по запросу, активированными контекстом) → plan → harden → verify, с одним закрытием и одним настоящим провалом. > **Результат (возможности):** один риск проверен как закрытый и снят с учета во всей цепочке, а одна мера защиты проверена как _не_ закрытая и отправлена обратно к harden. Вердикт отражает код, а не журнал. _Это наглядный пример работы механизмов методологии, а не исследование с полевыми измерениями, и метрик эффективности в нем нет._ Один непрерывный разбор показывает методологию в действии, а не только ее части. Мы продолжаем сквозной пример с загрузкой файлов из `§IV`, добавляя активацию знаний по запросу и закрытие, и включаем один настоящий провал. 1. **charter** предлагает принцип "Любой ввод считается недоверенным, пока не проверен" с описанием риска простым языком: непроверенный ввод представляет собой самый распространенный способ взломать систему. 2. **detect** сканирует маршрут загрузки и небольшую страницу администратора, на которой перечислены загруженные файлы. Она обнаруживает находку загрузки (обработчик доверяет MIME-типу от клиента). Страница администратора выполняется в браузере, а этот контекст распознает промпт по запросу (`§VII`), поэтому detect загружает специализацию для этого контекста и выводит вторую находку: место, где имя файла записывается на страницу как разметка, а не как текст, поэтому специально сформированное имя может выполниться как скрипт в браузере посетителя. Специализации, чей контекст в этом охвате отсутствует, никогда не загружаются, и каждый пропуск фиксируется вместе с отсутствием, прочитанным из кода. 3. **plan** присваивает исправлению загрузки приоритет Critical и привязывает его к принципу: проверять настоящий тип и размер файла, переименовывать его при сохранении, хранить там, где код не может выполниться. Второму исправлению она присваивает приоритет High: выводить имя файла как текст, а не как разметку. 4. **harden** сначала применяет исправление загрузки (наивысший приоритет) и фиксирует его как Applied, а затем второе, тоже Applied. 5. **verify** читает каждое место и сопоставляет код с журналом. Мера защиты загрузки действует: обработчик определяет настоящий тип по содержимому, ограничивает размер и отклоняет все остальное. Вердикт: риск закрыт. Verify снимает находку загрузки с учета во всей цепочке, а ее краткая сводка попадает в историю. Затем следует настоящий провал. Предположим, что второе исправление harden добавило безопасную функцию вывода текста, но оставило старый вызов, записывающий разметку, достижимым по другому пути в коде. Verify читает страницу, видит безопасную функцию, а также видит, что небезопасный путь все еще работает. Мера защиты присутствует, но риск не закрыт. Verify отказывается смягчать вердикт ради соответствия журналу. Она выносит вердикт "риск не закрыт", фиксирует пробел и указывает обратно на harden. Мера защиты, которая не устраняет риск полностью, не считается пройденной. Таков характер методологии в одном примере: обнаружение с учетом контекста, исправления с приоритетами, привязанные к принципам, аккуратное применение и проверка, которая сообщает фактическое состояние кода независимо от журнала. --- ## XIV. Когда использовать SDH и ее пределы SDH редко бывает избыточной так, как бывает тяжеловесный процесс, потому что она не зависит от состояния и закрываема: она масштабируется вниз до одного файла и одного опасения и приходит в устойчивое состояние, а не оставляет постоянную нагрузку. Ее граница определяется не размером проекта, а **глубиной гарантий**. ```mermaid flowchart TB q1{"Делает ли код что-то, важное для безопасности?
(ввод, аутентификация, данные, секреты, внешние вызовы)"} q1 -->|нет| little["Здесь SDH мало что добавит."] q1 -->|да| q2{"Запустите SDH. Есть ли требования соответствия
или выделенная функция безопасности?"} q2 -->|нет| baseline["SDH служит обоснованным базовым уровнем."] q2 -->|да| carrier["SDH служит структурированным носителем:
она поддерживает экспертную проверку и аудит,
но не заменяет их."] ``` **Рисунок 7.** Когда использовать SDH. Сначала ветвление идет по важности для безопасности, затем по глубине гарантий и никогда по размеру проекта. Где SDH достигает своей границы: поведение, которое проявляется только при работе системы (verify читает код и не запускает систему), риск, зависящий от конфигурации или окружения, которое агент не может прочитать, и контексты с высокими ставками, где экспертная проверка требуется в любом случае. Во всех этих случаях SDH все равно приносит пользу как структурированный первый проход, но она служит полом, а не потолком. > **Ключевая мысль** > > **Граница:** предел SDH определяется глубиной гарантий, а не размером проекта. Она может служить обоснованным базовым уровнем почти везде и поддерживает экспертную проверку там, где этого требуют ставки, но не заменяет тестирование работающей системы или суждение специалиста по безопасности. --- ## XV. Обсуждение: позиционирование, пределы и то, чего SDH не утверждает SDH точно обозначает свои границы. ### Она расширяет, а не заменяет SDH не заменяет специалистов по безопасности или специализированные инструменты Blue Team. Она расширяет знания разработчика (`§VI`). Взвешенное утверждение здесь единственно верное: при правильном применении SDH **может** эффективно закрывать реальные риски, особенно в проектах, которые иначе вообще не получили бы проверки безопасности. Это не гарантия и не замена экспертной проверки там, где ее требуют ставки. ### Только защита, по устройству SDH проводит аудит, усиливает защиту и проверяет. Она никогда не создает наступательных инструментов, эксплойтов или способов обхода обнаружения во вред. Материалы двойного назначения допустимы только в явно защитном и санкционированном контексте. Это жесткая граница, а не предпочтение. ### Проверка содержательная, а не показная Verify проверяет, читая код и сопоставляя его с журналом, а не запуская систему. Это статическая проверка: она подтверждает, что мера защиты присутствует в коде и реализована правильно, и не доказывает, что мера выдерживает атаку во время выполнения. Поэтому "по коду определить нельзя" является законным вердиктом, а не провалом, скрытым за успешным результатом. Когда свидетельств в коде нет (они зависят от конфигурации или от пути, который агент не может прочитать), SDH так и говорит, а не гадает. ### Детерминированность ограничена и названа Большая часть SDH опирается на рассуждения агента, и именно это делает возможным учет контекста. Детерминированность закреплена за детерминированными движками: проверками, которые может нести специализация (`§VII`), и движком отслеживания (`§XI`). Документ не размывает эту границу. Там, где результат детерминирован, это результат программы. Там, где он выведен рассуждением, это прочтение кода агентом, а последнее слово остается за пользователем. ### Стоимость и масштаб Полное сканирование расходует много токенов. Ручные режимы (`§VI`, `§VIII`) существуют отчасти для того, чтобы стоимость оставалась соразмерной опасению. ### Последнее слово за пользователем SDH просит человека решить, переименована находка или устранена, а одобрение правок кода остается там, где пользователь уже управляет своим агентом, в режиме разрешений, в котором он его запускает. Методология предлагает и проверяет. Она не отменяет решения человека. ### Возражения и ответы Справедливый скептик выдвинет несколько возражений. Существенные из них стоит сформулировать их же словами. **"Разве это не просто статический анализатор с прикрученной LLM?"** Нет. Статический анализатор по умолчанию запускает все свои правила. SDH сначала выявляет, чем является система, затем обращается к релевантным знаниям (`§II`, `§VII`) и _встраивает_ детерминированную проверку только там, где у класса рисков есть четкая процедура принятия решения. Рассуждение начинается с контекста, а детерминированность точечна. **"Разве это не просто чек-лист безопасности?"** Нет. SDH переворачивает чек-лист: сначала идет обнаружение, а знания подключаются под то, что проект делает на самом деле (`§II`, `§VII`). **"Разве это не просто SDD, переименованная под безопасность?"** Нет. SDH заимствует структуру SDD и переворачивает ее контракт: полномочия, предположение о состоянии, условие завершения и то, кому она служит, различаются (`§X`). Тот же механизм, противоположное направление. **"Разве метод на основе рассуждений ИИ не будет просто галлюцинировать находки?"** Замысел ограничивает выдумку, а не полагается на хорошее поведение модели. Detect фиксирует только то, что подтверждает код ("обнаруживать, а не выдумывать", `§IV`), verify сопоставляет код с журналом и может ответить "по коду определить нельзя" (`§XV`), детерминированные проверки обосновывают однозначно решаемые случаи (`§VII`), а последнее слово остается за пользователем. Это не делает агента непогрешимым, но делает его утверждения проверяемыми. Замечание о позиционировании. Здесь SDH определена независимо от ее эталонной реализации. Пять фаз, принципы безопасности, сформулированные через риски, правило "сверять, а не дописывать" и закрываемость, знания по запросу, превентивный режим, отслеживание с идентификацией по имени и граница "только защита" составляют методологию. Другая команда могла бы реализовать их на другом стеке и в другой экосистеме агентов, и результат все равно был бы SDH. Lagune является ее доказательством, а не определением. --- ## XVI. Ловушки и то, как SDH структурно их избегает У методологий этого семейства есть общий известный набор сбоев. Ответ SDH на большинство из них структурный: он встроен в процесс, а не оставлен на дисциплину. | Ловушка | Сбой | Структурный ответ SDH | | --------------------------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | | Гниение спецификации, устаревший бэклог | Артефакты накапливают мертвые записи, которым никто не доверяет | Сверять, а не дописывать (`§V`): каждый запуск перепроверяет каждую запись и удаляет то, что устранено | | Ложная уверенность, успешный результат | Считается, что присутствующая мера защиты закрывает риск | Verify сопоставляет код с журналом, поэтому "риск не закрыт" и "определить нельзя" являются полноценными вердиктами (`§IV`, `§XV`) | | Лавина чек-листа | Общие пункты заслоняют единственный важный риск | Учет контекста вместо общих решений, а промпт по запросу загружает только то, чего требует охват (`§VII`) | | Привязка к инструменту | Метод намертво связан с одним поставщиком или агентом | Носитель, независимый от агента: ценность для безопасности записана один раз, а ее доставка каждому агенту не несет логики безопасности (`§XII`) | | Бесконечный цикл | Бэклог никогда не закрывается, работа никогда не приходит в покой | Закрываемость и устойчивое состояние (`§V`) | **Таблица 4.** Известные ловушки этого семейства методологий и структурный ответ SDH на каждую. Смысл в том, чтобы назвать ловушку и указать на механизм: это не предупреждения быть осторожнее, а свойства процесса. --- ## XVII. Дальнейшая работа У методологии и ее эталонной реализации есть ясные следующие шаги. - **Пополнять каталог знаний:** Каждое добавление сохраняет форму из `§VII`: файл знаний и строка каталога, без новой команды. Путь со стороны пользователя там уже есть: пользователь по запросу создает собственные специализации. Больше встроенных языков, сред выполнения и классов рисков, каждый из которых входит в категорию, составляют направление со стороны мейнтейнера, а сами специализации будут эволюционировать. - **Больше детерминированных проверок:** Там, где у класса рисков есть четкая процедура принятия решения, специализация может нести детерминированную проверку, которая закрепляет рассуждения агента на воспроизводимом вердикте. Распространить это на большее число классов рисков представляется естественным направлением. - **Эмпирическая оценка:** Самый важный открытый вопрос касается измеренной эффективности: качества закрытия и доли ошибочных вердиктов на реальных кодовых базах. Исследование результатов SDH в области безопасности относится к дальнейшей работе, и утверждения здесь сформулированы с учетом этого. --- ## XVIII. Заключение Разработка с помощью ИИ открыла брешь в безопасности, которую общие чек-листы не могут закрыть, потому что важный риск зависит от того, что на самом деле делает система, а тот, кто ее выпускает, может не знать, о чем спрашивать. SDH закрывает эту брешь процессом с учетом контекста, ориентированным только на защиту и закрываемым, в котором знания о безопасности заложены в методологию и ее специализации, загружаемые по запросу, это базовый уровень, на который может опереться любой пользователь. Она выявляет реальный контекст системы, сортирует риски, которые этот контекст несет, аккуратно применяет исправления и проверяет каждое из них, а затем снимает с учета то, что закрыла, чтобы каждая находка достигла конечного состояния. Та же защита работает и превентивно, пока создается новая работа, поэтому то, что процесс закрыл, остается закрытым. Она подстраивается под любое состояние разработки на любом стеке и расширяет знания разработчика, а не заменяет людей и инструменты, которые уже выполняют эту работу. Lagune является доказательством, но вкладом является конвенция. SDH предлагается как основной процесс безопасности для эпохи разработки с ИИ, чтобы другие могли принять ее, уточнить и реализовать на своих стеках. --- ## Источники **[1]** D. B. Piskala, "Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants," arXiv preprint arXiv:2602.00180v1 [cs.SE], Jan. 2026. (Submitted to AIWare 2026.) [Online]. Available: https://arxiv.org/abs/2602.00180 **[2]** GitHub, "Spec Kit: Toolkit for Spec-Driven Development." [Online]. Available: https://github.com/github/spec-kit. Accessed: 2026. **[3]** Fission AI, "OpenSpec: Spec-Driven Development for AI Coding Assistants." [Online]. Available: https://github.com/Fission-AI/OpenSpec. Accessed: 2026. **[4]** B. Chess and G. McGraw, "Static Analysis for Security," IEEE Security & Privacy, vol. 2, no. 6, pp. 76-79, 2004, doi: 10.1109/MSP.2004.111. **[5]** OWASP Foundation, "Source Code Analysis Tools." [Online]. Available: https://owasp.org/www-community/Source_Code_Analysis_Tools. Accessed: 2026. **[6]** OWASP Foundation, "OWASP Top 10:2021." [Online]. Available: https://owasp.org/Top10/. Accessed: 2026. **[7]** MITRE, "Common Weakness Enumeration (CWE)." [Online]. Available: https://cwe.mitre.org/. Accessed: 2026. **[8]** N. Perry, M. Srivastava, D. Kumar, and D. Boneh, "Do Users Write More Insecure Code with AI Assistants?," in Proc. ACM SIGSAC Conf. on Computer and Communications Security (CCS '23), 2023, pp. 2785-2799, doi: 10.1145/3576915.3623157. [Online]. Available: https://arxiv.org/abs/2211.03622 **[9]** J. Davis and contributors, "safe-regex: Detect Possibly Catastrophic, Exponential-Time Regular Expressions." [Online]. Available: https://github.com/davisjam/safe-regex. Accessed: 2026. **[10]** D. Soshnikov, "regexp-tree: Regular Expressions Processor in JavaScript." [Online]. Available: https://github.com/DmitrySoshnikov/regexp-tree. Accessed: 2026. **[11]** T. Jenkinson, "redos-detector: A CLI and Library to Score How Vulnerable a Regex Pattern Is to ReDoS Attacks." [Online]. Available: https://github.com/tjenkinson/redos-detector. Accessed: 2026. --- ## Приложение A: принципы дословно 1. **Безопасность по умолчанию, простым языком, для всех одинаково:** Каждое значение по умолчанию, сообщение и исправление должно быть безопасным сразу и понятным любому пользователю, разработчику или нет. Ни один уровень пользователей не имеет преимуществ перед другим. 2. **Учет контекста вместо общих решений:** Каждая фаза должна начинать с контекста, выявленного в detect, и действовать исходя из того, что на самом деле делает система. Предпочитайте рекомендации, характерные для этого контекста, общим чек-листам. Знания о безопасности заложены в спецификацию и ее специализации, загружаемые по запросу, и расширяют то, что приносит пользователь. 3. **Гибкость вместо жесткости:** SDH подстраивается под проект и пользователя. Принципы, требования и рекомендации служат отправной точкой, а не фиксированным контрактом. Позвольте пользователю переформулировать, убрать, добавить или сузить что угодно. Гибкость никогда не ослабляет базовый уровень безопасности по умолчанию, она лишь позволяет пользователю определять, как он применяется. 4. **Сверять, а не только дописывать:** Артефакты представляют собой живые документы, а не журналы. Когда фаза запускается снова, сверяйте каждую существующую запись с текущим положением дел: сохраняйте то, что по-прежнему верно, переписывайте то, что изменилось, и удаляйте то, что больше не применимо. Закрытие представляет собой ту же сверку, дошедшую до завершения. 5. **Только защита:** SDH проводит аудит, усиливает защиту и проверяет. Она никогда не создает наступательных инструментов, эксплойтов для злонамеренного использования или способов обхода обнаружения во вред. Материалы двойного назначения допустимы только в явно защитном и санкционированном контексте. 6. **Сначала спецификация, под управлением агента, с прицелом на безопасность:** Стройте рабочий процесс на проверенной структуре: шаблоны, команды, управляющие принципы безопасности и агент, который проходит фазы. Реализуйте эту структуру заново с защитной целью. --- # Глоссарий Lagune: SDH, принципы безопасности, находки и меры защиты > Определения простым языком для каждого термина Lagune и Security-Driven Hardening: SDH, charter, detect, находка, мера защиты, harden, verify, снятие с учета, закрываемость, специализации, категории и каталог. Канонический URL: https://lagune.ai/ru-RU/docs/references/glossary Язык: ru-RU Оригинал: https://lagune.ai/docs/references/glossary Последнее обновление: 2026-11-03 Все ключевые термины Lagune и методологии Security-Driven Hardening, каждый определен один раз и простым языком. ### Security-Driven Hardening (SDH) Методология, которую реализует Lagune: конвенция Blue Team с учетом контекста, которая выявляет контекст системы, сортирует риски, которые этот контекст несет, и направляет исправления. Знания о безопасности заложены в спецификацию и ее специализации, загружаемые по запросу, поэтому разработчик и не разработчик проходят один и тот же процесс. ### Lagune Эталонная реализация SDH: девять команд для агента, каждая с шаблоном, который она заполняет, и ИИ-агент запускает их, чтобы усилить защиту кодовой базы. Каждый агент устанавливает их через собственный установщик плагинов или через [**skills.sh**](https://www.skills.sh/wellwelwel/lagune), как показано на [странице установки](https://lagune.ai/ru-RU/docs), а для каждого детерминированного шага они запускают движок Lagune. ### Charter (принципы безопасности) Управляющий уровень Lagune: набор принципов с приоритетом безопасности, которые обязана соблюдать каждая следующая фаза. Считайте его проверкой во время компиляции для уровня защищенности проекта. Хранится в `.lagune/memory/charter.md`. ### Процесс разработки Универсальная команда `/lagune`, которая усиливает защиту кода прямо во время написания. Она принимает любой промпт на любом этапе, создает то, что вы попросили, и защищает результат безопасными настройками по умолчанию, прежде чем вернуть его вам, следуя принципам безопасности, если они есть. Она ничего не записывает в отслеживание Lagune, поэтому ее единственный результат: защищенный код. Вместе с принципами безопасности (до) и процессом Blue Team (после) именно так Lagune защищает во время разработки. ### Процесс Blue Team Пятифазный аудит, лежащий в основе Lagune: charter, detect, plan, harden, verify. Каждая фаза опирается на предыдущую. "Blue Team" обозначает традицию защитников в безопасности, в противовес атакующей Red Team. ### Находка Один обнаруженный риск. Каждая находка содержит, что это такое, почему это важно, и свидетельства в коде. Находка представляет собой единственную отслеживаемую единицу, которую переносят дальше plan, harden и verify, и во всех артефактах она определяется по имени. ### Мера защиты Мера безопасности, применяемая, чтобы закрыть риск. Harden применяет меры защиты, verify доказывает, что они действуют. Lagune никогда не ослабляет меру защиты ради промпта. ### Detect Фаза, которая читает код и выявляет, что делает система и где находятся риски. Ее главное правило: обнаруживать, а не выдумывать. Она фиксирует только то, что подтверждает код. ### Harden Единственная фаза, которая трогает ваш код. Она применяет исправления из плана по одному и фиксирует каждое как Applied, Partial или Blocked. Applied еще не означает, что исправление доказано. ### Verify Фаза, которая доказывает, что каждое примененное исправление действует, читая код и сопоставляя его с тем, что зафиксировала harden. Она выносит один из трех вердиктов: Risk closed, Risk not closed или Cannot tell from the code. ### Снятие с учета Когда verify доказывает, что риск закрыт, находка снимается с учета: с вашего подтверждения она удаляется из всей цепочки, чтобы ее больше не обрабатывали повторно. ### Закрываемость Свойство, благодаря которому у работы по безопасности есть конечное состояние. Поскольку доказанно закрытая находка снимается с учета, процесс может прийти в состояние покоя и открывается снова, только когда меняется код. SDH закрываем, а не бесконечный цикл. ### Движок Пакет `lagune` в **npm**, который команды запускают через `npx` для каждого детерминированного шага: хуков, каталога и категорий. ### Специализация Профильный модуль знаний о безопасности, независимый от языка, который загружается только по запросу и никогда по умолчанию. Специализация не является командой. Загрузите ее в любой промпт с помощью `read catalog ` движка, например `npx lagune read catalog regex`. ### Категория Именованная группа встроенных специализаций, от `owasp` до специализаций под конкретные языки, таких как `javascript`, `python`, `go` и `rust`. Категории, которые использует проект и которые зафиксированы в `.lagune/configs.json`, определяют, какие встроенные специализации попадут в его каталог. Пока не зафиксировано ни одной, проект использует только `owasp`. ### Каталог Набор специализаций, которые использует проект: встроенные специализации его категорий плюс собственные, написанные с помощью `/lagune-specialize`. Команда движка `read catalog` выводит его, а фазы сопоставляют его с кодом. ### Промпт по запросу Принцип, по которому нужные знания о безопасности подключаются под то, чем проект является на самом деле, а не все проверки запускаются по умолчанию. ### Идентификация по имени Модель отслеживания Lagune: имя каждой находки, записанное одинаково как заголовок раздела в каждом артефакте, служит ее идентификатором во всей цепочке. Карта отслеживания (`.lagune/tracking.json`) хранит только отслеживание и никогда не хранит текст. ## Частые вопросы ### Что такое Security-Driven Hardening (SDH)? SDH представляет собой методологию безопасности Blue Team с учетом контекста. Она выявляет контекст системы, сортирует риски, которые этот контекст несет, и направляет исправления, описывая каждую находку простым языком. Lagune является ее эталонной реализацией. ### Что такое принципы безопасности (charter) в Lagune? Принципы безопасности образуют управляющий уровень Lagune, набор принципов с приоритетом безопасности, которые обязана соблюдать каждая следующая фаза. Они хранятся в .lagune/memory/charter.md. ### Что значит снять находку с учета? Когда verify доказывает, что риск закрыт, находка снимается с учета: с вашего подтверждения она удаляется из всей цепочки, чтобы ее больше не обрабатывали повторно. --- # Схема конфигурации > JSON Schema для конфигурации проекта Lagune, дающая автодополнение и проверку в редакторе, следуя текущей версии Lagune или с закреплением конкретной версии. Канонический URL: https://lagune.ai/ru-RU/docs/references/configs-schema Язык: ru-RU Оригинал: https://lagune.ai/docs/references/configs-schema Последнее обновление: 2026-11-03 `.lagune/configs.json` фиксирует [**категории**](https://lagune.ai/ru-RU/docs/categories), которые использует проект, и индексирует его собственные [**специализации**](https://lagune.ai/ru-RU/docs/catalog). Его JSON Schema позволяет редактору автодополнять каждое поле и помечать опечатку или неизвестную категорию прямо во время правки файла. ## Текущая схема Каждый раз, когда **Lagune** записывает файл и не находит в нем `$schema`, он указывает в файле текущую схему: ```json { "$schema": "https://lagune.ai/schemas/configs.json", "categories": ["owasp", "javascript"] } ``` Этот адрес всегда следует за текущей версией **Lagune**. Файл, записанный до **Lagune** 0.16.0, получит его при следующем изменении, а до тех пор каждая фаза будет об этом напоминать. ## Закрепление версии Каждый релиз **Lagune** начиная с 0.16.0 несет схему в том виде, в каком она была в этой версии, опубликованную в **npm** и раздаваемую через **jsDelivr**. Чтобы закрепить версию, укажите нужную версию после `lagune@` в адресе `$schema`: ```json { "$schema": "https://cdn.jsdelivr.net/npm/lagune@0.16.0/schemas/configs.json" } ``` Версия принимает любой диапазон semver: | Версия | Схема | | ------------------- | ------------------------------- | | `0.16.0` | Схема из 0.16.0 | | `0.16.x` или `0.16` | Схема из последнего релиза 0.16 | | `0.x` или `0` | Схема из последнего релиза 0.x | | `latest` | Схема из последнего релиза | ## Частые вопросы ### Нужна ли Lagune схема? Нет. Схема помогает только редактору, а Lagune читает файл одинаково с $schema и без него. ### Перезапишет ли Lagune закрепленную схему? Нет. Lagune записывает $schema, только если в файле его нет, и сохраняет любой адрес, который вы задали. ### Когда стоит закреплять версию? Когда проект работает с конкретной версией Lagune, чтобы редактор проверял файл по тому, что принимает эта версия. --- # Lagune и Deepsec: два подхода к безопасности на основе ИИ бок о бок > Справочное сравнение Lagune и Deepsec от Vercel по принципу работы, жизненному циклу, обнаружению, стоимости, находкам и закрытию. Канонический URL: https://lagune.ai/ru-RU/docs/references/deepsec Язык: ru-RU Оригинал: https://lagune.ai/docs/references/deepsec Последнее обновление: 2026-11-03 [Lagune](https://github.com/wellwelwel/lagune) и [Deepsec](https://github.com/vercel-labs/deepsec) (`v2.2.1`) представляют собой два защитных ответа на одну и ту же проблему: безопасность в эпоху разработки с помощью ИИ. Их исходная посылка, их начало, середина и конец, а также то, как каждый из них предстает перед пользователем, расходятся намеренно, даже там, где их механизмы пересекаются. **Совет** Вдохновлен ли Lagune проектом Deepsec? Нет, Lagune написан с нуля и вдохновлен Spec-Driven Development и Security Hardening. Два проекта разрабатывались независимо, а это сравнение призвано помочь пользователям понять их различия. ## Коротко | Аспект | Lagune | Deepsec | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------ | | Тип | Методология (SDH) с эталонной реализацией | Продукт: сканер уязвимостей на основе агентов | | Центр тяжести | Принципы безопасности и знания по запросу ведут агента, опираясь на детерминированные хуки | Широкая сеть регулярных выражений питает обязательное расследование ИИ | | Что он создает | Защищенный код, доказательства и отслеживаемую цепочку находок | Отчет о находках с сортировкой и ранжированием по критичности | | Трогает ли ваш код | Да: `harden` правит ваш код | Нет: только статический анализ, выдает находки и текст рекомендаций | | Среда выполнения | Работает на том агенте и той модели, которые у вас уже есть, любого уровня | Запускает собственный конвейер моделей, по умолчанию уровня frontier | | Начало работы | Одна установка плагина или `npx skills add`, а дальше управление простым языком, без нового инструмента, который нужно разворачивать | Развернуть рабочее пространство `.deepsec/`, установить зависимости и добавить ключ модели | ## Как это работает Lagune ставит агента на первое место: агент ведет работу, подключает знания по запросу под то, чем является код, и делегирует однозначно решаемую часть детерминированным хукам. Deepsec ставит на первое место детерминированность: широкое сканирование помечает кандидатов, которые указывают обязательной модели, что расследовать и оценивать. | Аспект | Lagune | Deepsec | | ------------------------ | ------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------- | | Порядок | Принципы безопасности и подобранные знания направляют агента, который делегирует хукам и оценивает остальное | Сопоставители помечают кандидатов, модель расследует и оценивает каждого | | Роль детерминированности | Многоязычные хуки, которые выносят вердикт или нацеливают агента, в сочетании со знаниями категорий | Сопоставители, которые помечают кандидатов для оценки обязательной моделью | | Процесс разработки | `/lagune` создает безопасный код прямо по ходу программирования | Он проверяет код, но не пишет его | | Процесс аудита | `charter` → `detect` → `plan` → `harden` → `verify` | `scan` → `process` → `triage` → `revalidate` → `report` | | Задача ИИ | Рассуждать на основе знаний, применить исправление и доказать, что оно действует | Расследовать каждого кандидата и сообщить о находках | ## Жизненный цикл Lagune работает до, во время и после написания кода. Deepsec проверяет репозиторий, когда код уже существует. | Момент | Lagune | Deepsec | | ---------------------- | ------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- | | До появления кода | `charter` выводит политику безопасности из заявленного намерения | Начинает с существующего кода: `init` нужна директория | | Во время разработки | `/lagune` создает код, безопасный по умолчанию, прямо по ходу, не оставляя артефактов | Проверяет после разработки, а не во время нее | | Для существующего кода | `detect` → `plan` → `harden` → `verify` | `scan` → `process`, основной процесс | | Непрерывная проверка | Повторный запуск фаз для нужного охвата, без готового шлюза для CI | Инкрементальное повторное сканирование, `process --diff` как шлюз выхода в CI | ## Уровень обнаружения Два детерминированных уровня противоположны по природе: один решает, другой помечает. | Аспект | Lagune | Deepsec | | ------------------- | ------------------------------------------------------------------------- | --------------------------------------------------------------------- | | Группировка | Хуки и специализации, сгруппированные по категориям | Сопоставители для каждого шаблона или фреймворка | | Вывод | Буквальный вердикт (finding / review / advisory) плюс метка классификации | Кандидат без вердикта (slug, строки, фрагмент, совпавший шаблон) | | Настройка | Точность: учет комментариев, защита от заглушек и окна контекста | Полнота: широкие сети, а ложные срабатывания потом отсекает ИИ | | Глубина | Глубже в общих классах | Шире, но менее глубоко в общих классах | | Ложные срабатывания | Удерживаются на низком уровне у источника, затем оцениваются в контексте | Намеренно генерируются с избытком и сокращаются проходом `revalidate` | ## Знания и суждение Оба несут знания о безопасности, недоступные регулярным выражениям. Различаются они тем, где эти знания живут и кто может их формировать. | Аспект | Lagune | Deepsec | | ----------------------- | ----------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------ | | Форма | Редактируемые модули на markdown, некоторые из которых опираются на детерминированный хук | Короткий промпт и подсказки по технологиям, опирающиеся на собственные знания модели | | Выбор | Подбираются под код и загружаются, только когда присутствует их контекст | Внедряется в каждый пакет для ИИ, плюс подсказки для обнаруженных технологий | | Кто их пишет | Пользователь правит модули и добавляет новые с помощью `specialize` | Промпт принадлежит мейнтейнеру, а пользователь заполняет `INFO.md` | | Где находится суждение | Хуки решают свой минимум, а остальное агент оценивает на основе знаний | Централизованно: один обработчик ИИ оценивает каждого кандидата | | Повторное использование | Один модуль направляет и `detect`, и `verify` | Один промпт управляет единственным этапом `process` | ## Находки и закрытие Сильнее всего они расходятся в том, чем становится находка, когда она устранена. | Аспект | Lagune | Deepsec | | ------------------- | ------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------- | | Критичность | Оценка CVSS v4.0 с поправкой на открытость и ставки | Критичность от ИИ плюс сортировка P0 / P1 / P2 по эксплуатируемости и последствиям | | Вердикты | Risk closed, Risk not closed или Cannot tell from the code | true-positive, false-positive, fixed, uncertain, accepted-risk, duplicate | | Хранение | Рабочая цепочка сверяется, закрытые находки сводятся в историю | Записи по файлам только с добавлением, ничего не удаляется | | Конечное состояние | Закрываемо: доказанная находка снимается с учета, цепочка может прийти в покой | Каждая находка хранится навсегда и скрывается из представлений после устранения | | Подробность истории | Краткая сводка того, в чем состоял риск | Полный след вердиктов, включая то, как проблема была исправлена | ## Стоимость | Аспект | Lagune | Deepsec | | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Детерминированный минимум | Бесплатно: хуки работают без ИИ и без ключа и уже выносят вердикты | Бесплатно: `scan` работает без ИИ, но сам по себе вердиктов не выносит | | Типичный счет | Входит в стоимость агента, которым вы уже пользуетесь: от $0 на локальной модели до цены вашего текущего тарифа или оплаты за каждую итерацию при работе через API | [Примерно от $25 до $1200 за запуск на 100–2000 файлов, больше при большем масштабе](https://github.com/vercel-labs/deepsec/blob/f75a16803ec5250938bacfe41571d929e8564f45/docs/getting-started.md#run-the-ai-investigation) | | Самый дешевый путь | Любая модель, включая бесплатную локальную, закрывает цикл | Есть более дешевые платные тарифы, но для находок нужен платный этап ИИ | ## Расширяемость и управление Каждый открывает тот уровень, который другой держит закрытым. | Аспект | Lagune | Deepsec | | ------------------------ | ------------------------------------------------------------- | --------------------------------------------------------- | | Что вы расширяете | Правите модули или добавляете новые через `specialize` | Добавляете сопоставители, агентов, уведомители и владение | | Уровень политики | Принципы безопасности управляют каждой фазой и версионируются | Конфигурация операционная (сопоставители, модели, пути) | | Переопределение по имени | Уточненный модуль перекрывает встроенный | При совпадении slug сопоставителя побеждает ваш | ## Интерфейсы Deepsec выдает материалы для службы безопасности. Lagune показывает представление в реальном времени для того, кто его запускает. | Аспект | Lagune | Deepsec | | ------------------------------ | ----------------------------------------------------------------- | ----------------------------------------------------------------------------- | | Интерфейс для человека | Локальный дашборд всей цепочки в реальном времени, простым языком | Файлы отчета, экспорта, метрик и комментариев к PR, плюс сайт с документацией | | Ответственность | Показывает файлы и примененные специализации | Предлагает ответственного: дежурного, руководителя или автора коммита | | Воспроизводимое доказательство | `prove` пишет запускаемые тесты и бюллетень для раскрытия | Намеренно остается статическим и никогда не запускает цель | | Самозащита инструмента | Защищает локальный API записи в дашборде | Защищает собственное выполнение ИИ от недоверенного кода цели | ## Масштаб и развертывание | Аспект | Lagune | Deepsec | | -------------------- | --------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | | Установка | Девять команд из плагина вашего агента или CLI skills, ничего не генерируется в проекте | Рабочее пространство `.deepsec/` с собственным пакетом и зависимостями | | Направление масштаба | Ограничивается любой частью, контекстом, от одного файла до всего проекта | Проходит целые репозитории, вплоть до больших монорепозиториев | | Распространение | Только локально, единственный сервер привязан к loopback | Необязательное распределение по рабочим виртуальным машинам Vercel Sandbox | ## Пользовательский опыт Как каждый встречает того, кто его запускает: что нужно для первого запуска и как оператор его направляет. ### Первый запуск Lagune работает через уже открытого агента. Deepsec сначала разворачивает собственное рабочее пространство и доступ к модели. | Аспект | Lagune | Deepsec | | -------------------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------ | | Первая команда | Установка плагина или `npx skills add wellwelwel/lagune`, затем `/lagune-*` в агенте | `npx deepsec init`, затем `cd .deepsec`, `pnpm install`, `scan`, `process` | | Учетные данные для запуска | Отдельный ключ не нужен, используется ваш текущий агент | Ключ модели (например, AI Gateway, 12-часовой токен Vercel OIDC или токен Anthropic) | ### Управление Оба принимают указания. Lagune читает форму входных данных для каждой фазы. Deepsec сужает набор файлов, по которому идет то же самое расследование. | Аспект | Lagune | Deepsec | | ------------------- | ---------------------------------------------------------------------------- | ---------------------------------------------------- | | Весь проект | Фаза без входных данных сканирует весь охват | `scan` и `process` проходят репозиторий | | Часть проекта | Любую фазу можно ограничить заданными файлами или директориями | `--files`, `--files-from` или `--diff` сужают запуск | | Опасение | Фазу можно ограничить описанным опасением | Промпт расследования фиксирован | | Диапазон приоритета | `harden` и `verify` можно ограничить уровнями Critical, High, Medium или Low | Находки получают метки после запуска | | Отдельное значение | Хук напрямую оценивает один фрагмент, шаблон или URL (`--pattern`, `--url`) | Единица работы: файл | ## Частые вопросы ### Чем Lagune отличается от Deepsec? Lagune ставит агента на первое место и работает до, во время и после написания кода: задает политику до появления кода, усиливает защиту прямо во время разработки и проводит аудит, исправляет и проверяет уже написанный код. Deepsec ставит на первое место детерминированность: широкое сканирование регулярными выражениями питает обязательное расследование моделью уровня frontier, которое проверяет существующий код и сообщает о находках, не меняя его. ### Можно ли запустить любой из них бесплатно? Весь процесс Lagune может работать за $0 на бесплатной локальной модели, а его детерминированные хуки выносят вердикты вообще без ИИ. Сканирование Deepsec бесплатно, но не выносит вердиктов, поэтому для любой находки нужен его платный этап ИИ. ### Меняет ли кто-то из них мой код? Lagune меняет: harden применяет исправления к вашему коду. Deepsec не меняет: это только статический анализ, который выдает находки и текст рекомендаций, а применяет их отдельно человек или агент. --- # Источники OWASP > Откуда берутся знания встроенных специализаций OWASP, с привязкой к каноническим страницам атак и Cheat Sheet от OWASP. Канонический URL: https://lagune.ai/ru-RU/docs/references/owasp-sources Язык: ru-RU Оригинал: https://lagune.ai/docs/references/owasp-sources Последнее обновление: 2026-11-03 Этот документ относит каждую **атаку** (`www-community`) и каждый **Cheat Sheet** (`CheatSheetSeries`) от OWASP к категории безопасности, со ссылкой на каноническую публичную страницу. Внутри категории равнозначные пункты делят одну строку чек-листа: атаки и cheat sheets, которые касаются одного и того же риска, перечислены вместе через запятую. Пункты без прямого соответствия стоят на отдельной строке. - Авторство принадлежит OWASP. Атаки находятся по адресу `https://owasp.org/www-community/attacks/`, а cheat sheets по адресу `https://cheatsheetseries.owasp.org/cheatsheets/.html`. --- ## 1. Инъекции (общие) - [x] [Code Injection](https://owasp.org/www-community/attacks/Code_Injection), [Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_Cheat_Sheet.html), [Injection Prevention in Java](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_in_Java_Cheat_Sheet.html) (interpreter) - [x] [Direct Dynamic Code Evaluation (Eval Injection)](https://owasp.org/www-community/attacks/Direct_Dynamic_Code_Evaluation_Eval_Injection) (interpreter) - [x] [Function Injection](https://owasp.org/www-community/attacks/Function_Injection) (interpreter) - [x] [Resource Injection](https://owasp.org/www-community/attacks/Resource_Injection) (network) - [x] [Special Element Injection](https://owasp.org/www-community/attacks/Special_Element_Injection) (interpreter) - [x] [Custom Special Character Injection](https://owasp.org/www-community/attacks/Custom_Special_Character_Injection) (interpreter) - [x] [Comment Injection Attack](https://owasp.org/www-community/attacks/Comment_Injection_Attack) (interpreter) - [x] [Parameter Delimiter](https://owasp.org/www-community/attacks/Parameter_Delimiter) (interpreter) - [x] [Server-Side Includes (SSI) Injection](https://owasp.org/www-community/attacks/Server-Side_Includes_%28SSI%29_Injection) (interpreter) - [x] [Input Validation](https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html), [Bean Validation](https://cheatsheetseries.owasp.org/cheatsheets/Bean_Validation_Cheat_Sheet.html) (interpreter) --- ## 2. Инъекции в SQL и базы данных - [x] [SQL Injection](https://owasp.org/www-community/attacks/SQL_Injection), [SQL Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html), [Query Parameterization](https://cheatsheetseries.owasp.org/cheatsheets/Query_Parameterization_Cheat_Sheet.html) (sql) - [x] [Blind SQL Injection](https://owasp.org/www-community/attacks/Blind_SQL_Injection) (sql) - [x] [SQL Injection Bypassing WAF](https://owasp.org/www-community/attacks/SQL_Injection_Bypassing_WAF) (sql) - [x] [RSQL Injection](https://owasp.org/www-community/attacks/RSQL_Injection) (interpreter) - [x] [Database Security](https://cheatsheetseries.owasp.org/cheatsheets/Database_Security_Cheat_Sheet.html) (sql) - [x] [NoSQL Security](https://cheatsheetseries.owasp.org/cheatsheets/NoSQL_Security_Cheat_Sheet.html) (interpreter) --- ## 3. Инъекции команд ОС - [x] [Command Injection](https://owasp.org/www-community/attacks/Command_Injection), [OS Command Injection Defense](https://cheatsheetseries.owasp.org/cheatsheets/OS_Command_Injection_Defense_Cheat_Sheet.html) (interpreter) --- ## 4. Инъекции в LDAP, XPath и XML - [x] [LDAP Injection](https://owasp.org/www-community/attacks/LDAP_Injection), [LDAP Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/LDAP_Injection_Prevention_Cheat_Sheet.html) (interpreter) - [x] [XPATH Injection](https://owasp.org/www-community/attacks/XPATH_Injection) (interpreter) - [x] [Blind XPath Injection](https://owasp.org/www-community/attacks/Blind_XPath_Injection) (interpreter) - [x] [XML External Entity (XXE) Prevention](https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html), [XML Security](https://cheatsheetseries.owasp.org/cheatsheets/XML_Security_Cheat_Sheet.html) (xml) --- ## 5. Межсайтовый скриптинг (XSS) - [x] [Cross Site Scripting (XSS)](https://owasp.org/www-community/attacks/Cross-site-Scripting-%28XSS%29), [Cross Site Scripting Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html), [XSS Filter Evasion](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html) (browser) - [x] [DOM Based XSS](https://owasp.org/www-community/attacks/DOM_Based_XSS), [DOM based XSS Prevention](https://cheatsheetseries.owasp.org/cheatsheets/DOM_based_XSS_Prevention_Cheat_Sheet.html), [DOM Clobbering Prevention](https://cheatsheetseries.owasp.org/cheatsheets/DOM_Clobbering_Prevention_Cheat_Sheet.html) (browser) - [x] [Reflected DOM Injection](https://owasp.org/www-community/attacks/Reflected_DOM_Injection) (browser) - [x] [XSS in Converting File Content to Text](https://owasp.org/www-community/attacks/XSS_in_Converting_File_Content_to_Text) (browser) - [x] [XSS in subtitle](https://owasp.org/www-community/attacks/Xss_in_subtitle) (browser) - [x] [Cross Frame Scripting](https://owasp.org/www-community/attacks/Cross_Frame_Scripting) (browser) - [x] [Cross Site Tracing](https://owasp.org/www-community/attacks/Cross_Site_Tracing) (browser) - [x] [Content Security Policy](https://cheatsheetseries.owasp.org/cheatsheets/Content_Security_Policy_Cheat_Sheet.html) (browser) --- ## 6. Межсайтовая подделка запросов (CSRF) и clickjacking - [x] [Cross Site Request Forgery (CSRF)](https://owasp.org/www-community/attacks/cross-site-request-forgery), [XSRF](https://owasp.org/www-community/attacks/XSRF), [Cross-Site Request Forgery Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html) (http-request) - [x] [Clickjacking](https://owasp.org/www-community/attacks/Clickjacking), [Clickjacking Defense](https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking_Defense_Cheat_Sheet.html) (browser) - [x] [Cross Site History Manipulation (XSHM)](https://owasp.org/www-community/attacks/Cross_Site_History_Manipulation_%28XSHM%29) (browser) - [x] [Form action hijacking](https://owasp.org/www-community/attacks/Form_action_hijacking) (network) - [x] [Reverse Tabnabbing](https://owasp.org/www-community/attacks/Reverse_Tabnabbing) (browser) --- ## 7. Перенаправления и переадресации - [x] [Open Redirect](https://owasp.org/www-community/attacks/open_redirect), [Unvalidated Redirects and Forwards](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) (network) - [x] [Execution After Redirect (EAR)](https://owasp.org/www-community/attacks/Execution_After_Redirect_%28EAR%29) (browser) --- ## 8. Контроль доступа и авторизация - [x] [Insecure Direct Object Reference (IDOR)](https://owasp.org/www-community/attacks/insecure_direct_object_reference), [Insecure Direct Object Reference Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Insecure_Direct_Object_Reference_Prevention_Cheat_Sheet.html) (access-control) - [x] [Forced browsing](https://owasp.org/www-community/attacks/Forced_browsing) (access-control) - [x] [Web Parameter Tampering](https://owasp.org/www-community/attacks/Web_Parameter_Tampering) (access-control) - [x] [Setting Manipulation](https://owasp.org/www-community/attacks/Setting_Manipulation) (access-control) - [x] [Authorization](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html) (access-control) - [x] [Transaction Authorization](https://cheatsheetseries.owasp.org/cheatsheets/Transaction_Authorization_Cheat_Sheet.html) (access-control) - [x] [Mass Assignment](https://cheatsheetseries.owasp.org/cheatsheets/Mass_Assignment_Cheat_Sheet.html) (access-control) - [x] [Multi-Tenant Application Security](https://cheatsheetseries.owasp.org/cheatsheets/Multi_Tenant_Security_Cheat_Sheet.html) (access-control) --- ## 9. Аутентификация и учетные данные - [x] [Brute Force Attack](https://owasp.org/www-community/attacks/Brute_force_attack), [Password Spraying Attack](https://owasp.org/www-community/attacks/Password_Spraying_Attack), [Bot Management and Anti-Automation](https://cheatsheetseries.owasp.org/cheatsheets/Bot_Management_and_Anti-Automation_Cheat_Sheet.html) (credential-endpoint) - [x] [Credential stuffing](https://owasp.org/www-community/attacks/Credential_stuffing), [Credential Stuffing Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Credential_Stuffing_Prevention_Cheat_Sheet.html) (credential-endpoint) - [x] [Qrljacking](https://owasp.org/www-community/attacks/Qrljacking) (federation) - [x] [Authentication](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html), [Multifactor Authentication](https://cheatsheetseries.owasp.org/cheatsheets/Multifactor_Authentication_Cheat_Sheet.html) (access-control) - [x] [Password Storage](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html) (access-control) - [x] [Forgot Password](https://cheatsheetseries.owasp.org/cheatsheets/Forgot_Password_Cheat_Sheet.html), [Choosing and Using Security Questions](https://cheatsheetseries.owasp.org/cheatsheets/Choosing_and_Using_Security_Questions_Cheat_Sheet.html) (access-control) - [x] [Email Validation and Verification in Identity Systems](https://cheatsheetseries.owasp.org/cheatsheets/Email_Validation_and_Verification_Cheat_Sheet.html) (access-control) --- ## 10. Управление сессиями - [x] [Session fixation](https://owasp.org/www-community/attacks/Session_fixation), [Session hijacking attack](https://owasp.org/www-community/attacks/Session_hijacking_attack), [Session Prediction](https://owasp.org/www-community/attacks/Session_Prediction), [Session Management](https://cheatsheetseries.owasp.org/cheatsheets/Session_Management_Cheat_Sheet.html) (access-control) - [x] [Cookie Theft Mitigation](https://cheatsheetseries.owasp.org/cheatsheets/Cookie_Theft_Mitigation_Cheat_Sheet.html) (access-control) --- ## 11. Федерация идентификации (OAuth, SAML, JWT) - [x] [OAuth 2.0 Protocol](https://cheatsheetseries.owasp.org/cheatsheets/OAuth2_Cheat_Sheet.html) (federation) - [x] [SAML Security](https://cheatsheetseries.owasp.org/cheatsheets/SAML_Security_Cheat_Sheet.html) (federation) - [x] [JSON Web Token for Java](https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html) (federation) --- ## 12. Криптография и безопасность передачи данных - [x] [Cryptanalysis](https://owasp.org/www-community/attacks/Cryptanalysis), [Cryptographic Storage](https://cheatsheetseries.owasp.org/cheatsheets/Cryptographic_Storage_Cheat_Sheet.html), [Key Management](https://cheatsheetseries.owasp.org/cheatsheets/Key_Management_Cheat_Sheet.html) (crypto) - [x] [Manipulator-in-the-Middle (MITM)](https://owasp.org/www-community/attacks/Man-in-the-middle_attack), [Transport Layer Security](https://cheatsheetseries.owasp.org/cheatsheets/Transport_Layer_Security_Cheat_Sheet.html) (transport) - [x] [HTTP Strict Transport Security](https://cheatsheetseries.owasp.org/cheatsheets/HTTP_Strict_Transport_Security_Cheat_Sheet.html) (transport) - [x] [Pinning](https://cheatsheetseries.owasp.org/cheatsheets/Pinning_Cheat_Sheet.html) (transport) --- ## 13. Подделка запросов на стороне сервера (SSRF) - [x] [Server Side Request Forgery](https://owasp.org/www-community/attacks/Server_Side_Request_Forgery), [Server-Side Request Forgery Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html) (network) --- ## 14. Path traversal и работа с файлами - [x] [Path Traversal](https://owasp.org/www-community/attacks/Path_Traversal) (path) - [x] [Binary Planting](https://owasp.org/www-community/attacks/Binary_planting) (path) - [x] [Windows ::DATA Alternate Data Stream](https://owasp.org/www-community/attacks/Windows_DATA_alternate_data_stream) (path) - [x] [Embedding Null Code](https://owasp.org/www-community/attacks/Embedding_Null_Code) (path) - [x] [File Upload](https://cheatsheetseries.owasp.org/cheatsheets/File_Upload_Cheat_Sheet.html) (upload) --- ## 15. Злоупотребление протоколом HTTP (заголовки, кеширование, splitting) - [x] [HTTP Response Splitting](https://owasp.org/www-community/attacks/HTTP_Response_Splitting), [Cross-User Defacement](https://owasp.org/www-community/attacks/Cross-User_Defacement) (interpreter) - [x] [HTTP Security Response Headers](https://cheatsheetseries.owasp.org/cheatsheets/HTTP_Headers_Cheat_Sheet.html) (разделено между browser, transport, http-request и access-control) - [x] [Cache Poisoning](https://owasp.org/www-community/attacks/Cache_Poisoning) (interpreter) - [x] [IP Spoofing via HTTP Headers](https://owasp.org/www-community/attacks/ip_spoofing_via_http_headers) (http-request) --- ## 16. Кодирование и подмена содержимого - [x] [Unicode Encoding](https://owasp.org/www-community/attacks/Unicode_Encoding) (interpreter) - [x] [Double Encoding](https://owasp.org/www-community/Double_Encoding) (interpreter) - [x] [Content Spoofing](https://owasp.org/www-community/attacks/Content_Spoofing) (browser) --- ## 17. Инъекции в CSV и таблицы - [x] [CSV Injection](https://owasp.org/www-community/attacks/CSV_Injection) (csv) --- ## 18. CORS (Cross-Origin Resource Sharing) - [x] [CORS OriginHeaderScrutiny](https://owasp.org/www-community/attacks/CORS_OriginHeaderScrutiny) (http-request) - [x] [CORS RequestPreflightScrutiny](https://owasp.org/www-community/attacks/CORS_RequestPreflightScrutiny) (http-request) --- ## 19. Отказ в обслуживании - [x] [Regular expression Denial of Service (ReDoS)](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS) (regex) --- ## 20. Безопасность памяти и нативный код - [x] [Buffer Overflow Attack](https://owasp.org/www-community/attacks/Buffer_overflow_attack), [Buffer Overflow via Environment Variables](https://owasp.org/www-community/attacks/Buffer_Overflow_via_Environment_Variables) (c-cpp) - [x] [Format string attack](https://owasp.org/www-community/attacks/Format_string_attack) (c-cpp) --- ## 21. Мобильный код и выполнение недоверенного кода - [x] [Mobile code invoking untrusted mobile code](https://owasp.org/www-community/attacks/Mobile_code_invoking_untrusted_mobile_code) (interpreter) - [x] [Mobile code non-final public field](https://owasp.org/www-community/attacks/Mobile_code_non-final_public_field) (java) - [x] [Mobile code object hijack](https://owasp.org/www-community/attacks/Mobile_code_object_hijack) (java) --- ## 22. Десериализация - [x] [Deserialization](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html) (разделено между python, ruby, php, java и dotnet) --- ## 23. Вредоносное ПО и угрозы на стороне клиента - [x] [Man-in-the-browser attack](https://owasp.org/www-community/attacks/Man-in-the-browser_attack), [Browser Extension Security Vulnerabilities](https://cheatsheetseries.owasp.org/cheatsheets/Browser_Extension_Vulnerabilities_Cheat_Sheet.html) (browser) - [x] [Third Party JavaScript Management](https://cheatsheetseries.owasp.org/cheatsheets/Third_Party_Javascript_Management_Cheat_Sheet.html) (browser) --- ## 24. Логирование, отказ от авторства и обработка ошибок - [x] [Log Injection](https://owasp.org/www-community/attacks/Log_Injection), [Logging](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html), [Application Logging Vocabulary](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Vocabulary_Cheat_Sheet.html) (interpreter) - [x] [Repudiation Attack](https://owasp.org/www-community/attacks/Repudiation_Attack) (interpreter) --- ## 25. Бизнес-логика и злоупотребление функциональностью У бизнес-логики и злоупотребления функциональностью нет единой поверхности в коде, которую защищала бы специализация для отдельной поверхности: защитой служит проектирование под конкретное приложение, то же рассуждение, которым руководит моделирование угроз проекта. Перенесено в раздел "Вне охвата". --- ## 26. Безопасность ИИ, LLM и агентов - [x] [Prompt Injection](https://owasp.org/www-community/attacks/prompt-injection), [LLM Prompt Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html) (llm) - [x] [MCP Tool Poisoning](https://owasp.org/www-community/attacks/MCP_Tool_Poisoning), [MCP (Model Context Protocol) Security](https://cheatsheetseries.owasp.org/cheatsheets/MCP_Security_Cheat_Sheet.html) (llm) - [x] [HITL Dialog Forging (Lies-in-the-Loop)](https://owasp.org/www-community/attacks/lies-in-the-loop) (llm) - [x] [AI Agent Security](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html), [Secure Coding with AI](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Coding_with_AI_Cheat_Sheet.html) (llm) - [x] [Retrieval-Augmented Generation (RAG) Security](https://cheatsheetseries.owasp.org/cheatsheets/RAG_Security_Cheat_Sheet.html) (llm) - [x] [Secure AI/ML Model Ops](https://cheatsheetseries.owasp.org/cheatsheets/Secure_AI_Model_Ops_Cheat_Sheet.html) (llm) - [x] [AML and Sanctions Compliance for AI Agent Payments](https://cheatsheetseries.owasp.org/cheatsheets/AML_Sanctions_AI_Agent_Payments_Cheat_Sheet.html) (llm) --- ## 27. Prototype pollution и межсайтовые утечки - [x] [Prototype Pollution Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Prototype_Pollution_Prevention_Cheat_Sheet.html) (javascript) - [x] [Cross-site leaks (XS-Leaks)](https://cheatsheetseries.owasp.org/cheatsheets/XS_Leaks_Cheat_Sheet.html) (browser) --- ## 28. Фреймворки и языковые платформы - [x] [Django Security](https://cheatsheetseries.owasp.org/cheatsheets/Django_Security_Cheat_Sheet.html), [Django REST Framework](https://cheatsheetseries.owasp.org/cheatsheets/Django_REST_Framework_Cheat_Sheet.html) (python) - [x] [Ruby on Rails](https://cheatsheetseries.owasp.org/cheatsheets/Ruby_on_Rails_Cheat_Sheet.html) (ruby) - [x] [Laravel](https://cheatsheetseries.owasp.org/cheatsheets/Laravel_Cheat_Sheet.html) (php) - [x] [Symfony](https://cheatsheetseries.owasp.org/cheatsheets/Symfony_Cheat_Sheet.html) (php) - [x] [Java Security](https://cheatsheetseries.owasp.org/cheatsheets/Java_Security_Cheat_Sheet.html) (java) - [x] [DotNet Security](https://cheatsheetseries.owasp.org/cheatsheets/DotNet_Security_Cheat_Sheet.html) (dotnet) - [x] [NodeJS Security](https://cheatsheetseries.owasp.org/cheatsheets/Nodejs_Security_Cheat_Sheet.html) (javascript) - [x] [PHP Configuration](https://cheatsheetseries.owasp.org/cheatsheets/PHP_Configuration_Cheat_Sheet.html) (php) --- ## 29. Веб-фронтенд и браузер - [x] [HTML5 Security](https://cheatsheetseries.owasp.org/cheatsheets/HTML5_Security_Cheat_Sheet.html) (browser) - [x] [AJAX Security](https://cheatsheetseries.owasp.org/cheatsheets/AJAX_Security_Cheat_Sheet.html) (browser) - [x] [Securing Cascading Style Sheets](https://cheatsheetseries.owasp.org/cheatsheets/Securing_Cascading_Style_Sheets_Cheat_Sheet.html) (разделено между access-control и browser) --- ## 30. API и сервисы - [x] [GraphQL](https://cheatsheetseries.owasp.org/cheatsheets/GraphQL_Cheat_Sheet.html) (api-endpoint) - [x] [gRPC Security](https://cheatsheetseries.owasp.org/cheatsheets/gRPC_Security_Cheat_Sheet.html) (api-endpoint) - [x] [WebSocket Security](https://cheatsheetseries.owasp.org/cheatsheets/WebSocket_Security_Cheat_Sheet.html) (api-endpoint) --- ## 31. Облако, контейнеры и инфраструктура Конфигурация контейнеров и рабочих нагрузок представляет собой конфигурацию как код, которую разработчик поставляет вместе с приложением (`Dockerfile`, Compose, `securityContext` подов), настоящую поверхность, которую исправляет `harden` и доказывает `verify`, поэтому она входит в охват. Администрирование кластера (RBAC, etcd, API-сервер, admission, сегментация сети) относится к зоне оператора и остается вне охвата. - [x] [Docker Security](https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html), [Node.js Docker](https://cheatsheetseries.owasp.org/cheatsheets/NodeJS_Docker_Cheat_Sheet.html) (container) - [x] [Kubernetes Security](https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html) (container: часть о рабочих нагрузках и подах. Администрирование кластера остается вне охвата) - [x] [Serverless / FaaS Security](https://cheatsheetseries.owasp.org/cheatsheets/Serverless_FaaS_Security_Cheat_Sheet.html) (serverless) --- ## 32. Цепочка поставок и CI/CD - [x] [NPM Security](https://cheatsheetseries.owasp.org/cheatsheets/NPM_Security_Cheat_Sheet.html) (interpreter) - [x] [Dependency Graph & SBOM Best Practices](https://cheatsheetseries.owasp.org/cheatsheets/Dependency_Graph_SBOM_Cheat_Sheet.html), [Vulnerable Dependency Management](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerable_Dependency_Management_Cheat_Sheet.html) (interpreter) --- ## 33. Секреты и конфигурация Управление секретами относится к эксплуатации: хранилища секретов, CI/CD, облачная конфигурация, ротация. Единственный аспект на уровне кода (секрет, жестко заданный в исходном коде) закрывает детерминированное сканирование, а не специализация по рискам. Перенесено в раздел "Вне охвата". --- ## 34. Процессы, проектирование и управление Защита приватности пользователей относится к политике и проектированию (минимизация данных, прозрачность, сроки хранения), а не к поверхности в коде, которую защищает специализация. Перенесено в раздел "Вне охвата". --- ## 35. Платежи и соответствие требованиям - [x] [Secure Integration of Third-Party Payment Gateways](https://cheatsheetseries.owasp.org/cheatsheets/Third_Party_Payment_Gateway_Integration_Cheat_Sheet.html) (payment) --- ## 36. Встраиваемые системы, IoT и специализированные области Безопасность автомобилей и дронов относится к области встраиваемых систем (шина CAN, прошивки OTA, целостность датчиков и радиосвязи, физический доступ), а не к исходному коду веб-приложений и API, который проверяет Lagune. Перенесено в раздел "Вне охвата". --- ## Вне охвата (нет поверхности в коде) Это не территория специализаций, и флажков у них нет: речь об управлении, процессах, эксплуатационном усилении защиты или использовании фреймворков без единой поверхности в коде, которую защищала бы специализация для отдельной поверхности. Их ценность для безопасности реальна, но она заключена в процессах и архитектуре (или, для фреймворка, в собственном навыке этого языка), а не в защите, которую поставляет этот каталог. Они перечислены для справки, а не как задачи. - [Authorization Regression Testing](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Regression_Testing_Cheat_Sheet.html), [Authorization Testing Automation](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Testing_Automation_Cheat_Sheet.html) - [JAAS](https://cheatsheetseries.owasp.org/cheatsheets/JAAS_Cheat_Sheet.html) - [Denial of Service](https://owasp.org/www-community/attacks/Denial_of_Service), [Denial of Service](https://cheatsheetseries.owasp.org/cheatsheets/Denial_of_Service_Cheat_Sheet.html) - [HTTP/2 Reset Attack](https://owasp.org/www-community/attacks/HTTP2_Reset_Attack) - [Traffic flood](https://owasp.org/www-community/attacks/Traffic_flood) - [Web Service Amplification Attack](https://owasp.org/www-community/attacks/web_service_amplificaiton) (усиление через SOAP/WS-Addressing, эксплуатационный вариант DoS без поверхности в коде) - [Cash Overflow](https://owasp.org/www-community/attacks/Cash_Overflow) - [Spyware](https://owasp.org/www-community/attacks/Spyware), [Trojan Horse](https://owasp.org/www-community/attacks/Trojan_Horse) (вредоносное ПО на устройствах конечных пользователей, а не поверхность в коде проверяемого проекта. Аспект доставки через браузер находится в `browser`) - [REST Security](https://cheatsheetseries.owasp.org/cheatsheets/REST_Security_Cheat_Sheet.html), [REST Assessment](https://cheatsheetseries.owasp.org/cheatsheets/REST_Assessment_Cheat_Sheet.html) - [Web Service Security](https://cheatsheetseries.owasp.org/cheatsheets/Web_Service_Security_Cheat_Sheet.html) - [Cloud Architecture Security](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Cloud_Architecture_Cheat_Sheet.html) (проектирование и компромиссы: IAM или подписанные URL, публичные и приватные VPC, границы доверия, разделенная ответственность. В отличие от `container`, здесь нет конкретной конфигурации, которую проверяет специализация) - [Infrastructure as Code Security](https://cheatsheetseries.owasp.org/cheatsheets/Infrastructure_as_Code_Security_Cheat_Sheet.html) (несмотря на название, это процессы SDLC и инструменты для _управления_ IaC: плагины IDE, статический анализ, сканирование образов, CI/CD, подписывание. Он не предлагает перехода от небезопасного шаблона к безопасной форме в файле Terraform или CloudFormation) - [Kubernetes Security](https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html) (_только часть об администрировании кластера_: RBAC, etcd, API-сервер, admission. Часть о рабочих нагрузках и подах входит в охват в рамках `container`) - [Network Segmentation](https://cheatsheetseries.owasp.org/cheatsheets/Network_Segmentation_Cheat_Sheet.html) (сетевая архитектура и политика межсетевого экрана) - [Subdomain Takeover Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Subdomain_Takeover_Prevention_Cheat_Sheet.html) (жизненный цикл DNS и мониторинг, а не код) - [Secrets Management](https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html) (хранилища секретов, CI/CD, ротация. Аспект жестко заданных секретов закрывает детерминированное сканирование, а не специализация по рискам) - [C-Based Toolchain Hardening](https://cheatsheetseries.owasp.org/cheatsheets/C-Based_Toolchain_Hardening_Cheat_Sheet.html) (флаги компилятора, компоновщика и сборки, без точки уязвимости в исходном коде) - [Microservices Security](https://cheatsheetseries.owasp.org/cheatsheets/Microservices_Security_Cheat_Sheet.html), [Microservices based Security Arch Doc](https://cheatsheetseries.owasp.org/cheatsheets/Microservices_based_Security_Arch_Doc_Cheat_Sheet.html) - [Zero Trust Architecture](https://cheatsheetseries.owasp.org/cheatsheets/Zero_Trust_Architecture_Cheat_Sheet.html) - [CI/CD Security](https://cheatsheetseries.owasp.org/cheatsheets/CI_CD_Security_Cheat_Sheet.html), [GitHub Actions Security](https://cheatsheetseries.owasp.org/cheatsheets/GitHub_Actions_Security_Cheat_Sheet.html) - [Software Supply Chain Security](https://cheatsheetseries.owasp.org/cheatsheets/Software_Supply_Chain_Security_Cheat_Sheet.html) - [Error Handling](https://cheatsheetseries.owasp.org/cheatsheets/Error_Handling_Cheat_Sheet.html), [Full Path Disclosure](https://owasp.org/www-community/attacks/Full_Path_Disclosure) (глобальная настройка обработчика ошибок для каждого стека. Эта утечка относится к тому же раскрытию, которым уже управляет обработка ошибок) - [Abuse of Functionality](https://owasp.org/www-community/attacks/Abuse_of_Functionality), [Business Logic Security](https://cheatsheetseries.owasp.org/cheatsheets/Business_Logic_Security_Cheat_Sheet.html), [Abuse Case _(исторический)_](https://cheatsheetseries.owasp.org/cheatsheets/Abuse_Case_Cheat_Sheet.html) (проектирование под конкретное приложение, без единой точки уязвимости в коде) - [User Privacy Protection](https://cheatsheetseries.owasp.org/cheatsheets/User_Privacy_Protection_Cheat_Sheet.html) (минимизация данных, прозрачность, политика хранения) - [Top 10 Automotive Security Vulnerabilities](https://cheatsheetseries.owasp.org/cheatsheets/Automotive_Security_Cheat_Sheet.html), [Drone Security](https://cheatsheetseries.owasp.org/cheatsheets/Drone_Security_Cheat_Sheet.html) (области встраиваемых систем: шина CAN, прошивки OTA, целостность датчиков и радиосвязи, а не исходный код веб-приложений и API) - [Mobile Application Security](https://cheatsheetseries.owasp.org/cheatsheets/Mobile_Application_Security_Cheat_Sheet.html) (усиление защиты платформ Android и iOS: хранилище, биометрия, pinning, персональные данные. У него нет единой поверхности в коде, а аспект загрузки недоверенного кода перешел в `interpreter`) - [Threat Modeling](https://cheatsheetseries.owasp.org/cheatsheets/Threat_Modeling_Cheat_Sheet.html), [Threat Modeling _(страница сообщества)_](https://owasp.org/www-community/Threat_Modeling) - [Attack Surface Analysis](https://cheatsheetseries.owasp.org/cheatsheets/Attack_Surface_Analysis_Cheat_Sheet.html) - [Secure Product Design](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Product_Design_Cheat_Sheet.html) - [Secure Code Review](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Code_Review_Cheat_Sheet.html) - [Virtual Patching](https://cheatsheetseries.owasp.org/cheatsheets/Virtual_Patching_Cheat_Sheet.html) - [Vulnerability Disclosure](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerability_Disclosure_Cheat_Sheet.html) - [Legacy Application Management](https://cheatsheetseries.owasp.org/cheatsheets/Legacy_Application_Management_Cheat_Sheet.html) - [Security Terminology](https://cheatsheetseries.owasp.org/cheatsheets/Security_Terminology_Cheat_Sheet.html) --- # /lagune-repair: исправьте сломанное отслеживание находок > Восстановите цепочку, когда переименование или перемещение файла сбивает отслеживание Lagune. Канонический URL: https://lagune.ai/ru-RU/docs/commands/repair Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/repair Последнее обновление: 2026-11-03 🧰 Восстановите цепочку, когда ее сбивает переименование или перемещение файла. **Внутреннее обслуживание, а не фаза безопасности** Repair не является шестой фазой линейного процесса. Ее задача: поддерживать согласованность отслеживания. ```prompt # Входных данных не нужно: команда всегда восстанавливает всю цепочку /lagune-repair ``` ## Как это работает Каждая находка detect представляет собой один отслеживаемый элемент, который переносят дальше plan, harden и verify: каждая фаза работает с ним и снова сообщает о нем по имени. Это имя, записанное одинаково как заголовок раздела в каждом артефакте, служит его идентификатором на всем пути. Единственное изменчивое, что хранит отслеживание, это пути к файлам, на которые указывает элемент. Эти пути больше нигде не хранятся, поэтому переименование или перемещение файла может сломать связь только там, а не в двух расходящихся копиях. Когда это случается, repair исправляет карту (`.lagune/tracking.json`), чтобы идентификатор пережил переименование. Команда читает артефакты и карту отслеживания, читает ваш исходный код только для того, чтобы узнать новый путь переименованного файла, и никогда не пишет содержимое о безопасности. За тот же проход она сверяет каждый артефакт памяти с его шаблоном и сообщает, что отклонилось, указывая для каждого расхождения фазу, которая его исправляет. **Совет** - Она не трогает ни ваш код, ни текстовые артефакты, только отслеживание. - Запускать ее вручную приходится редко. Когда фаза замечает, что цепочка несогласованна, она сама запускает repair и продолжает работу. - Отслеживание, которое она поддерживает, хранится в `.lagune/tracking.json`, во внутреннем состоянии, которое вы никогда не правите вручную. --- # Migrate: перенесите проект Lagune на основе манифеста на навыки и плагины > Перенесите проект Lagune на основе манифеста на Lagune на основе навыков, сохранив принципы безопасности, артефакты, отслеживание и собственные специализации. Канонический URL: https://lagune.ai/ru-RU/docs/commands/migrate Язык: ru-RU Оригинал: https://lagune.ai/docs/commands/migrate Последнее обновление: 2026-11-03 🔀 Перенесите проект **Lagune** на основе манифеста на **Lagune** на основе навыков, сохранив все, что вы написали. **Уведомление об устаревании** Проект с манифестом продолжает работать как есть до `v1.x`: `npx lagune` передает `init`, `pull`, `update`, `add`, `remove`, `list` и дашборд в `lagune@0.15.0`, последнюю версию на основе манифеста. ## Перенос 1. Убедитесь, что текущая работа закоммичена, затем запустите migrate из корня проекта: ```bash npx lagune migrate ``` 2. Закоммитьте то, что команда изменила, отдельным коммитом, чтобы перенос остался одним изменением, которое легко проверить. 3. Установите команды для своего агента, как показано на [странице установки](https://lagune.ai/ru-RU/docs). 4. Если в проекте уже есть артефакт detect, plan или harden, попросите [`/lagune-repair`](https://lagune.ai/ru-RU/docs/commands/repair) сверить старые ссылки в них и в ваших собственных специализациях: ```prompt /lagune-repair Сверь примененные специализации (ранее sub-skills) в артефактах в `.lagune/memory/` (`detect.md`, `plan.md` и `harden.md`) с именами, которые перечисляет новый каталог, и перепиши каждый вызов старых хуков из `.lagune/hooks/` в моих собственных специализациях в `.lagune/catalog/` как вызов инструмента `lagune_read` или `lagune_write`. ``` ## Что меняется | До | После | | --------------------------------------------------------------------- | --------------------------------------------------------------------------------- | | `.lagune/templates/`, `.lagune/hooks/` и `.lagune/specializations.md` | Удалены: каждый навык несет свой шаблон, а хуки запускает движок | | Копии встроенных специализаций в `.lagune/skills/` | Удалены: встроенные специализации отдает движок | | Ваши собственные специализации в `.lagune/skills/` | Перемещены в `.lagune/catalog/` | | `.lagune/skills.json`, индекс ваших собственных специализаций | Объединен с `.lagune/configs.json` | | Категории из манифеста | Зафиксированы в `.lagune/configs.json` | | Старые команды агента, такие как `/lagune.detect` | Удалены: [установка **Lagune**](https://lagune.ai/ru-RU/docs) приносит новые, такие как `/lagune-detect` | | Блок **Lagune** в `.gitignore` | Удален, вместе с файлом, если в нем больше ничего не было | | `.lagune/proofs/`, игнорируемая этим блоком | Не попадает в коммиты благодаря собственному `.gitignore` | | `.lagune/manifest.json` | Удален, последним | Ваша работа по безопасности остается как есть: принципы безопасности, артефакт, созданный каждой фазой, и карта отслеживания с путями, на которые указывает каждая находка. ## Частые вопросы ### Обязательно ли выполнять миграцию? Да. Проекты на основе манифеста устарели и продолжают работать только до v1.x, поэтому выполните npx lagune migrate, чтобы перенести свой. ### Что сохраняет migrate? Ваши принципы безопасности, каждый артефакт фаз, карту отслеживания, ваши категории и собственные специализации. Специализации переезжают в .lagune/catalog/, а их индекс присоединяется к вашим категориям в .lagune/configs.json. ### Когда устанавливать новые команды? После migrate, как показано на странице установки для вашего агента. Можно установить и сначала, поскольку migrate сохраняет новую /lagune. ### Коллега уже выполнил миграцию. Что запускать мне? Получите изменения с переносом, затем один раз выполните npx lagune migrate. Команда удалит то, что Lagune на основе манифеста оставил в вашем клоне и что никогда не попадало в систему контроля версий, и не пустит ваши доказательства в коммиты.