itlxrd/dip-ids
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
kilyabin
2026-04-12 22:26:26 +04:00
commit 68f9a01ed5
44 changed files with 7134 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/architecture.md
+131
View File
@@ -0,0 +1,131 @@
# Архитектура системы DIP-IDS
## 1. Общая схема
```
┌─────────────────────────────────────────────────────────────────────┐
│ Пользователь │
│ браузер → localhost:3000 │
└───────────────────────────┬─────────────────────────────────────────┘
│ HTTP
┌───────────────────────────▼─────────────────────────────────────────┐
│ Nuxt 3 Frontend │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────────────┐ │
│ │Dashboard │ │ Alerts │ │ Capture │ │ Stats │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────────────┘ │
│ Nuxt UI · vue-chartjs · Chart.js │
└───────────────────────────┬─────────────────────────────────────────┘
│ REST API (proxy /api/*)
┌───────────────────────────▼─────────────────────────────────────────┐
│ Go Backend (:8080) │
│ │
│ ┌──────────────────────────────────────────────────────────────┐ │
│ │ Gin HTTP Router │ │
│ │ /api/alerts /api/stats /api/capture /api/reports │ │
│ └──────────────────────────┬───────────────────────────────────┘ │
│ │ │
│ ┌──────────────────────────▼───────────────────────────────────┐ │
│ │ Analyzer Engine │ │
│ │ │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ │ │
│ │ │PortScan │ │BruteForce │ │ DoS │ │ │
│ │ │Detector │ │Detector │ │ Detector │ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ │ │
│ │ ┌────────────┐ ┌────────────┐ │ │
│ │ │ARPSpoof │ │DNS Anomaly │ │ │
│ │ │Detector │ │Detector │ │ │
│ │ └────────────┘ └────────────┘ │ │
│ └──────────────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────┐ ┌─────────────┐ ┌─────────────────┐ │
│ │ Capture │ │ Storage │ │ PDF Report │ │
│ │ (gopacket) │ │ (SQLite) │ │ (maroto v2) │ │
│ │ live / pcap │ │ GORM │ │ │ │
│ └──────────────┘ └─────────────┘ └─────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
│
┌─────────────┴──────────────┐
│ │
┌────────▼────────┐ ┌─────────▼────────┐
│ Сетевой │ │ PCAP файлы │
│ интерфейс │ │ (.pcap/.pcapng)│
│ (eth0, wlan0) │ │ │
└─────────────────┘ └──────────────────┘
```
## 2. Поток данных
```
Сетевой интерфейс / PCAP файл
│
▼
pcap.Handle (gopacket)
│ chan gopacket.Packet (буфер 1024)
▼
Analyzer Engine.Run()
│ fan-out: каждый пакет → все детекторы
├──▶ PortScanDetector.Analyze(pkt)
├──▶ BruteForceDetector.Analyze(pkt)
├──▶ DoSDetector.Analyze(pkt)
├──▶ ARPSpoofDetector.Analyze(pkt)
└──▶ DNSAnomalyDetector.Analyze(pkt)
│ []storage.Alert
▼
storage.DB.CreateAlert()
│
▼
SQLite (nids.db)
│
┌─────┴──────┐
▼ ▼
REST API PDF Report
(Gin) (maroto v2)
│
▼
Nuxt Frontend
```
## 3. Компоненты и их ответственность
| Компонент | Пакет | Ответственность |
|---|---|---|
| `Capturer` | `internal/capture` | Открывает pcap handle (live или файл), читает пакеты в канал |
| `Engine` | `internal/analyzer` | Принимает пакеты из канала, фанаутит детекторам, сохраняет алерты |
| `Detector` (интерфейс) | `internal/analyzer` | Контракт: `Analyze(pkt) []Alert`, `Reset()` |
| `DB` | `internal/storage` | CRUD алертов, статистики, сессий через GORM + SQLite |
| `Server` | `internal/api` | Gin HTTP сервер, CORS, маршрутизация |
| `handlers/*` | `internal/api/handlers` | Обработчики REST эндпоинтов |
| `report.Generate` | `internal/report` | Генерация структурированного PDF через maroto v2 |
## 4. Модель конкурентности
```
main goroutine
│
├── srv.Run() ← HTTP сервер (Gin, внутренние goroutines)
│
└── при старте захвата:
│
├── capture goroutine ← читает пакеты → chan
│
└── engine goroutine ← engine.Run(ctx, pkts)
│
└── обрабатывает пакеты синхронно (детекторы потокобезопасны через sync.Mutex)
```
Остановка захвата — через отмену `context.Context` (cancel функция хранится в `CaptureState`).
## 5. Выбор технологий
| Технология | Обоснование |
|---|---|
| **Go** | Системный язык, оптимален для сетевых инструментов; компилируется в один бинарник |
| **gopacket** | Стандарт де-факто для захвата пакетов в Go; оборачивает libpcap |
| **Gin** | Минималистичный HTTP фреймворк с высокой производительностью |
| **GORM + SQLite** | Не требует отдельного сервера БД; достаточно для демо и небольших сетей |
| **maroto v2** | Grid-based PDF генератор; создаёт структурированные деловые отчёты |
| **Nuxt 3** | SSR/SPA фреймворк на Vue 3; удобная файловая маршрутизация |
| **Nuxt UI** | Официальная UI библиотека Nuxt; Tailwind CSS, тёмная тема из коробки |
| **Chart.js + vue-chartjs** | Зрелая библиотека графиков; хорошая интеграция с Vue 3 |
| **Bun** | Быстрый JavaScript runtime и пакетный менеджер; замена npm/yarn |
docs/detection.md
+194
View File
@@ -0,0 +1,194 @@
# Алгоритмы обнаружения угроз
## Общие принципы
Все детекторы реализуют **сигнатурный метод** обнаружения на основе скользящего временного окна (sliding window). Каждый детектор:
- Потокобезопасен (`sync.Mutex` на внутреннее состояние)
- Поддерживает дедупликацию — повторный алерт от одного источника не генерируется чаще заданного интервала
- Настраивается через `configs/config.yaml` без перекомпиляции
---
## 1. Port Scan (Сканирование портов)
### Метод обнаружения
Злоумышленник обычно последовательно обращается к множеству портов на одном или нескольких хостах для выявления открытых сервисов. Детектор отслеживает количество **уникальных портов назначения**, к которым обращается один источник за фиксированное время.
### Алгоритм
```
Для каждого TCP SYN-пакета (SYN=1, ACK=0):
key = srcIP
ports[key][dstPort] += timestamp
Удалить записи старше window_seconds
uniquePorts = count(ports[key])
if uniquePorts >= threshold:
если последний алерт был > 30 сек назад:
создать Alert(type=port_scan, severity=high)
```
### Параметры
| Параметр | По умолчанию | Описание |
|----------|-------------|----------|
| `threshold` | 15 | Уникальных портов за период |
| `window_seconds` | 10 | Длина окна в секундах |
### Пример (Nmap):
```
Nmap SYN scan (-sS) → пакеты SYN к портам 22, 80, 443, 3389...
После 15-го уникального порта за 10 секунд → алерт
```
---
## 2. Brute Force (Перебор паролей)
### Метод обнаружения
При переборе паролей атакующий многократно устанавливает TCP-соединение на один и тот же порт аутентификации. Детектор считает количество SYN-пакетов от одного источника к одному порту/хосту назначения.
### Мониторируемые порты
| Порт | Сервис |
|------|--------|
| 22 | SSH |
| 21 | FTP |
| 23 | Telnet |
| 3389 | RDP (Windows Remote Desktop) |
| 5900 | VNC |
| 25 | SMTP |
| 110 | POP3 |
| 143 | IMAP |
### Алгоритм
```
Для каждого TCP SYN-пакета на порт из списка:
key = srcIP + ":" + dstIP + ":" + dstPort
timestamps[key] += now
Удалить записи старше window_seconds
count = len(timestamps[key])
if count >= threshold:
если последний алерт был > 30 сек назад:
создать Alert(type=brute_force, severity=critical)
```
### Параметры
| Параметр | По умолчанию | Описание |
|----------|-------------|----------|
| `threshold` | 10 | Попыток подключения за период |
| `window_seconds` | 30 | Длина окна в секундах |
---
## 3. DoS / DDoS
### Метод обнаружения
Атака отказа в обслуживании характеризуется аномально высоким потоком пакетов от одного (DoS) или множества (DDoS) источников. Детектор измеряет скорость пакетов (PPS — Packets Per Second) от каждого IP в скользящем окне.
### Алгоритм
```
Для каждого IP-пакета:
timestamps[srcIP] += now
Удалить записи старше window_seconds (1 сек по умолчанию)
pps = len(timestamps[srcIP]) / window_seconds
if pps >= pps_threshold:
если последний алерт был > 10 сек назад:
создать Alert(type=dos, severity=critical)
```
### Параметры
| Параметр | По умолчанию | Описание |
|----------|-------------|----------|
| `pps_threshold` | 1000 | Пакетов в секунду |
| `window_seconds` | 1 | Длина окна измерения |
### Ограничение
Детектор срабатывает на отдельные источники. Для распределённого DDoS с тысячами источников необходим дополнительный анализ суммарного трафика к жертве (не реализован в текущей версии).
---
## 4. ARP Spoofing (Подмена ARP)
### Метод обнаружения
Протокол ARP не предусматривает аутентификации, что позволяет злоумышленнику отправить поддельные ARP Reply и связать чужой IP с собственным MAC-адресом (Man-in-the-Middle атака).
Детектор ведёт доверенную таблицу соответствия `IP → MAC`. При получении ARP Reply проверяется, не изменился ли MAC для уже известного IP.
### Алгоритм
```
Для каждого ARP Reply (operation=2):
srcIP = arp.SourceProtAddress
srcMAC = arp.SourceHwAddress
if srcIP in table:
if table[srcIP] != srcMAC:
создать Alert(type=arp_spoof, severity=critical,
desc="IP X сменил MAC с A на B")
table[srcIP] = srcMAC // обновляем
else:
table[srcIP] = srcMAC // первичная запись
```
### Ограничения
- Таблица очищается при `Reset()` (смене сессии). При долгом мониторинге DHCP-обновления MAC не вызывают ложных срабатываний только если DHCP lease истёк.
- Не различает легитимное изменение MAC (замена сетевой карты) от атаки.
---
## 5. DNS Anomaly (Аномалии DNS)
### Сценарий A: DNS-туннелирование
DNS-туннелирование — метод передачи данных через DNS-запросы для обхода фаерволов. Данные кодируются в имени запроса, что приводит к аномально длинным меткам.
Нормальная метка (label): `www`, `mail`, `api` — 3–15 символов.
Подозрительная метка: `aGVsbG8gd29ybGQhIHRoaXMgaXMgYSB0ZXN0` — 38+ символов (base64-данные).
```
Для каждого DNS запроса (QR=0):
for label in split(queryName, "."):
if len(label) > max_label_length (50):
создать Alert(type=dns_anomaly, desc="DNS tunneling: label length N")
```
### Сценарий B: Высокая частота запросов
Аномально высокое число DNS-запросов от одного хоста может указывать на:
- DNS-туннелирование с разбивкой данных на короткие запросы
- Активность вредоносного ПО (C2 beacon через DNS)
- DGA (Domain Generation Algorithm) — малварь генерирует случайные домены
```
Для каждого DNS запроса:
timestamps[srcIP] += now
Удалить записи старше window_seconds
if len(timestamps[srcIP]) >= query_threshold:
создать Alert(type=dns_anomaly, desc="High DNS query rate: N queries/Xs")
```
### Параметры
| Параметр | По умолчанию | Описание |
|----------|-------------|----------|
| `max_label_length` | 50 | Максимальная длина DNS-метки |
| `query_threshold` | 200 | Запросов за период |
| `window_seconds` | 60 | Длина окна |
---
## Сводная таблица детекторов
| Детектор | Протокол | Метод | Ключ дедупл. | Severity |
|----------|----------|-------|--------------|----------|
| Port Scan | TCP | Sliding window, уникальные порты | srcIP | high |
| Brute Force | TCP | Sliding window, частота SYN | srcIP:dstIP:dstPort | critical |
| DoS | IP | Sliding window, PPS | srcIP | critical |
| ARP Spoof | ARP | Таблица IP→MAC | srcIP | critical |
| DNS Anomaly | DNS/UDP | Длина метки + частота | srcIP | medium |
docs/install.md
+110
View File
@@ -0,0 +1,110 @@
# Руководство по установке
## Требования
| Компонент | Версия | Назначение |
|-----------|--------|-----------|
| Linux | любой дистрибутив | ОС (raw sockets доступны только на Linux) |
| Go | ≥ 1.22 | Компиляция бэкенда |
| GCC | любая | Компиляция CGO (go-sqlite3) |
| libpcap-dev | любая | Захват пакетов |
| Bun | ≥ 1.1 | Сборка фронтенда |
## Установка зависимостей
### Debian / Ubuntu
```bash
sudo apt update
sudo apt install -y golang gcc libpcap-dev
# Bun
curl -fsSL https://bun.sh/install | bash
```
### Arch Linux / CachyOS
```bash
sudo pacman -S go gcc libpcap
# Bun
yay -S bun-bin
# или
curl -fsSL https://bun.sh/install | bash
```
### Fedora / RHEL
```bash
sudo dnf install golang gcc libpcap-devel
curl -fsSL https://bun.sh/install | bash
```
## Сборка и запуск
### 1. Клонирование репозитория
```bash
git clone <repo-url> dip-ids
cd dip-ids
```
### 2. Бэкенд
```bash
# Загрузить зависимости
go mod tidy
# Собрать бинарник
go build -o nids ./cmd/ids
# Запустить (sudo обязателен для live-захвата)
sudo ./nids
# API доступен на http://0.0.0.0:8080
```
Конфигурация загружается из `configs/config.yaml`. Альтернативный путь:
```bash
sudo ./nids /path/to/custom-config.yaml
```
### 3. Фронтенд (dev-режим)
```bash
cd frontend
bun install
bun run dev
# Панель доступна на http://localhost:3000
```
### 4. Фронтенд (production-сборка)
```bash
cd frontend
bun run generate
# Статические файлы в frontend/.output/public/
```
## Настройка интерфейса
Узнать имя сетевого интерфейса:
```bash
ip link show
# или
sudo tcpdump -D
```
Обновить в `configs/config.yaml`:
```yaml
capture:
default_interface: "enp3s0" # ← ваш интерфейс
```
## Права доступа
Live-захват требует доступа к raw sockets. Варианты:
**Вариант 1 (рекомендуется для разработки):**
```bash
sudo ./nids
```
**Вариант 2 — capabilities (без sudo):**
```bash
sudo setcap cap_net_raw,cap_net_admin=eip ./nids
./nids
```
**Вариант 3 — только PCAP анализ** (без специальных прав):
Загружайте готовые `.pcap` файлы через веб-панель, бэкенд можно запускать без sudo.
docs/modules.md
+172
View File
@@ -0,0 +1,172 @@
# Описание модулей DIP-IDS
## 1. Модуль захвата трафика (`internal/capture`)
### Назначение
Обеспечивает получение сетевых пакетов из двух источников: живой захват с сетевого интерфейса и чтение ранее записанных PCAP-файлов.
### Файлы
| Файл | Описание |
|------|----------|
| `capture.go` | Структура `Capturer`, функции `New`, `Start`, `Stop`, `ListInterfaces` |
### Ключевые типы
```go
type Mode string // "live" или "pcap"
type Config struct {
Interface string // имя интерфейса (для live)
PCAPFile string // путь к файлу (для pcap)
Mode Mode
Snaplen int32 // максимальный размер захватываемого пакета
Promiscuous bool // неразборчивый режим
}
```
### Принцип работы
`Start(ctx)` открывает `pcap.Handle` нужного типа (live или offline) и запускает горутину, которая читает пакеты в буферизованный канал `chan gopacket.Packet` ёмкостью 1024. При отмене контекста или достижении конца файла канал закрывается.
---
## 2. Движок анализа (`internal/analyzer`)
### Назначение
Центральный компонент, который принимает пакеты и распределяет их по детекторам.
### Файлы
| Файл | Описание |
|------|----------|
| `engine.go` | Структура `Engine`, методы `Run`, `Reset`, `Stats` |
| `detector.go` | Интерфейс `Detector`, вспомогательная структура `timeWindow` |
| `portscan.go` | Детектор сканирования портов |
| `bruteforce.go` | Детектор перебора паролей |
| `dos.go` | Детектор DoS/DDoS атак |
| `arp.go` | Детектор ARP-спуфинга |
| `dns.go` | Детектор DNS-аномалий |
### Интерфейс детектора
```go
type Detector interface {
Name() string // уникальное имя
Analyze(pkt gopacket.Packet) []Alert // анализ пакета, возврат алертов
Reset() // сброс внутреннего состояния
}
```
### Sliding Window
Все детекторы используют скользящее временное окно (`timeWindow`) для хранения событий. При каждом обращении устаревшие записи автоматически удаляются:
```
Время: t-10s ... t-5s ... t-3s ... now
События: [old] [old] [keep] [keep] [keep]
↑
cutoff = now - window_size
```
### Дедупликация алертов
Каждый детектор хранит `alerted map[string]time.Time` — время последнего алерта по ключу (IP, IP:port и т.д.). Повторный алерт генерируется не чаще одного раза в 30–60 секунд на один источник.
---
## 3. Модуль хранения данных (`internal/storage`)
### Назначение
Персистентное хранение алертов, статистики пакетов и сессий захвата.
### Файлы
| Файл | Описание |
|------|----------|
| `models.go` | GORM-модели: `Alert`, `PacketStat`, `CaptureSession` |
| `db.go` | Структура `DB`, CRUD-методы, агрегирующие запросы |
### Модели данных
**Alert** — запись об обнаруженной угрозе:
```
ID | CreatedAt | Type | Severity | SrcIP | DstIP | SrcPort | DstPort | Protocol | Description | Count
```
**PacketStat** — статистика по пакетам (сохраняется каждый 10-й пакет):
```
ID | CreatedAt | Protocol | SrcIP | DstIP | Bytes
```
**CaptureSession** — сессия захвата трафика:
```
ID | CreatedAt | EndedAt | Source | Mode | Status | TotalPkts | TotalBytes
```
### Методы агрегации
| Метод | SQL-эквивалент |
|-------|---------------|
| `AlertsBySeverity()` | `SELECT severity, COUNT(*) GROUP BY severity` |
| `AlertsByType()` | `SELECT type, COUNT(*) GROUP BY type` |
| `TopSourceIPs(n)` | `SELECT src_ip, COUNT(*) GROUP BY src_ip ORDER BY count DESC LIMIT n` |
| `AlertsTimeline(h)` | `SELECT strftime('%H:00', created_at), COUNT(*) GROUP BY hour` |
---
## 4. API сервер (`internal/api`)
### Назначение
HTTP сервер на базе Gin, предоставляет REST API для фронтенда.
### Файлы
| Файл | Описание |
|------|----------|
| `server.go` | Инициализация Gin, регистрация маршрутов, CORS middleware |
| `handlers/alerts.go` | GET /api/alerts, DELETE /api/alerts, DELETE /api/alerts/:id |
| `handlers/stats.go` | GET /api/stats/summary, /timeline, /top-ips |
| `handlers/capture.go` | Управление захватом: start, stop, upload, status, sessions |
| `handlers/reports.go` | GET /api/reports/generate — скачать PDF |
### CORS
Сервер разрешает запросы с любого origin (`*`) для работы Nuxt dev-сервера на порту 3000.
### Управление состоянием захвата
`CaptureHandler` хранит указатель `active *CaptureState`, который содержит `context.CancelFunc` для остановки текущей сессии. Одновременно может быть только одна активная сессия.
---
## 5. Генератор отчётов (`internal/report`)
### Назначение
Формирование PDF-отчёта по всем накопленным данным.
### Файлы
| Файл | Описание |
|------|----------|
| `pdf.go` | Структура `Data`, функция `Generate(data) ([]byte, error)` |
### Структура отчёта
1. **Заголовок** — название системы, дата формирования, версия
2. **Метаданные сессии** — источник трафика, режим, длительность, объём
3. **Сводка по критичности** — таблица с цветовой маркировкой (критический / высокий / средний / низкий)
4. **Типы угроз** — таблица по типам обнаруженных атак
5. **Топ источников** — 10 наиболее активных IP-адресов
6. **Журнал инцидентов** — детальная таблица до 200 алертов
### Библиотека maroto v2
Grid-based компоновка: страница делится на 12 колонок, строки (`row`) содержат колонки (`col`), в колонках размещаются компоненты (`text`, `line`).
---
## 6. Фронтенд (`frontend/`)
### Назначение
Веб-панель управления для мониторинга, управления захватом и просмотра статистики.
### Структура
| Путь | Назначение |
|------|-----------|
| `pages/index.vue` | Дашборд: карточки метрик, графики, топ IP, последние алерты |
| `pages/alerts.vue` | Журнал алертов с фильтрацией и пагинацией |
| `pages/capture.vue` | Управление захватом (live + PCAP upload), история сессий |
| `pages/stats.vue` | Статистика: timeline, распределение по типам и критичности |
| `layouts/default.vue` | Боковое меню, заголовок, индикатор статуса захвата |
| `composables/useApi.ts` | Базовый HTTP клиент (get, post, del, upload) |
| `composables/useCaptureStatus.ts` | Глобальный polling статуса захвата (каждые 3 сек) |
| `components/MetricCard.vue` | Карточка числовой метрики с иконкой |
| `components/SeverityBadge.vue` | Цветной бейдж уровня критичности |
docs/testing.md
+356
View File
@@ -0,0 +1,356 @@
# Руководство по тестированию
## Подготовка окружения
Для тестирования нужны две машины в одной сети (или две VM), либо одна машина с loopback-интерфейсом.
```
[Машина A — NIDS] [Машина B — Атакующий]
192.168.1.100 192.168.1.200
sudo ./nids nmap / hping3 / hydra
http://localhost:3000
```
**Запуск системы перед каждым тестом:**
```bash
# Терминал 1 — бэкенд
sudo ./nids
# Терминал 2 — фронтенд
cd frontend && bun run dev
# Открыть в браузере: http://localhost:3000
# Перейти на страницу «Захват» → выбрать интерфейс → «Начать захват»
```
---
## Тест 1: Сканирование портов (Port Scan)
**Инструмент:** `nmap`
**Установка:**
```bash
# Debian/Ubuntu
sudo apt install nmap
# Arch
sudo pacman -S nmap
```
**Запуск атаки (с машины B):**
```bash
# SYN-scan — самый распространённый метод сканирования
sudo nmap -sS 192.168.1.100
# Агрессивное сканирование всех портов
sudo nmap -sS -p- --min-rate 1000 192.168.1.100
# Сканирование конкретного диапазона
sudo nmap -sS -p 1-1000 192.168.1.100
```
**Ожидаемый результат:**
```
Тип алерта: port_scan
Критичность: high
Описание: Port scan detected: 15 unique ports probed in 10s window
SrcIP: 192.168.1.200
```
**Что проверить:**
- Алерт появляется в журнале (~10 секунд после начала сканирования)
- SrcIP совпадает с адресом машины B
- Счётчик `Count` отражает количество уникальных портов
**Порог срабатывания:** 15 уникальных портов за 10 секунд (настраивается в `config.yaml`).
---
## Тест 2: Перебор паролей (Brute Force)
**Инструмент:** `hydra` или `medusa`
**Установка:**
```bash
# Debian/Ubuntu
sudo apt install hydra
# Arch
sudo pacman -S hydra
```
**Требование:** на машине A должен быть запущен SSH-сервер:
```bash
sudo systemctl start sshd
```
**Запуск атаки (с машины B):**
```bash
# Brute-force SSH с небольшим словарём
hydra -l root -P /usr/share/wordlists/rockyou.txt \
-t 4 -V ssh://192.168.1.100
# Быстрый тест с inline паролями
hydra -l admin -p pass1,pass2,pass3,pass4,pass5,pass6,pass7,pass8,pass9,pass10,pass11 \
ssh://192.168.1.100
# Только SYN-флуд на порт 22 (без hydra)
sudo hping3 -S -p 22 --flood 192.168.1.100
```
**Ожидаемый результат:**
```
Тип алерта: brute_force
Критичность: critical
Описание: Brute-force detected on port 22: 10 connection attempts in 30s
SrcIP: 192.168.1.200
DstPort: 22
```
**Другие мониторируемые порты:**
```bash
# FTP (21)
hydra -l admin -P wordlist.txt ftp://192.168.1.100
# RDP (3389) — если запущен xrdp
hydra -l administrator -P wordlist.txt rdp://192.168.1.100
# Telnet (23)
hydra -l root -P wordlist.txt telnet://192.168.1.100
```
**Порог срабатывания:** 10 попыток за 30 секунд на один порт.
---
## Тест 3: DoS / DDoS атака
**Инструмент:** `hping3`
**Установка:**
```bash
# Debian/Ubuntu
sudo apt install hping3
# Arch
sudo pacman -S hping3
```
**Запуск атаки (с машины B):**
```bash
# SYN flood — классический DoS
sudo hping3 -S --flood -V -p 80 192.168.1.100
# ICMP flood
sudo hping3 --icmp --flood 192.168.1.100
# UDP flood
sudo hping3 --udp --flood -p 53 192.168.1.100
# С заданной скоростью (1500 пакетов/сек)
sudo hping3 -S -p 80 --faster -c 10000 192.168.1.100
```
**Ожидаемый результат:**
```
Тип алерта: dos
Критичность: critical
Описание: DoS attack detected from 192.168.1.200: 1234 pkt/s (threshold: 1000)
SrcIP: 192.168.1.200
Count: 1234
```
**Проверка без второй машины (loopback):**
```bash
# Флуд на локальный интерфейс (lo)
sudo hping3 -S --flood -V 127.0.0.1
# Бэкенд при этом нужно запустить с захватом на интерфейсе lo
```
**Порог срабатывания:** 1000 пакетов/сек от одного источника.
---
## Тест 4: ARP Spoofing
**Инструмент:** `arpspoof` (пакет `dsniff`) или `ettercap`
**Установка:**
```bash
# Debian/Ubuntu
sudo apt install dsniff
# Arch
sudo pacman -S dsniff
```
**Запуск атаки (с машины B):**
```bash
# Подмена ARP: сообщаем машине A, что мы — шлюз (192.168.1.1)
sudo arpspoof -i eth0 -t 192.168.1.100 192.168.1.1
# Двусторонняя подмена (полный MITM)
# Терминал 1:
sudo arpspoof -i eth0 -t 192.168.1.100 192.168.1.1
# Терминал 2:
sudo arpspoof -i eth0 -t 192.168.1.1 192.168.1.100
```
**Альтернатива — вручную через `arping`:**
```bash
# Отправить ARP Reply с поддельным MAC
sudo arping -c 5 -A -I eth0 192.168.1.100
```
**Ожидаемый результат:**
```
Тип алерта: arp_spoof
Критичность: critical
Описание: ARP spoofing: IP 192.168.1.1 changed MAC from aa:bb:cc:dd:ee:ff to 11:22:33:44:55:66
SrcIP: 192.168.1.1
Protocol: ARP
```
**Важно:** детектор срабатывает только если IP уже известен из предыдущих ARP-пакетов. Первая запись в таблицу — штатная, второй пакет с другим MAC — алерт.
---
## Тест 5: DNS Аномалии
### 5A. DNS-туннелирование
**Инструмент:** `iodine` или ручная генерация
**Установка:**
```bash
# Debian/Ubuntu
sudo apt install iodine
# Arch
sudo pacman -S iodine
```
**Имитация туннелирования вручную (через `dig`):**
```bash
# Запрос с очень длинной меткой (>50 символов) — триггер детектора
dig "aGVsbG8td29ybGQtdGhpcy1pcy1hLXZlcnktbG9uZy1zdWJkb21haW4.example.com" @8.8.8.8
# Скрипт для многократной отправки
for i in $(seq 1 20); do
dig "$(head -c 60 /dev/urandom | base64 | tr -d '\n/' | head -c 55).test.local" &
done
```
**Ожидаемый результат:**
```
Тип алерта: dns_anomaly
Критичность: medium
Описание: DNS tunneling suspected: label length 55 in query 'aGVsbG8t...test.local'
```
### 5B. Высокая частота DNS-запросов
**Инструмент:** `dnsperf` или bash-скрипт
```bash
# Установка dnsperf
sudo apt install dnsperf # Debian/Ubuntu
# Генерация файла запросов
for i in $(seq 1 500); do
echo "host$i.example.com A"
done > /tmp/dns-queries.txt
# Flood (200+ запросов за 60 секунд)
dnsperf -s 8.8.8.8 -d /tmp/dns-queries.txt -Q 50 -l 30
# Простой bash-вариант без dnsperf
for i in $(seq 1 250); do
dig "sub$i.example.com" @8.8.8.8 +short &
done
```
**Ожидаемый результат:**
```
Тип алерта: dns_anomaly
Критичность: medium
Описание: High DNS query rate from 192.168.1.200: 200 queries in 60s
```
---
## Тест через готовые PCAP файлы (без второй машины)
Это самый простой способ протестировать все детекторы одновременно.
**Рекомендуемые источники PCAP:**
| Источник | Описание |
|----------|----------|
| [Wireshark Sample Captures](https://wiki.wireshark.org/SampleCaptures) | Коллекция тестовых захватов |
| [Malware Traffic Analysis](https://www.malware-traffic-analysis.net/) | Реальный вредоносный трафик |
| [NETRESEC](https://www.netresec.com/?page=PcapFiles) | Тематические PCAP с атаками |
| [CTF captures](https://github.com/ctfs) | Захваты с соревнований |
**Скачать конкретные файлы:**
```bash
# Nmap scan capture
wget https://wiki.wireshark.org/SampleCaptures?action=AttachFile&do=get&target=nmap.pcap \
-O test-portscan.pcap
# ARP примеры
wget https://wiki.wireshark.org/SampleCaptures?action=AttachFile&do=get&target=arp-storm.pcap \
-O test-arp.pcap
```
**Использование:**
1. Открыть `http://localhost:3000/capture`
2. Перейти на вкладку **PCAP файл**
3. Перетащить файл → нажать **Анализировать**
4. Алерты появятся в журнале через несколько секунд
---
## Проверка API напрямую (без браузера)
```bash
# Список интерфейсов
curl http://localhost:8080/api/capture/interfaces
# Статус захвата
curl http://localhost:8080/api/capture/status
# Начать захват на eth0
curl -X POST http://localhost:8080/api/capture/start \
-H "Content-Type: application/json" \
-d '{"interface": "eth0"}'
# Все алерты
curl http://localhost:8080/api/alerts | python3 -m json.tool
# Алерты по типу
curl "http://localhost:8080/api/alerts?type=port_scan&page_size=10"
# Сводка статистики
curl http://localhost:8080/api/stats/summary | python3 -m json.tool
# Остановить захват
curl -X POST http://localhost:8080/api/capture/stop
# Скачать PDF отчёт
curl http://localhost:8080/api/reports/generate -o report.pdf
```
---
## Таблица ожидаемых результатов
| Тест | Инструмент | Алерт | Критичность | Время до срабатывания |
|------|------------|-------|-------------|----------------------|
| Port Scan | `nmap -sS` | `port_scan` | high | ~10 сек |
| Brute Force SSH | `hydra` | `brute_force` | critical | ~30 сек |
| SYN Flood | `hping3 --flood` | `dos` | critical | ~1 сек |
| ARP Spoof | `arpspoof` | `arp_spoof` | critical | мгновенно |
| DNS Tunnel | `dig` длинный | `dns_anomaly` | medium | мгновенно |
| DNS Flood | `dnsperf` | `dns_anomaly` | medium | ~60 сек |
docs/user-guide.md
+108
View File
@@ -0,0 +1,108 @@
# Руководство пользователя
## Интерфейс веб-панели
Панель управления доступна по адресу `http://localhost:3000` после запуска фронтенда.
### Боковое меню
| Пункт | Страница | Описание |
|-------|----------|----------|
| Обзор | `/` | Дашборд с метриками и графиками |
| Алерты | `/alerts` | Журнал всех обнаруженных угроз |
| Захват | `/capture` | Управление захватом трафика |
| Статистика | `/stats` | Детальные графики и сводные таблицы |
В нижней части меню — индикатор состояния захвата (зелёный пульс = активен).
---
## Страница «Обзор» (Dashboard)
Главная страница отображает:
**Карточки метрик** — количество алертов по уровню критичности:
- Критический (красный)
- Высокий (оранжевый)
- Средний (жёлтый)
- Низкий (зелёный)
**График «Алерты за 24 часа»** — временная шкала событий с часовой детализацией.
**Диаграмма «Типы атак»** — donut-чарт с распределением по типам угроз.
**Топ источников** — 5 наиболее активных IP-адресов с прогресс-барами.
**Последние инциденты** — 8 последних алертов с описанием. Данные обновляются автоматически каждые 10 секунд.
---
## Страница «Алерты»
### Фильтрация
- **Тип атаки** — Port Scan, Brute Force, DoS/DDoS, ARP Spoof, DNS Anomaly
- **Критичность** — критический, высокий, средний, низкий
- **IP источника** — фильтр по точному совпадению
Нажмите **Найти** для применения фильтров, **Сбросить** — для очистки.
### Таблица алертов
Колонки: Время · Критичность · Тип · Источник · Назначение · Описание
- **Страница** — 25 записей, навигация внизу таблицы
- **Удалить алерт** — кнопка с иконкой корзины в строке
- **Очистить всё** — удаляет все алерты из БД (необратимо)
---
## Страница «Захват»
### Live захват
1. Выберите сетевой интерфейс из выпадающего списка (кнопка ↺ обновляет список)
2. Нажмите **Начать захват**
3. Бэкенд должен быть запущен с правами root (`sudo ./nids`)
4. Для остановки — кнопка **Остановить захват** (в заголовке или на странице)
### Анализ PCAP файла
1. Перейдите на вкладку **PCAP файл**
2. Перетащите `.pcap` или `.pcapng` файл в зону загрузки (или нажмите «Выбрать файл»)
3. Нажмите **Анализировать**
4. После завершения алерты появятся в журнале
### История сессий
Таблица последних 20 сессий захвата: источник, режим, статус, количество пакетов, объём трафика.
---
## Страница «Статистика»
### Период наблюдения
Кнопки: **6ч · 24ч · 2д · 7д** — переключают временной диапазон для всех графиков.
### Графики
- **Динамика алертов** — столбчатая диаграмма по часам
- **По типам атак** — donut с легендой
- **По критичности** — donut с легендой
- **Топ-10 источников** — горизонтальная столбчатая диаграмма
### Сводная таблица
Итоговые числа по критичности и типам атак, общее количество.
---
## Генерация PDF-отчёта
Кнопка **PDF отчёт** доступна в заголовке на любой странице.
Отчёт содержит:
1. Заголовок с датой формирования
2. Метаданные последней сессии
3. Сводку по критичности
4. Таблицу типов угроз
5. Топ-10 источников атак
6. Журнал инцидентов (до 200 записей)
Файл сохраняется как `nids-report-YYYY-MM-DD_HH-MM.pdf`.