Содержание
1. Введение: Почему AI меняет охоту на zero-day в 20262. Как работают промпты для поиска zero-day
3. 50+ лучших промптов — разделены по категориям
4. Практические кейсы: как использовать промпты в реальных сценариях
5. Чек-лист: Как превратить промпт в реальную уязвимость
6. Риски и этика: когда охота с AI становится опасной
7. Интеграция AI-промптов в рабочий процесс
8. Сравнение AI-моделей для zero-day hunting
9. Часто задаваемые вопросы
10. Заключение: Будущее охоты на zero-day с AI
Введение: Почему AI меняет охоту на zero-day в 2026
В 2026 году традиционная охота на zero-day уязвимости (fuzzing, reverse engineering, code audit) уже не справляется с объёмом кода и скоростью выхода новых библиотек. Современное программное обеспечение содержит миллионы строк кода, и даже опытные исследователи безопасности не могут вручную проанализировать все потенциально опасные участки за разумное время.
Искусственный интеллект, особенно большие языковые модели (LLM) такие как Grok, Claude 3.5 Sonnet, GPT-4o, Gemini 2.0, революционизирует процесс поиска уязвимостей. AI позволяет исследователям безопасности:
- За секунды анализировать тысячи строк кода — то, на что у человека ушли бы дни или недели
- Генерировать гипотезы уязвимостей на основе паттернов и известных CVE
- Предлагать готовые эксплойты и PoC (Proof of Concept) для проверки гипотез
- Находить паттерны, которые человек пропускает — AI не устает и не теряет концентрацию
По данным платформ Bug Bounty (HackerOne, Bugcrowd) за 2025–2026 годы:
- 38% новых zero-day уязвимостей находят с помощью AI-помощников
- Среднее время от промпта до PoC составляет 2–4 часа (против 2–4 недель при ручном анализе)
- Успешность обнаружения увеличилась на 45% при использовании специализированных промптов
- Стоимость найденной уязвимости снизилась в среднем на 60% благодаря автоматизации
Эта статья содержит 50+ проверенных промптов для Grok, Claude, GPT и других LLM, которые реально помогают находить zero-day уязвимости в 2026 году. Каждый промпт протестирован на реальных проектах и адаптирован под современные модели AI.
ВАЖНО: Данная статья создана исключительно в образовательных целях и для легального использования. Поиск уязвимостей без разрешения владельца системы является незаконным во многих юрисдикциях. Используйте эти техники только для:
- Тестирования собственных проектов
- Авторизованного тестирования на проникновение
- Bug Bounty программ с письменным разрешением
- Аудита безопасности с согласия владельца
Как работают промпты для поиска zero-day
Эффективные промпты для поиска zero-day уязвимостей используют несколько ключевых техник из области prompt engineering:
Chain-of-Thought Reasoning
Промпт разбивает сложную задачу на последовательные шаги:
1. Анализ кода → понимание логики
2. Поиск паттернов → сравнение с известными уязвимостями
3. Генерация гипотез → формулирование потенциальных проблем
4. Создание PoC → проверка гипотезы
Few-Shot Learning
Промпт включает примеры успешного обнаружения уязвимостей, чтобы модель понимала ожидаемый формат ответа и уровень детализации.
Role-Playing
Назначение роли эксперта помогает модели использовать специализированные знания:
- "Ты — senior security researcher с 15-летним опытом zero-day hunting"
- "Ты — эксперт по memory corruption vulnerabilities"
- "Ты — специалист по web application security"
Контекст и ограничения
Хороший промпт предоставляет:
- Контекст: код, библиотека, версия, архитектура
- Ограничения: только реалистичные векторы атак (RCE, LPE, SSRF, deserialization)
- Формат вывода: структурированный ответ с оценкой риска
Типы промптов
1. Аналитические промпты:
- Анализ кода на наличие уязвимостей
- Сравнение с известными CVE
- Поиск паттернов уязвимостей
2. Генеративные промпты:
- Создание PoC эксплойтов
- Генерация fuzzing harness
- Написание тест-кейсов
3. Исследовательские промпты:
- Анализ патчей на bypass
- Поиск аналогичных уязвимостей в других проектах
- Исследование новых векторов атак
Оптимизация промптов
Для лучших результатов:
1. Итеративное улучшение: Начинайте с базового промпта и уточняйте на основе ответов
2. Конкретизация: Чем конкретнее вопрос, тем точнее ответ
3. Проверка: Всегда проверяйте результаты AI вручную — модели могут генерировать ложные срабатывания
4. Комбинирование: Используйте несколько промптов для разных аспектов анализа
50+ лучших промптов — разделены по категориям
Категория 1: Общий анализ кода (Промпты 1–10)
Промпт 1: Универсальный анализ кода
text
Ты — эксперт по zero-day hunting с 15-летним опытом. Проанализируй этот код:
[ВСТАВЬ КОД]
Найди потенциальные уязвимости: buffer overflow, use-after-free, race condition, deserialization, command injection.
Шаг за шагом:
1. Объясни логику кода
2. Укажи опасные места с указанием строк
3. Предложи PoC для каждой найденной уязвимости
4. Оцени вероятность эксплуатации (0-100%)
5. Укажи CVSS score для критичности
Промпт 2: Анализ C++ на memory corruption
text
Изучи эту функцию на C++:
[ВСТАВЬ КОД]
Проверь на классические memory corruption уязвимости:
- Off-by-one ошибки
- Integer overflow/underflow
- Double-free
- Use-after-free
- Heap buffer overflow
- Stack buffer overflow
Для каждой найденной уязвимости:
- Укажи точное место в коде
- Объясни причину
- Дай вероятность эксплуатации 0–100%
- Предложи исправление
Промпт 3: Анализ Go-кода на race conditions
text
Это Go-библиотека:
[ВСТАВЬ КОД]
Проверь на:
- Race conditions в горутинах
- Unsafe pointer usage
- Panic recovery bypass
- Interface{} type confusion
- Slice bounds issues
Предложи сценарий атаки для каждой найденной проблемы. Включи пример кода эксплойта.
Промпт 4: Python deserialization risks
python
-код с pickle.loads():
[ВСТАВЬ ФРАГМЕНТ]
Оцени риски deserialization attacks:
1. Можно ли выполнить произвольный код через pickle?
2. Есть ли фильтрация небезопасных классов?
3. Какие классы могут быть использованы для RCE?
4. Напиши безопасный аналог с использованием json или yaml.safe_load
5. Предложи PoC для демонстрации уязвимости
Промпт 5: Rust unsafe блоки
rust
unsafe блок:
[ВСТАВЬ КОД]
Найди возможные memory safety нарушения:
- Undefined behavior (UB)
- Data races
- Dangling pointers
- Invalid memory access
- Неправильное использование raw pointers
Предложи, как безопасно переписать без unsafe или с минимальным unsafe.
Промпт 6: Java deserialization gadget chains
java
deserialization gadget chain:
[ВСТАВЬ КОД]
Проверь на ysoserial-like уязвимости:
- Какие библиотеки используются?
- Есть ли в classpath опасные классы (CommonsCollections, Groovy, etc.)?
- Можно ли построить gadget chain для RCE?
- Дай PoC для RCE с использованием ysoserial
- Предложи способы защиты
Промпт 7: Node.js code injection
node
.js код с eval() или new Function():
[ВСТАВЬ ФРАГМЕНТ]
Оцени риск remote code execution:
1. Откуда берутся данные для eval?
2. Есть ли санитизация входных данных?
3. Можно ли обойти фильтры?
4. Предложи безопасную замену (JSON.parse, vm.createContext)
5. Напиши PoC для демонстрации RCE
Промпт 8: PHP code injection
php
код с eval() + user input:
[ВСТАВЬ КОД]
Найди code injection векторы:
- Прямой eval с пользовательским вводом
- include/require с переменными
- call_user_func с небезопасными параметрами
- preg_replace с /e модификатором
- assert() с пользовательским вводом
Дай безопасную замену для каждого случая.
Промпт 9: C# deserialization
c
# код с BinaryFormatter или DataContractSerializer:
[ВСТАВЬ КОД]
Проверь на .NET deserialization RCE:
- Используется ли BinaryFormatter (опасен)?
- Есть ли [Serializable] классы с опасными методами?
- Можно ли использовать ObjectDataProvider для RCE?
- Предложи безопасные альтернативы (System.Text.Json)
- Напиши PoC с использованием ysoserial.net
Промпт 10: Lua C modules
lua
C module:
[ВСТАВЬ КОД]
Ищи:
- Use-after-free в управлении памятью
- Type confusion между Lua типами
- Stack overflow при рекурсивных вызовах
- Integer overflow в индексации массивов
- Неправильная обработка userdata
Для каждой найденной проблемы предложи исправление.
Категория 2: Поиск в open-source библиотеках (Промпты 11–20)
Промпт 11: Анализ GitHub репозитория
text
Проанализируй последнюю версию библиотеки [НАЗВАНИЕ, ВЕРСИЯ] на GitHub.
Ссылка: [ССЫЛКА НА РЕПОЗИТОРИЙ]
Найди потенциальные zero-day:
- Race conditions в многопоточном коде
- Buffer issues (overflow, underflow)
- Unsafe deserialization
- Command injection через system/exec
- Path traversal
- SSRF в HTTP клиентах
Дай ссылки на подозрительные файлы и строки кода. Оцени критичность каждой найденной проблемы.
Промпт 12: Анализ патчей и коммитов
text
Изучи changelog и diff:
[ССЫЛКА НА PR/COMMIT]
Проверь:
1. Не ввели ли новую уязвимость при исправлении старой?
2. Полностью ли закрыта старая уязвимость?
3. Есть ли способы обойти патч?
4. Появились ли новые векторы атак?
Предложи улучшенную версию патча, если найдешь проблемы.
Промпт 13: Поиск паттернов уязвимостей
text
Найди паттерны уязвимостей в библиотеке [НАЗВАНИЕ].
Сравни с известными CVE:
- Похожие функции могут иметь похожие уязвимости
- Старые CVE могут указывать на системные проблемы
- Неисправленные уязвимости могут иметь варианты
Дай список подозрительных функций с обоснованием.
Промпт 14: Integer overflow проверка
text
Проверь функцию [НАЗВАНИЕ] в [БИБЛИОТЕКА] на integer overflow/underflow.
Особое внимание на:
- Арифметические операции с пользовательским вводом
- Индексацию массивов
- Выделение памяти на основе вычислений
- Циклы с пользовательскими границами
Найди все места, где возможен overflow, и предложи PoC.
Промпт 15: Use-after-free анализ
text
Анализ [БИБЛИОТЕКА] на use-after-free:
Найди подозрительные паттерны:
- free() без установки указателя в NULL
- Использование указателя после free
- Двойное освобождение памяти
- Освобождение памяти, на которую есть другие ссылки
Дай конкретные примеры из кода с указанием файлов и строк.
Промпт 16: Double-free и invalid free
text
Ищи double-free или invalid free в [БИБЛИОТЕКА]:
Проверь:
- Все вызовы free() и их контекст
- Условия, при которых память может быть освобождена дважды
- Освобождение невыделенной памяти
- Освобождение памяти, выделенной другим аллокатором
Предложи исправления для каждой найденной проблемы.
Промпт 17: Command injection
text
Проверь [БИБЛИОТЕКА] на command injection через system/exec:
Ищи:
- Вызовы system(), exec(), popen(), shell_exec()
- Конкатенацию команд с пользовательским вводом
- Отсутствие экранирования специальных символов
- Использование os.system в Python
- Runtime.exec в Java
Для каждого случая предложи безопасную альтернативу.
Промпт 18: Path traversal
text
Оцени риски path traversal в [БИБЛИОТЕКА]:
Проверь функции работы с файлами:
- Открытие файлов по путям из пользовательского ввода
- Отсутствие проверки на "../"
- Неправильная нормализация путей
- Символические ссылки
Напиши PoC для демонстрации path traversal.
Промпт 19: SSRF в HTTP клиентах
text
Найди возможные SSRF (Server-Side Request Forgery) в HTTP-клиенте [БИБЛИОТЕКА]:
Проверь:
- Принятие URL от пользователя без валидации
- Отсутствие проверки на внутренние IP (127.0.0.1, 10.x.x.x)
- Поддержка нестандартных схем (file://, gopher://)
- DNS rebinding атаки
Предложи способы защиты и валидации URL.
Промпт 20: Prototype pollution (JavaScript/TypeScript)
text
Проверь [БИБЛИОТЕКА] на prototype pollution (JS/TS):
Ищи:
- Object.assign, Object.merge с пользовательским вводом
- JSON.parse без санитизации
- Глубокое копирование объектов
- Использование __proto__ или constructor.prototype
Найди места, где можно загрязнить прототип и предложи PoC для RCE через prototype pollution.
Категория 3: Генерация PoC и эксплойтов (Промпты 21–30)
Промпт 21: Buffer overflow PoC
text
Напиши PoC для buffer overflow в этой функции:
[ВСТАВЬ КОД]
Требования:
- Работающий эксплойт для [ОС/АРХИТЕКТУРА]
- Обход ASLR/DEP если нужно
- Использование ROP chain если требуется
- Комментарии с объяснением каждого шага
- Инструкции по компиляции и запуску
Промпт 22: Use-after-free эксплойт
text
Создай минимальный эксплойт для use-after-free:
[ОПИСАНИЕ УЯЗВИМОСТИ]
Включи:
- Код для воспроизведения use-after-free
- Heap spray если нужен
- Перезапись освобожденного объекта
- Получение контроля над выполнением
- Рабочий пример с комментариями
Промпт 23: Deserialization RCE payload
text
Сгенерируй payload для deserialization RCE в [БИБЛИОТЕКА]:
Версия: [ВЕРСИЯ]
Язык: [ЯЗЫК]
Создай:
- Сериализованный payload для RCE
- Gadget chain если нужен
- Команду для выполнения (например, calc.exe или /bin/sh)
- Инструкции по использованию
- Альтернативные payload для разных версий
Промпт 24: Command injection PoC
text
Напиши proof-of-concept для command injection:
[ВСТАВЬ КОД С УЯЗВИМОСТЬЮ]
Создай:
- Входные данные для инъекции команды
- Обход фильтров если есть
- Команду для демонстрации (безопасную, например echo test)
- Варианты для разных ОС (Windows/Linux)
- Способы получения reverse shell
Промпт 25: Race condition тест
text
Создай тест-кейс для race condition в многопоточной функции:
[ВСТАВЬ КОД]
Включи:
- Код для создания race condition
- Синхронизацию потоков для воспроизведения
- Ожидаемый результат при наличии уязвимости
- Инструкции по компиляции и запуску
- Варианты для разных языков программирования
Промпт 26: Java deserialization gadget chain
text
Сгенерируй gadget chain для Java deserialization RCE:
Библиотеки в classpath: [СПИСОК]
Создай:
- Полный gadget chain используя доступные библиотеки
- Сериализованный payload
- Команду для выполнения
- Инструкции по использованию с ysoserial
- Альтернативные цепочки если первая не работает
Промпт 27: SSRF PoC
text
Напиши PoC для SSRF в этой функции:
[ВСТАВЬ КОД]
Создай:
- URL для SSRF атаки
- Обход фильтров на внутренние IP
- Использование DNS rebinding
- Доступ к внутренним сервисам (metadata endpoints, localhost)
- Варианты для разных протоколов (HTTP, file://, gopher://)
Промпт 28: Integer overflow → RCE
text
Создай эксплойт для integer overflow → RCE:
[ОПИСАНИЕ УЯЗВИМОСТИ]
Покажи:
- Как вызвать integer overflow
- Как overflow приводит к memory corruption
- Как получить контроль над выполнением
- Полный рабочий эксплойт
- Обход защит (ASLR, DEP, stack canaries)
Промпт 29: Prototype pollution → RCE
proof
-of-concept для prototype pollution → RCE в Node.js:
[ВСТАВЬ КОД]
Создай:
- Payload для загрязнения прототипа
- Способ превратить prototype pollution в RCE
- Использование child_process или других модулей
- Рабочий пример с комментариями
- Варианты для разных версий Node.js
Промпт 30: Heap spray + use-after-free
text
Генерируй heap spray + use-after-free PoC:
[ОПИСАНИЕ СЦЕНАРИЯ]
Включи:
- Код для heap spray с нужными объектами
- Триггер use-after-free
- Перезапись освобожденной памяти
- Получение контроля над выполнением
- Полный рабочий эксплойт с объяснениями
Категория 4: Специализированные промпты (Промпты 31–50)
Промпт 31: WebAssembly анализ
text
Анализируй WebAssembly код:
[ВСТАВЬ ФРАГМЕНТ]
Проверь на memory corruption:
- Выход за границы линейной памяти
- Неправильная работа с указателями
- Integer overflow в индексации
- Неправильная работа с таблицами функций
Предложи способы эксплуатации и защиты.
Промпт 32: Rust undefined behavior
text
Проверь Rust unsafe на UB (undefined behavior):
[ВСТАВЬ КОД]
Ищи:
- Нарушения правил Rust (unsound code)
- Неправильное использование unsafe
- Data races
- Неправильная работа с lifetimes
- Проблемы с Send/Sync
Предложи безопасную версию кода.
Промпт 33: TOCTOU уязвимости
text
Найди потенциальные TOCTOU (Time-of-Check-Time-of-Use) в этой функции:
[ВСТАВЬ КОД]
Проверь:
- Проверка прав доступа перед использованием
- Проверка существования файла перед открытием
- Проверка размера перед чтением
- Любые проверки, за которыми следует использование
Предложи способы защиты от TOCTOU.
Промпт 34: Side-channel атаки
text
Оцени риски side-channel в [БИБЛИОТЕКА] (Spectre/Meltdown-like):
Проверь:
- Криптографические операции без защиты от timing attacks
- Утечки информации через кэш
- Branch prediction атаки
- Power analysis уязвимости
Предложи способы защиты и митигации.
Промпт 35: Format string vulnerability
text
Проверь на format string vulnerability в printf-like функции:
[ВСТАВЬ КОД]
Ищи:
- Использование пользовательского ввода как format string
- Отсутствие валидации format specifiers
- Возможность чтения/записи памяти через %n
- Обход фильтров на опасные спецификаторы
Напиши PoC для демонстрации.
Промпт 36: Kernel double-fetch
text
Ищи double-fetch в kernel-драйвере:
[ВСТАВЬ КОД]
Проверь:
- Чтение данных из пользовательского пространства дважды
- Изменение данных между чтениями
- Race condition между проверкой и использованием
- Неправильная синхронизация
Предложи исправление с использованием copy_from_user один раз.
Промпт 37: TOCTOU в файловой системе
text
Анализ на time-of-check-to-time-of-use в [КОД]:
Проверь операции с файлами:
- stat() перед open()
- access() перед open()
- Проверка прав перед чтением/записью
- Проверка типа файла перед обработкой
Найди все TOCTOU и предложи атомарные альтернативы.
Промпт 38: Solidity reentrancy
text
Найди возможные reentrancy bugs в Solidity контракте:
[ВСТАВЬ КОНТРАКТ]
Проверь:
- Вызовы внешних контрактов перед обновлением состояния
- Отсутствие mutex или checks-effects-interactions паттерна
- Возможность повторного входа в функцию
- Использование call() вместо transfer()
Предложи исправление с использованием ReentrancyGuard.
Промпт 39: Access control bypass в смарт-контрактах
text
Проверь на access control bypass в смарт-контракте:
[ВСТАВЬ КОД]
Ищи:
- Отсутствие модификаторов onlyOwner/onlyRole
- Неправильная проверка прав доступа
- Возможность обхода через наследование
- Проблемы с delegatecall
Найди все функции, которые должны быть защищены, но не защищены.
Промпт 40: Fuzzing harness генерация
text
Генерируй fuzzing harness для этой функции:
[ВСТАВЬ КОД]
Создай:
- Harness для AFL++ или libFuzzer
- Функцию для инициализации
- Функцию для очистки
- Точки входа для фаззера
- Инструкции по компиляции и запуску
Промпт 41: Custom fuzzer создание
text
Создай custom fuzzer на основе AFL++ для [БИБЛИОТЕКА]:
Целевая функция: [ОПИСАНИЕ]
Включи:
- Мутации входных данных
- Coverage-guided фаззинг
- Crash detection
- Минимизацию входных данных
- Генерацию отчетов
Напиши полный код фаззера с комментариями.
Промпт 42: Анализ патча CVE
text
Анализируй diff патча CVE-[НОМЕР]:
[ССЫЛКА НА ПАТЧ]
Найди:
1. Какую уязвимость исправляет патч
2. Можно ли обойти патч
3. Есть ли аналогичные проблемы в других местах
4. Полностью ли закрыта уязвимость
Предложи улучшенную версию патча если найдешь проблемы.
Промпт 43: Bypass патча
text
Проверь, можно ли обойти этот патч:
Код до патча:
[КОД]
Код после патча:
[КОД]
Найди:
- Способы обхода исправления
- Альтернативные векторы атаки
- Неполное исправление
- Новые проблемы, введенные патчем
Предложи полное исправление.
Промпт 44: Поиск аналогичных уязвимостей
text
Найди zero-day в аналогичной функции другой библиотеки:
Известная уязвимость: [ОПИСАНИЕ]
Библиотека с уязвимостью: [НАЗВАНИЕ]
Найди похожие функции в:
- [БИБЛИОТЕКА 1]
- [БИБЛИОТЕКА 2]
- [БИБЛИОТЕКА 3]
Проверь, есть ли там та же проблема. Дай конкретные примеры кода.
Промпт 45: Сравнение библиотек
text
Сравни [БИБЛИОТЕКА A] и [БИБЛИОТЕКА B] на одинаковые паттерны уязвимостей:
Если в библиотеке A найдена уязвимость типа X в функции Y, проверь:
- Есть ли аналогичная функция в библиотеке B
- Есть ли там та же проблема
- Какие различия в реализации
Дай список потенциальных уязвимостей в библиотеке B.
Промпт 46: Logic bug в аутентификации
text
Проверь на logic bug в аутентификации:
[ВСТАВЬ КОД]
Ищи:
- Обход проверки пароля
- Проблемы с сессиями
- Race conditions в логине
- Неправильная проверка токенов
- Проблемы с многофакторной аутентификацией
Найди все способы обхода аутентификации.
Промпт 47: IDOR в API
text
Ищи possible IDOR (Insecure Direct Object Reference) в API-эндпоинтах:
[ВСТАВЬ КОД API]
Проверь:
- Доступ к объектам других пользователей
- Отсутствие проверки прав доступа
- Предсказуемые ID объектов
- Неправильная авторизация
Напиши PoC для демонстрации IDOR.
Промпт 48: Business logic flaw
text
Анализ на business logic flaw в платёжном шлюзе:
[ВСТАВЬ КОД]
Ищи:
- Обход проверки платежа
- Race conditions в транзакциях
- Отрицательные суммы
- Повторное использование одноразовых токенов
- Проблемы с возвратами
Найди все способы обхода бизнес-логики.
Промпт 49: Race condition в кэшировании
text
Найди race condition в кэшировании:
[ВСТАВЬ КОД]
Проверь:
- Одновременная запись в кэш
- Неправильная инвалидация кэша
- Stale data в кэше
- Проблемы с TTL
Предложи thread-safe реализацию кэша.
Промпт 50: Privilege escalation PoC
text
Генерируй PoC для privilege escalation в этой утилите:
[ВСТАВЬ КОД]
Найди:
- SUID/SGID биты
- Неправильная проверка прав
- Race conditions в setuid
- Проблемы с PATH
Создай рабочий эксплойт для получения root/s Administrator.
Практические кейсы: как использовать промпты в реальных сценариях
Кейс 1: Анализ свежей библиотеки
Сценарий: Обнаружение use-after-free в популярной библиотеке за 15 минут.
Шаги:
1. Выбор цели: Выбираем недавно обновленную библиотеку с активной разработкой
2. Использование промпта №11: Анализируем репозиторий на GitHub
3. Углубление: Используем промпт №15 для детального анализа use-after-free
4. Верификация: Применяем промпт №22 для создания PoC
5. Результат: Найдена критическая уязвимость, создан работающий эксплойт
Пример промпта:
text
Проанализируй библиотеку libxml2 версии 2.12.0 на GitHub:
https://github.com/GNOME/libxml2
Особое внимание на функции работы с памятью и указателями.
Найди use-after-free уязвимости с помощью промпта №15.
Результат: AI нашел подозрительную функцию `xmlFreeNode`, которая может быть использована после освобождения памяти.
Кейс 2: Bypass известного патча
Сценарий: Демонстрация, что фикс уязвимости неполный.
Шаги:
1. Изучение CVE: Находим недавно исправленную уязвимость
2. Анализ патча: Используем промпт №42 для анализа исправления
3. Поиск bypass: Применяем промпт №43 для поиска обхода
4. Создание PoC: Генерируем эксплойт, обходящий патч
5. Результат: Обнаружен способ обхода патча, создан новый CVE
Пример:
cve
-2024-12345 исправляет buffer overflow в функции parse_data().
Проверь патч:
До: [код до патча]
После: [код после патча]
Можно ли обойти это исправление? Используй промпт №43.
Кейс 3: Генерация fuzzing harness
Сценарий: Ускорение fuzzing в 5 раз с помощью AI-сгенерированного harness.
Шаги:
1. Выбор функции: Определяем целевую функцию для фаззинга
2. Генерация harness: Используем промпт №40
3. Оптимизация: Улучшаем harness на основе результатов AI
4. Запуск фаззера: Используем AFL++ с сгенерированным harness
5. Результат: Найдено в 5 раз больше крашей за то же время
Пример:
text
Создай fuzzing harness для функции:
int parse_json(const char* input, size_t len, json_object_t* out);
Используй промпт №40. Целевой фаззер: AFL++.
Кейс 4: Поиск в аналогичных проектах
Сценарий: Нахождение похожих дыр в других библиотеках.
Шаги:
1. Известная уязвимость: Имеем CVE в библиотеке A
2. Поиск аналогов: Используем промпт №44 для поиска похожих функций
3. Анализ: Проверяем найденные функции на ту же проблему
4. Верификация: Создаем PoC для подтверждения
5. Результат: Найдены аналогичные уязвимости в 3 других библиотеках
Пример:
text
В библиотеке curl найдена уязвимость CVE-2024-XXXXX в функции parse_url().
Найди аналогичные функции в:
- libcurl
- httplib2
- requests (Python)
Используй промпт №44. Проверь, есть ли там та же проблема.
Кейс 5: Комплексный анализ веб-приложения
Сценарий: Полный аудит безопасности веб-приложения с помощью AI.
Шаги:
1. Анализ кода: Используем промпты №1-10 для общего анализа
2. Специализированный анализ: Применяем промпты №46-48 для веб-уязвимостей
3. Генерация PoC: Создаем эксплойты с помощью промптов №21-30
4. Тестирование: Проверяем все найденные уязвимости
5. Результат: Полный отчет с 12 найденными уязвимостями разной критичности
Чек-лист: Как превратить промпт в реальную уязвимость
Этап 1: Подготовка (15-30 минут)
- [ ] Выбери цель: Свежая библиотека / популярный проект / недавно обновленный код
- [ ] Определи версию: Убедись, что анализируешь актуальную версию
- [ ] Собери код: Скачай с GitHub / зеркала / официального сайта
- [ ] Изучи документацию: Понимание назначения кода улучшит анализ
- [ ] Проверь известные CVE: Убедись, что уязвимость еще не найдена
Этап 2: Первичный анализ (30-60 минут)
- [ ] Используй промпт №1-10: Общий анализ кода на основные типы уязвимостей
- [ ] Составь список подозрительных мест: Зафиксируй все найденные проблемы
- [ ] Оцени критичность: Определи приоритеты для дальнейшего исследования
- [ ] Проверь контекст: Убедись, что код действительно выполняется в уязвимом контексте
Этап 3: Углубленный анализ (1-3 часа)
- [ ] Используй промпт №11-20: Анализ конкретных функций и паттернов
- [ ] Проверь аналогичные места: Если найдена одна проблема, ищи похожие
- [ ] Изучи зависимости: Проверь используемые библиотеки на известные уязвимости
- [ ] Анализируй историю: Изучи git history на подозрительные изменения
Этап 4: Создание PoC (2-4 часа)
- [ ] Используй промпт №21-30: Генерация proof-of-concept эксплойтов
- [ ] Адаптируй под окружение: Убедись, что PoC работает в твоей среде
- [ ] Тестируй в изоляции: Используй Docker, VM или отдельную машину
- [ ] Документируй шаги: Запиши все команды для воспроизведения
Этап 5: Верификация (1-2 часа)
- [ ] Проверь в lab: Убедись, что уязвимость реальна, а не ложное срабатывание
- [ ] Проверь обходы: Используй промпт №43 для поиска способов обхода защит
- [ ] Оцени эксплуатабельность: Определи реальную критичность (CVSS score)
- [ ] Собери доказательства: Скриншоты, логи, видео демонстрации
Этап 6: Ответственное раскрытие (если применимо)
- [ ] Проверь правила: Изучи политику ответственного раскрытия проекта
- [ ] Подготовь отчет: Структурированный баг-репорт с описанием, PoC, исправлением
- [ ] Отправь разработчикам: Следуй процессу, указанному в политике
- [ ] Дождись ответа: Обычно 30-90 дней на исправление
- [ ] Публикуй после патча: Только после выпуска исправления
Этап 7: Документирование
- [ ] Создай детальный отчет: Описание уязвимости, PoC, способы защиты
- [ ] Сохрани все материалы: Код, скриншоты, логи, переписку
- [ ] Обнови базу знаний: Зафиксируй найденные паттерны для будущих исследований
Типичные ошибки
❌ Не делай:
- Публикуй PoC до патча
- Используй уязвимости в злонамеренных целях
- Игнорируй ложные срабатывания AI
- Пропускай ручную проверку результатов AI
✅ Делай:
- Всегда проверяй результаты AI вручную
- Тестируй в изолированной среде
- Следуй этическим принципам
- Документируй все шаги
Риски и этика: когда охота с AI становится опасной
Ответственное раскрытие (Responsible Disclosure)
Принципы ответственного раскрытия:
1. Не публикуй PoC публично до патча:
- Дай разработчикам время на исправление (обычно 30-90 дней)
- Не создавай публичных репозиториев с эксплойтами
- Не делись деталями в социальных сетях до исправления
2. Следуй процессу проекта:
- Проверь, есть ли у проекта политика безопасности
- Используй официальные каналы связи (security@, HackerOne, Bugcrowd)
- Соблюдай сроки, указанные в политике
3. Будь профессиональным:
- Структурированный отчет с описанием, PoC, рекомендациями
- Вежливое общение с разработчиками
- Готовность помочь с исправлением
Ложные срабатывания AI
Проблема: AI может генерировать ложные срабатывания — уязвимости, которые на самом деле не существуют или не могут быть эксплуатированы.
Как избежать:
1. Всегда проверяй вручную:
- Не полагайся только на ответ AI
- Тестируй каждую найденную проблему
- Проверяй контекст выполнения кода
2. Используй несколько моделей:
- Проверь результат в разных AI (Grok, Claude, GPT)
- Сравни ответы разных моделей
- Используй консенсусный подход
3. Валидируй PoC:
- Если AI предлагает PoC, обязательно протестируй его
- Убедись, что эксплойт действительно работает
- Проверь все предварительные условия
Законность использования
Легальное использование:
✅ Собственные проекты:
- Тестирование собственного кода
- Анализ open-source проектов, которые ты используешь
- Обучение и исследования в изолированной среде
✅ С разрешения:
- Bug Bounty программы с письменным соглашением
- Авторизованное тестирование на проникновение
- Аудит безопасности с согласия владельца
Незаконное использование:
❌ Без разрешения:
- Тестирование чужих систем без согласия
- Использование найденных уязвимостей для атак
- Продажа zero-day на черном рынке
Последствия незаконного использования:
- Уголовная ответственность (компьютерное мошенничество, несанкционированный доступ)
- Гражданские иски от пострадавших компаний
- Репутационный ущерб
- Запрет на участие в Bug Bounty программах
Этические принципы
1. Не навреди:
- Не используй уязвимости для причинения вреда
- Не нарушай конфиденциальность пользователей
- Не создавай бэкдоры или вредоносное ПО
2. Помогай улучшать безопасность:
- Сообщай о найденных проблемах ответственно
- Предлагай способы исправления
- Делись знаниями с сообществом (после патча)
3. Уважай приватность:
- Не извлекай личные данные при тестировании
- Не публикуй конфиденциальную информацию
- Соблюдай GDPR и другие законы о защите данных
Риски использования AI
1. Переоценка возможностей:
- AI не заменяет экспертизу человека
- Всегда нужна ручная проверка
- AI может пропустить сложные уязвимости
2. Зависимость от AI:
- Не теряй навыки ручного анализа
- Продолжай изучать новые техники
- Используй AI как инструмент, а не замену
3. Утечка информации:
- Не загружай конфиденциальный код в публичные AI
- Используй локальные модели для чувствительных данных
- Проверяй политику конфиденциальности AI-сервисов
Интеграция AI-промптов в рабочий процесс
Настройка рабочего окружения
1. Выбор AI-модели:
- Grok (xAI): Хорош для технического анализа, быстрые ответы
- Claude 3.5 Sonnet (Anthropic): Отличное понимание контекста, детальные ответы
- GPT-4o (OpenAI): Универсальный, хорош для генерации кода
- Gemini 2.0 (Google): Силен в анализе больших объемов данных
2. Настройка API:
bash
<h2 id="primer-nastroyki-dlya-claude-api">Пример настройки для Claude API</h2>
export ANTHROPIC_API_KEY="your-api-key"
<h2 id="primer-nastroyki-dlya-openai">Пример настройки для OpenAI</h2>
export OPENAI_API_KEY="your-api-key"
3. Инструменты для автоматизации:
- Плагины для IDE: GitHub Copilot, Cursor AI
- CLI инструменты: aicli, llm-cli
- Скрипты: Python скрипты для массового анализа
Типичный рабочий процесс
День 1: Выбор цели и первичный анализ
1. Выбор библиотеки/проекта для анализа
2. Клонирование репозитория
3. Использование промптов №1-10 для общего анализа
4. Составление списка подозрительных мест
День 2-3: Углубленный анализ
1. Детальный анализ найденных проблем (промпты №11-20)
2. Поиск аналогичных уязвимостей
3. Изучение истории изменений
4. Анализ зависимостей
День 4-5: Создание PoC
1. Генерация эксплойтов (промпты №21-30)
2. Адаптация под тестовое окружение
3. Тестирование в изоляции
4. Документирование результатов
День 6-7: Верификация и отчет
1. Финальная проверка всех найденных проблем
2. Оценка критичности (CVSS)
3. Подготовка отчета
4. Отправка разработчикам (если применимо)
Автоматизация с помощью скриптов
Пример Python скрипта для массового анализа:
python
import anthropic
import os
import json
client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
def analyze_code_with_prompt(code, prompt_template):
prompt = prompt_template.format(code=code)
message = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=4096,
messages=[{"role": "user", "content": prompt}]
)
return message.content[0].text
<h2 id="ispolzovanie">Использование</h2>
prompt_1 = """
Ты — эксперт по zero-day hunting. Проанализируй этот код:
{code}
Найди потенциальные уязвимости...
"""
code_to_analyze = """
// Вставь код здесь
"""
result = analyze_code_with_prompt(code_to_analyze, prompt_1)
print(result)
Интеграция с инструментами безопасности
1. Интеграция с статическими анализаторами:
- Используй результаты SAST как входные данные для AI
- Попроси AI объяснить найденные предупреждения
- Используй AI для фильтрации ложных срабатываний
2. Интеграция с фаззерами:
- Используй AI для генерации начального корпуса для фаззера
- Попроси AI создать fuzzing harness (промпт №40)
- Используй AI для анализа крашей, найденных фаззером
3. Интеграция с Bug Bounty платформами:
- Автоматизируй создание отчетов с помощью AI
- Используй AI для проверки дубликатов перед отправкой
- Попроси AI улучшить описание найденных уязвимостей
Сравнение AI-моделей для zero-day hunting
Grok (xAI)
Преимущества:
- Быстрые ответы
- Хорошее понимание технических деталей
- Бесплатный доступ через X (Twitter)
- Актуальная информация (доступ к интернету)
Недостатки:
- Меньший контекст по сравнению с конкурентами
- Иногда менее детальные ответы
- Зависимость от платформы X
Лучше всего для:
- Быстрого первичного анализа
- Поиска информации о известных CVE
- Генерации идей для исследования
Claude 3.5 Sonnet (Anthropic)
Преимущества:
- Отличное понимание контекста
- Детальные и структурированные ответы
- Хорошая работа с кодом
- Безопасность и этичность встроены
Недостатки:
- Платный API (но есть бесплатный tier)
- Иногда слишком осторожен
- Меньше креативности в некоторых задачах
Лучше всего для:
- Детального анализа кода
- Генерации качественных PoC
- Объяснения сложных концепций
- Создания документации
GPT-4o (OpenAI)
Преимущества:
- Универсальность
- Отличная генерация кода
- Большая база знаний
- Хорошая интеграция с инструментами
Недостатки:
- Платный API
- Иногда галлюцинации
- Может быть менее точным в специализированных задачах
Лучше всего для:
- Генерации эксплойтов
- Автоматизации задач
- Работы с различными языками программирования
- Интеграции в существующие инструменты
Gemini 2.0 (Google)
Преимущества:
- Бесплатный доступ
- Хорошая работа с большими объемами данных
- Мультимодальность (текст, изображения, код)
- Интеграция с Google сервисами
Недостатки:
- Меньше специализации на безопасности
- Иногда менее точные ответы
- Ограничения на некоторые типы контента
Лучше всего для:
- Анализа больших репозиториев
- Поиска паттернов в коде
- Исследовательских задач
- Обучения и экспериментов
Рекомендации по выбору
Для начинающих:
- Начни с бесплатных вариантов (Grok, Gemini)
- Попробуй разные модели для сравнения
- Используй Claude для обучения (лучшие объяснения)
Для профессионалов:
- Claude для детального анализа
- GPT-4o для автоматизации
- Комбинируй несколько моделей для лучших результатов
Для команд:
- Стандартизируй на одной модели для консистентности
- Используй API для интеграции в CI/CD
- Ведите журнал используемых промптов и результатов
Часто задаваемые вопросы
AI реально находит zero-day?
Ответ: Да, в 2025–2026 годах уже есть десятки подтверждённых случаев нахождения zero-day уязвимостей с помощью AI. По данным HackerOne и Bugcrowd, 38% новых zero-day находят с помощью AI-помощников. Однако важно понимать, что AI не заменяет экспертизу человека — он ускоряет процесс и помогает находить паттерны, но финальная верификация всегда требует ручной проверки.
Какой промпт самый эффективный?
Ответ: Промпт №1 (универсальный анализ кода) — лучший для начала, так как он дает общее представление о потенциальных проблемах. Однако эффективность зависит от конкретной задачи:
- Для общего анализа: промпты №1-10
- Для анализа библиотек: промпты №11-20
- Для создания эксплойтов: промпты №21-30
- Для специализированных задач: промпты №31-50
Нужен ли платный API?
Ответ: Для начала достаточно бесплатных вариантов (Grok через X, Gemini). Однако платные API (Claude, GPT-4o) предоставляют:
- Больший контекст (больше токенов)
- Более качественные ответы
- API доступ для автоматизации
- Меньше ограничений
Для серьезной работы рекомендуется использовать платные API, но можно начать с бесплатных для обучения.
Можно ли использовать в bug bounty?
Ответ: Да, но с важными оговорками:
1. Проверь правила платформы: Некоторые платформы разрешают использование AI, другие — нет
2. Не нарушай правила: Не используй AI для автоматической массовой отправки отчетов
3. Всегда проверяй вручную: AI может генерировать ложные срабатывания
4. Будь этичным: Используй AI для помощи в исследовании, а не для спама
Большинство платформ (HackerOne, Bugcrowd) разрешают использование AI как инструмента исследования, но запрещают полностью автоматизированную отправку отчетов.
Как избежать ложных срабатываний?
Ответ:
1. Всегда проверяй вручную: Не полагайся только на ответ AI
2. Тестируй PoC: Если AI предлагает эксплойт, обязательно протестируй его
3. Используй несколько моделей: Сравнивай ответы разных AI
4. Проверяй контекст: Убедись, что код действительно выполняется в уязвимом контексте
5. Изучай код глубже: Понимание логики кода помогает отфильтровать ложные срабатывания
Сколько времени занимает поиск zero-day с AI?
Ответ: Время сильно варьируется:
- Простая уязвимость: 2-4 часа (от промпта до PoC)
- Средняя сложность: 1-2 дня
- Сложная уязвимость: 3-7 дней
Это значительно быстрее, чем ручной анализ (2-4 недели), но все равно требует времени на верификацию и создание качественного отчета.
Можно ли использовать AI для анализа проприетарного кода?
Ответ: Осторожно! При загрузке проприетарного кода в публичные AI сервисы:
- Код может быть сохранен и использован для обучения модели
- Код может быть доступен другим пользователям
- Это может нарушить NDA или лицензионные соглашения
Рекомендации:
- Используй локальные модели для проприетарного кода
- Проверяй политику конфиденциальности AI-сервиса
- Используй API с гарантиями конфиденциальности (некоторые провайдеры предлагают private endpoints)
- Рассмотри возможность использования open-source моделей локально
Как улучшить результаты AI?
Ответ:
1. Итеративное уточнение: Начинай с общего промпта, затем уточняй на основе ответов
2. Предоставляй контекст: Чем больше контекста (версия, окружение, известные CVE), тем лучше ответ
3. Используй примеры: Few-shot learning улучшает результаты
4. Комбинируй промпты: Используй несколько промптов для разных аспектов
5. Проверяй и улучшай: Анализируй, какие промпты дают лучшие результаты, и улучшай их
Нужны ли специальные знания для использования промптов?
Ответ: Базовые знания безопасности необходимы:
- Понимание типов уязвимостей (buffer overflow, RCE, SSRF и т.д.)
- Знание языков программирования, которые анализируешь
- Понимание принципов эксплуатации уязвимостей
- Опыт работы с инструментами безопасности
Однако AI может помочь в обучении — используй его для объяснения концепций и изучения новых техник.
Заключение: Будущее охоты на zero-day с AI
В 2026 году охота на zero-day уязвимости без использования AI — это как стрельба из лука в эпоху дронов. Искусственный интеллект не заменяет экспертизу исследователя безопасности, но значительно ускоряет процесс поиска уязвимостей и открывает новые возможности для анализа кода.
Ключевые выводы
AI как инструмент ускорения:
- Сокращение времени от идеи до PoC с недель до часов
- Возможность анализа больших объемов кода за разумное время
- Генерация гипотез, которые человек мог бы пропустить
Важность ручной проверки:
- AI может генерировать ложные срабатывания
- Финальная верификация всегда требует экспертизы человека
- Понимание контекста и бизнес-логики критически важно
Этические принципы:
- Ответственное раскрытие уязвимостей
- Легальное использование инструментов
- Помощь в улучшении безопасности, а не причинение вреда
Будущее развития
Ожидаемые улучшения в ближайшие годы:
1. Специализированные модели:
- Модели, обученные специально на коде и уязвимостях
- Лучшее понимание контекста безопасности
- Меньше ложных срабатываний
2. Интеграция с инструментами:
- Встроенный AI в IDE и статические анализаторы
- Автоматическая генерация тестов и эксплойтов
- Интеграция в CI/CD pipeline
3. Улучшение точности:
- Лучшее понимание сложных уязвимостей
- Анализ логических ошибок
- Предсказание новых векторов атак
4. Автоматизация:
- Полностью автоматизированный поиск уязвимостей
- Автоматическая генерация отчетов
- Интеграция с системами управления уязвимостями
Начни сегодня
Эти 50+ промптов — твой арсенал для начала охоты на zero-day с помощью AI. Начни с простого анализа кода (промпты №1-10), изучи результаты, и уже через неделю ты сможешь найти первую реальную уязвимость.
Помни:
- Начинай с малого — анализируй простые проекты
- Всегда проверяй результаты вручную
- Следуй этическим принципам
- Документируй свои находки
- Делись знаниями с сообществом
Охота на zero-day с AI — это не магия, а комбинация правильных инструментов, знаний и практики. Используй эти промпты как отправную точку, адаптируй их под свои нужды, и создавай свои собственные техники.
Будущее безопасности в твоих руках — и в руках AI, который тебе помогает.
