Skip to content

Latest commit

 

History

History
287 lines (203 loc) · 30.8 KB

README.md

File metadata and controls

287 lines (203 loc) · 30.8 KB

NetAI

Конвейер для обучения модели представлений сетевого трафика на неразмеченных данных: перехват пакетов на C++/libpcap → компактный бинарный протокол через UNIX-сокет → сессионная агрегация → 9 признаков на пакет → тензорные окна → шардированное хранилище → рекуррентная модель на PyTorch.

Задача — построить представление потока трафика без ручной разметки: окно из последовательности пакетов кодируется рекуррентной сетью в скрытое состояние, поверх которого обучается реконструкционная голова. Латентное состояние и ошибка реконструкции — база для детекции аномалий и классификации типов трафика.

Схема работы

        libpcap  ──►  packet_parser.hpp ──► NetworkEventMsg (23 байта, #pragma pack(1))
  src/capture/cpp                              │  один write() в AF_UNIX / SOCK_STREAM
                                               ▼
                                  socket_receiver.py
                                  struct.unpack("=d II HHH B")
                                               │
                                               ▼
                        SessionManager ──► SessionState (deque(maxlen=128))
                        ключ: (протокол, каноническая пара endpoint'ов)
                                               │  FeatureExtractor → 9 float на пакет
                                               ▼
                        WindowBuilder  (128 пакетов = 1 окно, без перекрытия)
                                               │
                                               ▼
                        ShardWriter ──► data/raw/shard_00000.pt … (100 000 окон)
                                               │
                                               ▼
        ShardIterableDataset ──► StatsCollector ──► NetAI (LSTM + реконструкция)
        ленивый пошардовый       mean/std во        StandardizationLayer
        IterableDataset          float64            на борде модели

Структура репозитория

src/
├── capture/
│   ├── cpp/
│   │   ├── sniffer.cpp        захват libpcap, цикл pcap_dispatch, сигналы
│   │   ├── packet_parser.hpp  разбор Ethernet/IPv4/TCP/UDP/ICMP из сырых байт
│   │   ├── event_sender.hpp   AF_UNIX-клиент, сериализация события
│   │   └── CMakeLists.txt     C++17, -O2 -Wall -Wextra, линковка libpcap
│   └── socket_receiver.py     приёмник: сокет → события → окна → шарды на диск
├── network/
│   ├── types.py               ProtocolType, Endpoint, SessionKey
│   └── network_event.py       NetworkEvent + построение ключа сессии
├── session/
│   ├── session_manager.py     жизненный цикл сессий, направление, таймауты
│   ├── session_state.py       состояние сессии и буфер фиксированной длины
│   └── session_event.py       пакет + производные признаки момента
├── features/
│   ├── constants.py           FEATURE_DIM = 9
│   ├── features.py            модули признаков (typing.Protocol)
│   └── feature_extractor.py   композиция модулей в вектор фиксированной длины
├── data/
│   ├── window_builder.py      нарезка окон + ограничения дисбаланса
│   ├── shard_writer.py        запись шардов, возобновление индекса
│   ├── shard_dataset.py       IterableDataset со сплитом и multi-worker
│   └── stats.py               проходные mean/std во float64
├── models/
│   ├── backbone.py            LSTM + кастомная инициализация
│   ├── netai_model.py         NetAI: backbone + ModuleDict голов
│   └── standardization.py     нормализация непрерывных признаков на борде модели
└── training/
    └── train.py               гиперпараметры и compute_stats

1. Захват трафика (C++ / libpcap)

sniffer.cpp открывает интерфейс в promiscuous-режиме и работает пакетно, без выделения памяти на каждый кадр:

  • pcap_open_live(iface, 65535, 1, 1, errbuf) — полный snaplen, promisc, таймаут опроса 1 мс;
  • BPF-фильтр ставится через pcap_compile / pcap_setfilter (по умолчанию ip), поэтому отсечение выполняется ещё в ядре до копирования в userspace;
  • основной цикл — pcap_dispatch(handle, 64, ...), обработка пачкой по 64 пакета.

Параметры передаются позиционно: sniffer [iface] [socket_path] [bpf_filter], значения по умолчанию — br0, /tmp/netai.sock, ip.

Разбор заголовков (packet_parser.hpp) делается вручную по указателям в буфер кадра, без аллокаций и без копирования payload: сдвиг на 14 байт Ethernet, проверка ip_v == 4, длина IP-заголовка из ip_hl, ветвление по ip_p на TCP/UDP/ICMP/OTHER, порты через ntohs. ICMP и прочие протоколы дают событие с нулевыми портами. Все проверки границ (caplen) стоят до обращения к полям.

Формат события — фиксированные 23 байта без выравнивания:

#pragma pack(push, 1)
struct NetworkEventMsg {
    double   timestamp;   // 8  — секунды с дробной частью (ts.tv_sec + ts.tv_usec*1e-6)
    uint32_t src_ip;      // 4  — сетевой порядок
    uint32_t dst_ip;      // 4
    uint16_t src_port;    // 2
    uint16_t dst_port;    // 2
    uint16_t size;        // 2  — caplen кадра
    uint8_t  protocol;    // 1  — 0=TCP 1=UDP 2=ICMP 3=OTHER
};                        // итого 23 байта
#pragma pack(pop)

На событие приходится ровно один write() фиксированного размера — для потока AF_UNIX это атомарная передача, поэтому получатель не может прочитать половину записи.

Устойчивость транспорта: EventSender::connect() блокирующий, до 30 попыток с интервалом в секунду — сниффер можно стартовать раньше приёмника. Если получатель пропал, send() возвращает false, сниффер пишет ошибку и останавливается, вместо того чтобы терять события молча. SIGINT/SIGTERM выставляют atomic<bool> g_running, после чего корректно вызываются pcap_freecode и pcap_close.

Сборка — CMake ≥ 3.16, C++17, find_library(pcap REQUIRED).

2. Приём событий (Python)

Сервер поднимает AF_UNIX / SOCK_STREAM сокет, удаляет остатки старого файла сокета, слушает один backlog и работает во внешнем бесконечном цикле accept() — после разрыва соединения сокет остаётся слушающим, и сниффер можно перезапустить без перезапуска приёмника.

Распаковка симметрична C++-структуре:

MSG_FORMAT = "=d II HHH B"   # 23 байта, нативный порядок и размеры
MSG_SIZE   = struct.calcsize(MSG_FORMAT)

Размер вычисляется в рантайме, а не зашит числом, поэтому изменение полей в C++ не требует ручной правки константы — при несовпадении чтение сдвинется и станет видно по мусору в данных. Префикс = отключает выравнивание, что соответствует #pragma pack(1).

Отдельная функция recv_exact() дочитывает ровно 23 байта, поэтому частичные чтения и фрагментация потока не приводят к потере синхронизации. IP преобразуется через inet_ntoa, порт 0 (ICMP) превращается в None и в ключе сессии даёт endpoint без порта.

Корректное завершение: SIGINT/SIGTERM → flush несохранённого буфера на диск, закрытие сокета, удаление файла сокета. Каждые 5000 окон вызывается manager.cleanup(), чтобы словарь сессий не рос неограниченно при многочасовом захвате.

3. Сессионная агрегация

Ключ сессии — (протокол, каноническая пара endpoint'ов), где endpoint это ip:port либо ip, если порта нет. Эндпоинты сортируются, поэтому сессия двусторонняя: трафик A→B и B→A попадает в одну сессию и учитывает взаимное направление, а не распадается на два независимых потока.

SessionState хранит deque(maxlen) накопленных векторов признаков, start_time, last_seen, last_direction, total_bytes и packet_count. Постоянная длина буфера означает, что память на сессию не растёт со временем — это принципиально для долгого захвата.

SessionEvent — пакет плюс три производные величины, которые нельзя получить из самого пакета:

  • is_first — первый пакет сессии;
  • direction_changed — сменилось ли направление относительно предыдущего пакета;
  • delay — timestamp - last_seen, интервал внутри сессии.

Направление определяется относительно канонического (лексикографически отсортированного) порядка эндпоинтов, а не относительно «кто пришёл первым»: признак инвариантен к порядку поступления данных. Устаревшие сессии вытесняются по таймауту (60 с по умолчанию) относительно last_seen.

4. Признаки: 9 измерений на пакет

idx Признак Тип Модуль
0 размер кадра / 1500 непрерывный PacketSizeFeature
1–4 one-hot протокола TCP / UDP / ICMP / OTHER бинарный ProtocolOneHotFeature
5 направление относительно канонической пары бинарный DirectionFeature
6 первый пакет сессии бинарный RelativityFeature
7 смена направления бинарный RelativityFeature
8 log1p(delay) — задержка с предыдущего пакета сессии непрерывный RelativityFeature

Каждый модуль реализует структурный протокол FeatureModule (typing.Protocol), а FeatureExtractor разворачивает фиксированный кортеж модулей и конкатенирует их выходы. Добавление признака — это один класс и одна строка в кортеже; порядок признаков при этом стабилен, а FEATURE_DIM проверяется моделями.

Нормализация встроена в извлечение: размер делится на 1500 (характерный MTU), задержка проходит через log1p. Это снимает разброс масштабов и сжимает тяжёлый хвост межпакетных интервалов (характерный для фонового и интерактивного трафика) в одной операции; в датасет попадают уже нормированные значения.

Из содержимого пакетов берутся только метаданные заголовков (адреса, порты, протокол, размер, время) — payload не читается и на диск не попадает.

5. Нарезка окон

WindowBuilder отдаёт окно только когда буфер сессии заполнен целиком (len == max_len == 128), то есть окна неперекрывающиеся, шаг равен длине окна. Такая схема не создаёт почти идентичных соседних примеров и делает объём датасета предсказуемым от длительности захвата.

Ограничения дисбаланса:

  • min_len = 32 — нижняя граница, короче сессии в датасет не попадают;
  • cap_per_session = 500 — одна очень долгая сессия (стриминг, телеметрия) не вытесняет остальные;
  • cap_total = 5_000_000 — жёсткий предел размера выборки для одного прогона.

На выходе — torch.float32 тензор формы (128, 9) и метка времени последнего пакета окна.

6. Хранилище шардов

ShardWriter держит окна в памяти до 100 000 штук и затем пишет shard_00000.pt:

{"windows": Tensor(N, 128, 9), "timestamps": Tensor(N)}

Шардинг закрывает две задачи. Во-первых, память процесса захвата ограничена размером одного буфера: многочасовой прогон не упирается в RAM и не теряет накопленное при аварии. Во-вторых, запись только добавляется — новые шарды не перезаписывают старые данные, и объём датасета можно наращивать параллельными захватами.

Номер следующего шарда восстанавливается при старте по количеству существующих shard_*.pt, поэтому захват можно останавливать и продолжать без перезаписи (исправление в последней ревизии истории). Буфер сбрасывается на диск и по требованию — в обработчике SIGTERM.

7. Датасет

ShardIterableDataset — IterableDataset с ленивой загрузкой: torch.load вызывается по одному шарду за раз, поэтому память ограничена размером одного шарда, а не всего датасета, и загрузка идёт внахлёст с обучением.

Сплит выполняется по шардам (train_ratio = 0.8), а не по окнам. Окна одной сессии перекрываются во времени и описывают один и тот же поток, поэтому попадание соседних окон в разные части выборки давало бы утечку.

Перемешивание двухуровневое: целиком перемешивается порядок шардов, а внутри шарда — буферизованное перемешивание окон (буфер ограниченного размера, из него извлекается случайный элемент). Это компромисс между степенью перемешивания и потреблением памяти: полное перемешивание потребовало бы держать весь датасет в RAM.

При num_workers > 0 шарды раздаются воркерам как shards[worker_id::num_workers] — каждый воркер читает свой непересекающийся поднабор, повторного чтения нет.

Наружу отдаётся {"input": (128, 9), "timestamp": float} — метка времени сохраняется в выборке и доступна для последующих задач, не разрушая текущую схему.

8. Статистики и стандартизация

StatsCollector считает mean и std за один проход по обучающей выборке, накапливая sum и sum_sq во float64 и восстанавливая дисперсию по формуле E[x²] − E[x]². Промежуточные суммы для признаков вида «размер / 1500» достигают порядка 1e6 при count в миллионы, и во float32 дисперсия теряла бы точность до того, как её посчитают; float64 накопление снимает этот риск при нулевой цене по времени. Дисперсия клампится снизу на 1e-8, чтобы вырожденный признак не дал деления на ноль.

Стандартизуются только непрерывные признаки (CONTINUOUS_INDICES = [0, 8]). One-hot и бинарные признаки остаются 0/1 — иначе они перестают быть интерпретируемыми как индикаторы.

StandardizationLayer — nn.Module, в котором mean, std и continuous_indices зарегистрированы как буферы. Статистика автоматически попадает в state_dict и едет вместе с чекпойнтом, нормализация выполняется на лету в forward на копии входа (x.clone()), затрагивая только непрерывные столбцы. Модуль не добавляет обучаемых параметров и не меняет состояние входного тензора, поэтому один и тот же объект NetAI корректно работает в train и eval.

9. Модель

LSTMBackbone — nn.LSTM(input_dim=9, hidden_dim=256, num_layers=2, dropout=0.2), однонаправленная, batch_first=True.

Кастомная инициализация параметров под структуру LSTM:

  • weight_ih — xavier_uniform, чтобы на старте разброс активаций был умеренным;
  • weight_hh — orthogonal, что сохраняет норму градиента по времени и не даёт ему ни взрываться, ни затухать на длинных последовательностях;
  • bias — ноль.

forward возвращает и выходные активации (B, T, H), и пару состояний (h, c), поэтому состояние можно переносить между батчами и использовать в генеративном режиме, а не обучать каждое окно «с нуля». Аргументы и формы тензоров валидируются с явными ValueError; при num_layers < 2 выдаётся предупреждение, что dropout в nn.LSTM в этом случае не применяется.

NetAI объединяет backbone и heads: nn.ModuleDict. Сейчас в словаре одна голова — реконструкция Linear(256 → 9), то есть модель учится сжимать последовательность пакетов в скрытое состояние и восстанавливать признаки из него. Такая постановка не требует меток, что и позволяет обучаться на сыром трафике; заточенная под конкретную задачу голова добавляется в heads отдельной строкой, не затрагивая остальной код.

FEATURE_DIM и слой стандартизации подключаются до backbone: forward сначала применяет self.standardization (если он задан), затем подаёт тензор в LSTM, поэтому модель получает уже нормированные данные, а при смене датасета достаточно пересчитать mean/std и положить их в модель. По умолчанию поле standardization равно None — это сделано намеренно: модель можно использовать и без нормализации, а статистика добавляется явно из выхода compute_stats().

10. Обучение

train.py содержит конфигурацию прогона (BATCH_SIZE = 128, EPOCHS = 10, LR = 10e-3, NUM_WORKERS = 4, FEATURE_DIM, индексы непрерывных признаков) и функцию compute_stats(), которая прогоняет обучающую выборку для расчёта статистик перед обучением. Каталоги data/processed и checkpoints создаются на импорте. Батчинг опирается на стандартный DataLoader поверх IterableDataset, поэтому подготовка данных не блокирует обучение.

Проектные решения

Решение Причина
Разбор пакетов на C++/libpcap, а не на Python Трафик на порядки быстрее Python; в userspace остаётся минимум работы — только запись фиксированного блока в сокет
AF_UNIX / SOCK_STREAM вместо TCP-порта или очередей Нет портов и сетевого стека, передача локальная и в пределах ядра; фиксированная длина записи снимает вопросы с фрагментацией на стороне получателя
Один write() на событие фиксированного размера Исключает частичные записи и полупрочитанные события, минимальный код на стороне Python
Длина структуры вычисляется через struct.calcsize Синхронизация формата с C++ не опирается на константу, а проверяется самим unpack
Бинарный формат вместо JSON/текста 23 байта на пакет и отсутствие парсинга/аллокаций на горячем пути
Метаданные заголовков без payload Минимизация объёма и исключение утечки содержимого передаваемых данных
Сессии с двусторонним ключом Сохраняет структуру «запрос — ответ», без которой временная динамика теряется
deque(maxlen) в состоянии сессии Память на сессию ограничена, поведение предсказуемо на многочасовом захвате
Окна без перекрытия (шаг = длина окна) Нет почти дублирующихся соседних примеров, предсказуемый размер выборки
Лимиты на сессии и на весь датасет Защита от перекоса: одна длительная сессия не должна определять обучение
Шардирование с нумерацией по существующим файлам Захват возобновляем, данные только дописываются, потеря не приводит к перезаписи
IterableDataset с пошардовым сплитом Память ограничена шардом, ленивая загрузка, сплит без утечки между соседними окнами
float64 для накопления статистик Дисперсия не теряет точность на больших выборках
Ортогональная инициализация weight_hh Стабильность градиента на длинных последовательностях
Отдельный requirements-capture.txt Машина захвата тянет только CPU-сборку PyTorch: там нужен torch для создания тензоров, а не для обучения

Масштабирование и ограничения

  • Поток захвата: 1 сниффер → 1 приёмник, один backlog. Несколько интерфейсов запускаются отдельными экземплярами (файл сокета и каталог шардов задаются аргументами), что позволяет параллельно собирать трафик с нескольких точек.
  • Потребление памяти приёмника ограничено буфером шарда (100 000 окон) и числом активных сессий, из которых устаревшие вытесняются каждые 5000 окон.
  • Потребление памяти при обучении ограничено размером одного шарда независимо от num_workers.
  • Размер выборки ограничен cap_total = 5 000 000 окон на прогон.
  • Классификация выполняется по протоколу и адресам/портам; приложения с одинаковыми метаданными сливаются в одну сессию.

Состояние проекта

Готово: захват на libpcap с ручным разбором заголовков; бинарный транспорт и приёмник с устойчивостью к разрывам; сессионная агрегация и очистка по таймауту; извлечение 9 признаков композиционными модулями; нарезка неперекрывающихся окон с ограничениями дисбаланса; шардированное хранилище с возобновлением; ленивый датасет со сплитом и раздачей шардов воркерам; проходные статистики и слой нормализации на борде модели; LSTM-backbone с собственной инициализацией и реконструкционная голова.

В работе: цикл обучения в src/training/train.py — на текущий момент в модуле есть конфигурация и compute_stats(); обучение на собранных шардах, метрики и логирование, чекпойнты и загрузка для инференса ещё не реализованы.

Планируется: собственный датасет для оценки качества, метрики (включая ошибку реконструкции как скор аномалии), экспорт модели для инференса.

Запуск

Зависимости:

pip install -r requirements.txt
# на машине захвата достаточно CPU-сборки PyTorch:
pip install -r requirements-capture.txt

Сборка и запуск сниффера (нужны libpcap-dev и права на чтение интерфейса):

cd src/capture/cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
sudo ./build/sniffer br0 /tmp/netai.sock ip

Приём событий и запись шардов:

python -m src.capture.socket_receiver
# данные: data/raw/shard_00000.pt …

Обучение (после появления цикла в src/training/train.py):

python -m src.training.train

Стек

Ядро проекта: C++17 + libpcap + CMake (захват) и Python + PyTorch (приём, признаки, хранилище, модель, torch.utils.data). Бинарный транспорт — UNIX domain sockets и struct.

requirements.txt также фиксирует окружение для анализа и сравнения: NumPy, SciPy, pandas, pyarrow, scikit-learn, XGBoost, matplotlib, seaborn, tqdm, joblib. Важная деталь: в самом конвейере импортируется только torch и стандартная библиотека — разбор пакетов выполняет C++-часть, поэтому scapy и dpkt из требований в текущем коде не используются.