Skip to content
KitploitKITPLOIT
ИнструментыЭксплойтыБлог
Log in
Отправить
ИнструментыЭксплойтыБлог
Отправить

Инструменты для хакинга, пентеста и кибербезопасности — ваш арсенал защиты!

Kitploit — это каталог инструментов для хакинга, кибербезопасности и пентестинга. Находите последние обновления проектов для поиска уязвимостей, анализа систем, автоматизации тестирования и усиления вашей безопасности.

ЛентыКонтактыКонфиденциальность© 2026 Kitploit

Каталог инструментов

Категории

Все категории
Loading categories
NoiseHound — Обнаружение-осведомлённое скоринг атакующих путей BloodHound — самый незаметный маршрут к вашей цели, откалиброванный по пяти уровням обнаружения (audit/EDR/Elastic/MDI/WDAC) плюс Azure. | Kitploit
Инструменты/GitHubGitHub/warpedatom/noisehound
Оборонительные ИнструментыПовышение привилегийЛатеральное перемещениеПост-эксплуатацияТестирование на ПроникновениеRed TeamingСостязательная Атака
GitHubwarpedatom/noisehound

NoiseHound

Обнаружение-осведомлённое скоринг атакующих путей BloodHound — самый незаметный маршрут к вашей цели, откалиброванный по пяти уровням обнаружения (audit/EDR/Elastic/MDI/WDAC) плюс Azure.

Репозиторий
6710712 месяцев назадПроверено Kitploit
Поделиться
Сайт
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/50019/502beed5defd8b7d32991f173f6339e3214eb604968886518cd026cc2e4d3ee5.png" alt="NoiseHound" width="600"></p>

<h1 align="center">NoiseHound</h1>

<p align="center">
  <a href="https://pypi.org/project/noisehound/"><img src="https://img.shields.io/pypi/v/noisehound" alt="PyPI"></a>
  <a href="https://github.com/warpedatom/NoiseHound/releases"><img src="https://img.shields.io/github/v/release/warpedatom/NoiseHound" alt="Release"></a>
  <a href="https://github.com/warpedatom/noisehound/blob/main/LICENSE"><img src="https://img.shields.io/github/license/warpedatom/NoiseHound" alt="License"></a>
  <img src="https://img.shields.io/badge/python-3.10+-3776AB?logo=python&amp;logoColor=white" alt="Python 3.10+">
  <a href="https://github.com/warpedatom/NoiseHound/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/warpedatom/NoiseHound/ci.yml?branch=main&amp;label=CI" alt="CI"></a>
  <a href="https://github.com/warpedatom/noisehound/blob/main/SECURITY.md"><img src="https://img.shields.io/badge/Security-Policy-green" alt="Security policy"></a>
  <a href="https://x.com/warped_atom"><img src="https://img.shields.io/badge/X-@warped__atom-000000?logo=x&amp;logoColor=white" alt="X (Twitter): @warped_atom"></a>
</p>

**Оценка путей атаки в Active Directory с учётом обнаружения.**
_DreadHost Research | дополнение к OffsetInspect (PowerShell) и OffsetScan (Rust)_

BloodHound (и PlumHound поверх него) находит *некоторый* путь к цели.
NoiseHound принимает те же данные графа и переранжирует пути по **ожидаемой
стоимости обнаружения** вместо числа переходов, так что оператор может спросить
«какой самый тихий способ добраться до Domain Admin» вместо просто «какой есть способ».

