Конвейер для обучения модели представлений сетевого трафика на неразмеченных данных: перехват пакетов на 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
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).
Сервер поднимает 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(), чтобы словарь сессий не рос неограниченно при многочасовом захвате.
Ключ сессии — (протокол, каноническая пара 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.
| 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 не читается и на диск не попадает.
WindowBuilder отдаёт окно только когда буфер сессии заполнен целиком (len == max_len == 128), то есть окна неперекрывающиеся, шаг равен длине окна. Такая схема не создаёт почти идентичных соседних примеров и делает объём датасета предсказуемым от длительности захвата.
Ограничения дисбаланса:
min_len = 32— нижняя граница, короче сессии в датасет не попадают;cap_per_session = 500— одна очень долгая сессия (стриминг, телеметрия) не вытесняет остальные;cap_total = 5_000_000— жёсткий предел размера выборки для одного прогона.
На выходе — torch.float32 тензор формы (128, 9) и метка времени последнего пакета окна.
ShardWriter держит окна в памяти до 100 000 штук и затем пишет shard_00000.pt:
{"windows": Tensor(N, 128, 9), "timestamps": Tensor(N)}Шардинг закрывает две задачи. Во-первых, память процесса захвата ограничена размером одного буфера: многочасовой прогон не упирается в RAM и не теряет накопленное при аварии. Во-вторых, запись только добавляется — новые шарды не перезаписывают старые данные, и объём датасета можно наращивать параллельными захватами.
Номер следующего шарда восстанавливается при старте по количеству существующих shard_*.pt, поэтому захват можно останавливать и продолжать без перезаписи (исправление в последней ревизии истории). Буфер сбрасывается на диск и по требованию — в обработчике SIGTERM.
ShardIterableDataset — IterableDataset с ленивой загрузкой: torch.load вызывается по одному шарду за раз, поэтому память ограничена размером одного шарда, а не всего датасета, и загрузка идёт внахлёст с обучением.
Сплит выполняется по шардам (train_ratio = 0.8), а не по окнам. Окна одной сессии перекрываются во времени и описывают один и тот же поток, поэтому попадание соседних окон в разные части выборки давало бы утечку.
Перемешивание двухуровневое: целиком перемешивается порядок шардов, а внутри шарда — буферизованное перемешивание окон (буфер ограниченного размера, из него извлекается случайный элемент). Это компромисс между степенью перемешивания и потреблением памяти: полное перемешивание потребовало бы держать весь датасет в RAM.
При num_workers > 0 шарды раздаются воркерам как shards[worker_id::num_workers] — каждый воркер читает свой непересекающийся поднабор, повторного чтения нет.
Наружу отдаётся {"input": (128, 9), "timestamp": float} — метка времени сохраняется в выборке и доступна для последующих задач, не разрушая текущую схему.
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.
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().
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 из требований в текущем коде не используются.