> **Впервые здесь? [Operator Walkthrough](https://github.com/warpedatom/noisehound/blob/main/docs/WALKTHROUGH.md) — самый быстрый способ
> увидеть, что это делает** — практическое, основанное на скриншотах руководство от установки до живого
> proof of concept в BloodHound CE (оценки записываются обратно в интерфейс), движка DeadAir
> и отчёта о пробелах в обнаружении для blue team.

> **Статус проекта (v1.2.0):** стабилен и протестирован на реальных данных BloodHound в
> нескольких доменах. **37 из 77 рёбер корпуса измерены в лаборатории** в пяти
> локальных уровнях обнаружения (Windows audit, Defender for Endpoint, Elastic SIEM,
> runtime-оповещения Defender for Identity и WDAC audit) плюс измеренный уровень Azure/Entra
> — поставляется как шесть готовых профилей в [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles), с
> доказательством замкнутого цикла, что они меняют ранжирование путей ([`docs/VALIDATION.md`](https://github.com/warpedatom/noisehound/blob/main/docs/VALIDATION.md)).
> Корпус включает 13 рёбер **Azure/Entra** ([`docs/AZURE.md`](https://github.com/warpedatom/noisehound/blob/main/docs/AZURE.md)),
> принимаемых напрямую из вывода AzureHound.
> Неизмеренные локальные и все рёбра Azure несут **экспертные оценки**; стенд калибровки
> (`noisehound-calibrate`) — это то, как они и ваша собственная среда получают
> измерения. Относитесь к некалиброванным рейтингам как к хорошо обоснованным рекомендациям, а не как к истине в последней инстанции.

> Только для авторизованных работ. Этот инструмент оценивает пути атаки для планирования
> OPSEC против систем, на тестирование которых у вас есть письменное разрешение.

> NoiseHound — независимый общественный проект. Он не связан с,
> не одобрен и не ассоциирован со SpecterOps или проектом BloodHound; он
> использует открытый формат данных BloodHound.

---

## Как это работает

1. **Загрузить** экспорт BloodHound CE (`.zip`), необработанный JSON-файл или каталог
   с экспортами во внутренний граф. Также принимается нормализованный JSON-формат `{nodes, edges}`
   для офлайн-анализа и тестов. Рёбра эскалации AD CS **ESC1-8** синтезируются
   при загрузке на основе фактов о шаблонах сертификатов и CA, которые собирает
   BloodHound (см. ниже).
2. **Аннотировать** каждое ребро из корпуса телеметрии рёбер, присваивая
   `effective_noise_score` (0-100). Если несколько прав соединяют одну и ту же пару
   узлов, выбирается самое тихое. Типы рёбер, отсутствующие в корпусе, по умолчанию
   получают консервативную оценку (60), чтобы пробелы срабатывали безопасно, а не занижали
   отчётность. Необязательный **профиль окружения** корректирует оценки в соответствии
   с заявленной целевой позицией обнаружения (см. ниже).
3. **Решить** задачу поиска самых тихих путей. Поскольку оценка пути представляет собой
   узкое место плюс среднее (а не простую сумму), её нельзя оптимизировать напрямую
   с помощью Дейкстры. Решатель сочетает *пороговый перебор* (для каждого отдельного
   уровня шума — самый тихий маршрут, остающийся ниже него) с ограниченным проходом
   k-кратчайших по весу путей, а затем переранжирует объединение по реальной оценке
   пути. Пороговый перебор служит гарантией корректности: он выявляет длинный, но
   равномерно тихий путь, который чистый поиск по сумме весов поставил бы ниже
   короткого, но громкого.
4. **Отчёт** в виде текста, JSON (совместимого со схемой результатов OffsetInspect)
   или самодостаточного HTML-отчёта, оформленного в стиле набора инструментов.

### Оценка путей

Шум пути намеренно **не** является простой суммой. Срабатывание одного и того же
обнаружения дважды не делает его вдвое громче (триаж SOC, а не подсчёт сырых событий).
NoiseHound использует:

```
path_score = max(edge_scores) * 0.6 + mean(edge_scores) * 0.4
```

Это смещает вес в сторону самого громкого отдельного шага (один плохой шаг часто сжигает всю операцию), при этом всё ещё учитывая накопленную экспозицию. Веса настраиваются (`--max-weight` / `--mean-weight`), поэтому их можно эмпирически подобрать, когда появятся реальные данные обнаружения из лаборатории APT29/Caldera.

Каждый путь также сообщает **вероятность обнаружения** — шанс, что он вызовет коррелированную тревогу — смешивая самое громкое ребро с накопленным noisy-OR всех рёбер (настраивается через `--correlation`). Это отвечает на другой вопрос, чем оценка шума: короткий, но громкий путь может иметь *меньшую* общую вероятность быть пойманным, чем длинный, но тихий. Ранжируйте по ней с помощью `--rank-by probability`.

### Двухуровневый движок (DeadAir)

Для больших графов решение передаётся в [DeadAir](https://github.com/warpedatom/DeadAir) — сопутствующий движок на Rust (уровень OffsetScan-to-OffsetInspect). NoiseHound остаётся многофункциональным фронтендом — приём данных, корпус, окружение/Sigma, ограничения, отчётность — и передаёт подготовленный граф тому движку, который его решает, поэтому результаты идентичны в любом случае.

- `--engine auto` (по умолчанию): DeadAir, когда найден его бинарник *и* граф большой (>= 5000 узлов); в противном случае встроенный решатель на Python.
- `--engine python`: принудительно использовать встроенный решатель (бинарник не нужен).
- `--engine rust`: принудительно использовать DeadAir (ошибка, если бинарник отсутствует).

DeadAir ищется через `$NOISEHOUND_DEADAIR`, затем `PATH`, затем соседнюю сборку `../deadair/target/{release,debug}/`. Он в 10-100 раз быстрее на больших графах (граф на 250 тыс. узлов решается за ~2 с против ~30 с на Python), при этом выдавая побайтово идентичные ранжирования. В выводе записывается, какой движок работал.

### Многоцелевая и ограниченная маршрутизация

Шум, число переходов и вероятность обнаружения тянут в разные стороны, поэтому `--pareto` возвращает **фронт Парето** — каждый путь, который не превосходится другим ни по одному из трёх критериев одновременно — вместо принудительного выбора единственного победителя. А у реальных операций есть ограничения: `--avoid NODE` удерживает путь от конкретного хоста (прыжковый сервер под мониторингом EDR, honeypot), а `--avoid-edge TYPE` запрещает технику (например, `--avoid-edge DCSync`). Оба параметра можно повторять, и решение пересчитывается на лету.

```bash
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --pareto
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --avoid FILESERVER01 --avoid-edge HasSession
```

## Как NoiseHound сравнивается с другими инструментами

Взвешенный по шуму поиск путей в BloodHound — не новость, поэтому вот честное позиционирование:

- **BloodHound / BloodHound CE** находят *некоторый* путь по невзвешенному числу переходов. Модели шума нет.
- **GoodHound** назначает стоимость рёбрам и находит самые дешёвые пути, но его модель стоимости основана на сложности эксплуатации и бизнес-риске, а не на шуме обнаружения.
- **PlumHound / ImproHound** занимаются отчётностью и анализом нарушений уровней доступа; ни один из них не выполняет повторное решение задачи поиска тишайшего пути к цели.
- **Сопоставления с обнаружениями** (Sigma, DeTT&CT, справочники соответствия event-ID → ATT&CK) богаты, но ориентированы на человека и не привязаны к типам рёбер BloodHound.

Вклад NoiseHound — это комбинация: машиночитаемый корпус телеметрии обнаружения, привязанной к рёбрам BloodHound, повторное решение задачи с весами шума, сформулированное как OPSEC оператора («тишайший путь к DA»), модель окружения, адаптирующаяся к заявленной конфигурации цели, и цикл калибровки, превращающий обнаружения из лаборатории в измеренные оценки. Сама графовая математика — это стандартный инструментарий; суть — в корпусе и в постановке задачи. Его ценность ровно настолько высока, насколько хорош корпус, поэтому калибровка и вклад сообщества являются первостепенными — см. ниже.

## Установка

```bash
cd NoiseHound
python -m pip install -r requirements.txt   # networkx>=3.0
# optional editable install to get the `noisehound` command on PATH:
python -m pip install -e .
```

Требуется Python 3.10+.

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

```bash
# Text summary (default)
python -m noisehound --input export.zip --objective "Domain Admins" --source jdoe

# JSON, for downstream tooling / correlation across the DreadHost suite
python -m noisehound -i export.zip -o "Domain Admins" -s jdoe -f json --out paths.json

# Self-contained HTML report
python -m noisehound -i export.zip -o "Domain Admins" -s jdoe -f html --out report.html
```

Сначала проверьте парсер на вашем экспорте (гистограммы + покрытие корпуса, без построения путей) — самый быстрый способ проверить NoiseHound на реальных данных:

```bash
noisehound-inspect -i export.zip
```

### Работа с BloodHound CE / Neo4j в реальном времени

Вместо zip-архива укажите `--input` на базу данных Neo4j, которую заполняет BloodHound CE,
и NoiseHound будет читать (уже проанализированный) граф напрямую через Bolt:

```bash
pip install 'noisehound[neo4j]'
export NEO4J_PASSWORD=bloodhoundcommunityedition   # match your BHCE compose
noisehound-inspect -i bolt://localhost:7687
python -m noisehound -i bolt://localhost:7687 -s jdoe -o "Domain Admins"
```

Разверните BloodHound CE (включает Neo4j на порту 7687) с помощью официального compose-файла:
`curl -L https://ghst.ly/getbhce | docker compose -f - up`.

Попробуйте его на встроенных примерах:

```bash
python -m noisehound -i samples/sample_graph.json -s jdoe -o "Domain Admins" -d CONTOSO.LOCAL
python -m noisehound -i samples/sample_bloodhound_ce.zip -s jdoe -o "Domain Admins"
python -m noisehound -i samples/sample_adcs_ce.zip -s jdoe -o "Domain Admins"   # ADCS ESC1
# Full-spectrum export exercising every edge family (sessions, delegation, DCSync, ADCS, trusts):
python -m noisehound -i samples/sample_fullspectrum_ce.zip -s ALICE -o "Domain Admins" -d CONTOSO.LOCAL -k 3
```

Последний пример — самое наглядное подтверждение тезиса: самый тихий маршрут к Domain Admins — это 4-шаговый путь через сессии, который стоит *выше* 3-шагового пути через RDP и 1-шагового ADCS ESC1 — больше всего шагов, меньше всего шума.

Пример демонстрирует основную ценность: самый тихий маршрут — это 4-шаговый путь через сессии (оценка 19.9), который стоит *выше* 2-шагового сокращения через ForceChangePassword (36.4). Меньше шагов не означает тише.

### Режим выявления пробелов в обнаружении для синей команды

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

```bash
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --defensive
```

На полной выборке он обнаруживает, что самый тихий путь к Domain Admins
зависит от незамеченного доступа к LSASS (`HasSession`, 20 -> 65 при наличии инструментирования), и
рекомендует развернуть Sysmon Event 10 — закрытие этого единственного пробела поднимает самый тихий
путь с 19,9 до 48,4. См. [`docs/ROADMAP.md`](https://github.com/warpedatom/noisehound/blob/main/docs/ROADMAP.md), чтобы узнать, куда движется это
и остальная часть модели.

### Ключевые опции

| Опция | Значение |
|--------|---------|
| `--input, -i` | BloodHound `.zip`, `.json` или каталог с экспортами |
| `--source, -s` | Начальный субъект (`jdoe` или id объекта) |
| `--objective, -o` | Целевой узел (`Domain Admins` или id объекта) |
| `--paths, -k` | Количество самых тихих путей для вывода (по умолчанию 5) |
| `--format, -f` | `text` (по умолчанию), `json` или `html` |
| `--defensive` | Взгляд синей команды: пробелы в обнаружении на самых тихих путях + исправления |
| `--rank-by` | `noise` (по умолчанию) или `probability` (P коррелированного оповещения) |
| `--correlation` | Коэффициент корреляции SOC для P(detected), 0..1 (по умолчанию 0.5) |
| `--pareto` | Вернуть границу Парето по noise/hops/P(detect) |
| `--engine` | `auto` (по умолчанию), `python` или `rust` (движок DeadAir) |
| `--avoid NODE` | Исключить узел из всех путей (можно повторять) |
| `--avoid-edge TYPE` | Исключить тип ребра из всех путей (можно повторять) |
| `--corpus` | Переопределить каталог корпуса сопоставления рёбер |
| `--environment, -e` | JSON с заявленной оператором конфигурацией цели (корректирует оценки) |
| `--max-weight` / `--mean-weight` | Веса оценки (в сумме должны давать 1.0) |
| `--default-noise` | Оценка для типов рёбер, отсутствующих в корпусе (по умолчанию 60) |

---

## Профили окружения

Статическая оценка из корпуса не может знать, включён ли на данной цели аудит объектов
4662, развёрнут ли Sysmon или работает ли ITDR вроде MDI — а ведь всё это колоссально меняет
реальный шум ребра (DCSync почти бесшумен без аудита 4662 и
почти гарантированно обнаруживается с ним). Вместо того чтобы делать вид, что одно число подходит для любого
окружения, объявите конфигурацию цели в небольшом JSON-файле, и NoiseHound
прозрачно скорректирует оценки на основе собственных телеметрических аннотаций корпуса:

```json
{
  "name": "CONTOSO.LOCAL-prod",
  "object_auditing_4662": true,
  "ds_change_auditing_5136": false,
  "edr": "MDI",
  "sysmon": true,
  "powershell_logging_4104": true,
  "adjustments": { "HasSession": 65 }
}
```

Корректировки всегда только *повышают* оценку до порога обнаружения, подразумеваемого объявленной конфигурацией. `adjustments` — это жёсткие переопределения для каждого ребра, место для записи значений, которые вы откалибровали на собственной лабораторной среде. Они предоставляются оператором, а не измеряются; это не заменяет живую валидацию фазы 2, но превращает статический корпус из «одного числа для всех сред» в «число для среды, в которой вы на самом деле находитесь». На прилагаемом образце объявление профиля выше переключает самый тихий маршрут с пути сессии дампа LSASS на путь записи в каталог — что является правильным решением, как только телеметрия хоста станет активной.

```bash
python -m noisehound -i samples/sample_graph.json -s jdoe -o "Domain Admins" \
    -e samples/env_profile.example.json
```

Приоритет оценки: `static -> environment-adjusted -> live (Phase 2)`.

---

## Стенд калибровки

Профили окружения хороши настолько, насколько хороши числа, которые вы в них вносите.
`noisehound-calibrate` замыкает цикл: запустите техники в лаборатории обнаружения,
зафиксируйте, что сработало, и он выдаст калиброванный профиль окружения.

**Это уже сделано.** [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles) содержит шесть измеренных профилей из
реального стенда Hyper-V Vulnerable-AD и лабораторного тенанта Azure — уровни audit, EDR (Defender for
Endpoint), Elastic SIEM, Defender for Identity и WDAC, а также измеренный
уровень Azure/Entra, 37 рёбер — полученных с помощью автоматизированного стенда (`lab/`) и этого
инструмента. Используйте их напрямую или измерьте свои собственные:

```bash
# Use a shipped measured profile:
noisehound -i export.zip -s jdoe -o "Domain Admins" -e profiles/vulnad-hyperv-audit.json

# Or measure your own lab:
# 1. noisehound-calibrate --plan -o plan.json   (per-edge detection events)
# 2. lab/Invoke-NoiseHoundCalibration.ps1        (run + auto-count -> lab_detections.json)
noisehound-calibrate -i lab_detections.json -o env.calibrated.json
noisehound -i export.zip -s jdoe -o "Domain Admins" -e env.calibrated.json
```

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

```
p          = detections / runs                       (detection probability)
lab_score  = p * severity_loudness + (1 - p) * residual
w          = runs / (runs + smoothing)               (confidence in the lab)
calibrated = w * lab_score + (1 - w) * corpus_static
```

`lab_score` — ожидаемая стоимость обнаружения: серьёзность для SOC, когда срабатывает, и небольшой остаточный вес, когда не срабатывает. Вес `w` не позволяет одному запуску перевесить корпус, но даёт хорошо представленному результату доминировать. В примере HasSession поднимается со статических 20 до 52 (лаборатория поймала дамп LSASS в 4 из 5 запусков), а Kerberoast падает с 60 до 34 (он ни разу не сработал). Используйте `--merge existing.json`, чтобы наложить новую калибровку на профиль, сохранив его флаги posture, а `--smoothing` / `--residual` — для настройки модели.

---

## Оценка по развёрнутым детекциям (Sigma)

Профили окружения и калибровка задаются самостоятельно. `noisehound-sigma` оценивает по детекциям, которые защитник *фактически написал*: укажите ему набор правил Sigma, и он определит, на каких рёбрах корпуса сработает каждое правило (сопоставляя ID событий телеметрии ребра и технику ATT&CK), а затем выдаст профиль окружения, который повышает покрытые рёбра — готовая замена для `--environment`.

```bash
noisehound-sigma -r ./sigma-rules/ -o env.sigma.json
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" -e env.sigma.json --defensive
```

Для уровня идентификации **`noisehound-mdi`** делает то же самое в отношении встроенных детекций Microsoft Defender for Identity — он сопоставляет runtime-оповещения MDI (а при использовании `--include-posture` — и его ISPM-оценки) с рёбрами корпуса и формирует профиль уровня идентификации. MDI не зависит от инструментов, поэтому его покрытие сохраняется независимо от инструментария атакующего.

```bash
noisehound-mdi -o env.mdi.json          # + coverage report (which edges MDI watches, and the gaps)
```

Для рёбер **Azure/Entra** инструмент **`noisehound-entra`** измеряет облачный уровень так же, как измерялись локальные уровни: запускает злоупотребления `AZ*` в лабораторном тенанте, экспортирует журнал Entra `directoryAudits` и подсчитывает, что фактически попало в журнал согласно откалиброванному профилю (`docs/AZURE_CALIBRATION.md`).

```bash
noisehound-entra -a directoryAudits.json -m entra_runs.json --profile-out profiles/lab-tenant-azure.json
```

Сопоставление намеренно консервативно, чтобы никогда не скрывать пробел: правило учитывается только если оно ссылается на ID события, которое генерирует ребро, *и*, когда правило имеет тег ATT&CK, его техника совпадает — так что правило DCSync DS-Access (4662) не получает ошибочного зачёта за покрытие чтений LAPS, которые лишь разделяют тот же ID события. Отчёт перечисляет как то, что покрывают ваши правила, так и, что полезнее, рёбра атак, которые не покрывает ни одно правило. В сочетании с `--defensive` это отвечает на вопрос: «учитывая развёрнутые мной детекции, где мой самый тихий путь атаки всё ещё невидим?»

### Инвентаризация активной Elastic Security

`noisehound-elastic` отвечает на тот же вопрос применительно к детекциям, которые **фактически включены прямо сейчас** в работающем стеке Elastic Security, а не к правилам на диске. Он читает движок детекций через read-only API `_find` Kibana (или офлайн-экспорт), сопоставляет технику ATT&CK каждого включённого правила и любые коды событий Windows в его запросе и выдаёт тот же профиль покрытия `--environment`.

```bash
export KIBANA_URL=https://kibana:5601 KIBANA_API_KEY=<base64 ApiKey>
noisehound-elastic -o env.elastic.json                                   # live, read-only
noisehound-elastic --rules-json rules_find.json -o env.elastic.json      # offline export
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" -e env.elastic.json --defensive
```

При загрузке NoiseHound выполняет сфокусированную версию постобработки ADCS из BloodHound, синтезируя рёбра эскалации из сохранённых фактов о шаблонах/CA. Право `Enroll` на уязвимом шаблоне становится прямым ребром `ADCSESCn` от субъекта к группе Domain Admins домена (RID 512), поэтому эскалация через сертификаты становится проходимой по пути и оценивается так же, как любое другое ребро:

| Ребро | Условие |
|------|-----------|
| `ADCSESC1` | Enrollee-supplies-subject + EKU client-auth, без approval/RA sigs |
| `ADCSESC2` | EKU Any-Purpose / SubCA, без approval |
| `ADCSESC3` | Шаблон enrollment-agent + шаблон аутентификации на том же CA |
| `ADCSESC4` | Опасный контроль записи над опубликованным шаблоном |

---

[Read more](https://github.com/warpedatom/noisehound)
Скачать инструмент

Популярное

Смотреть все →

Откройте для себя самые используемые инструменты нашего сообщества.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Полный набор инструментов OSINT: граф расследования, оценка достоверности, семейства псевдонимов, карта, временная шкала и отчёты. 49 модулей, более 400 сайтов, API-ключи не требуются.

    795
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Приложение GhostLock с запуском в один клик (CVE-2026-43499)

    520
  • 3

    ARTEX

    baarai/artex

    Платформа автономного тестирования на проникновение на основе мультиагентной LLM с агентами-планировщиками и агентами-исполнителями, графами активов и исследования, записью MITM-трафика и повторной проверкой уязвимостей.

    439
  • 4

    redforge

    cybersecurity91/redforge

    Браузерный инструментарий для red team с 102 офлайн-инструментами для разведки, генерации полезной нагрузки, атак на учётные данные, криптографии, кодирования и отчётности по проектам.

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    Платформа CSIRT, которая загружает отчёты Shadowserver в MongoDB и воспроизводит их в виде интерактивных карт, аналитики, результатов, рекомендаций и исполнительных дашбордов.

    267
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

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

    264

Изучить все инструменты

Просмотрите нашу коллекцию инструментов

Смотреть все инструменты →