netreplay 0.1.0__tar.gz

netreplay-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NetReplay contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

netreplay-0.1.0/PKG-INFO

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: netreplay
+Version: 0.1.0
+Summary: NetReplay - network traffic time machine. Capture, analyze and replay network traffic as a story.
+Author: NetReplay
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/arbuztratil-design/NetReplay
+Project-URL: Repository, https://github.com/arbuztratil-design/NetReplay
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scapy>=2.5
+Requires-Dist: cryptography>=42
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn>=0.29
+Requires-Dist: websockets>=12.0
+Requires-Dist: typer>=0.12
+Requires-Dist: flet>=0.86
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# NetReplay
+
+Машина времени для сетевого трафика. Захват → разбор → анализ потоков →
+временная линия → «перемотка» событий обратно.
+
+MVP: `netreplay capture` собирает трафик в файл `.nrp`, `netreplay timeline`
+показывает его как читаемую историю, `netreplay replay` воспроизводит события
+с реалистичными паузами, а `netreplay serve` + `netreplay gui` дают REST/WebSocket
+API и оконный клиент.
+
+## Возможности
+
+- Захват пакетов через Scapy (на Windows требуется Npcap).
+- Разбор Ethernet / IPv4 / IPv6 / TCP / UDP / ARP / DNS / TLS: SNI, версии TLS,
+  DNS query/response.
+- Офлайн-расшифровка TLS 1.2 (AES-128/256-GCM, PRF SHA-256/SHA-384) из
+  внешнего SSLKEYLOGFILE: расшифрованные прикладные данные попадают в таймлайн
+  как события `DECRYPT`.
+- Потоки: нормализованный 5-tuple, TCP state machine
+  (SYN → SYN/ACK → ESTABLISHED → FIN → CLOSED, RST).
+- Timeline-события: старт потока, переходы TCP, DNS, TLS, DECRYPT — с фильтрами
+  по времени, типам и потоку.
+- Собственный формат `.nrp` — versioned SQLite (magic `NREP`, v1), WAL,
+  payload отдельными 64 КБ-чанками в `raw_blocks`.
+- API: REST + WebSocket (live-события захвата), GUI как чистый клиент API.
+
+## Установка
+
+```powershell
+pip install -e .
+```
+
+На Windows для живого захвата установите [Npcap](https://npcap.com)
+(с опцией «WinPcap API–compatible Mode»). Без него `netreplay capture`
+завершится с понятной ошибкой.
+
+## Использование
+
+```powershell
+# Список интерфейсов
+netreplay interfaces
+
+# Живой захват 10 секунд
+netreplay capture -i "Ethernet" -o capture.nrp -d 10
+
+# Метаданные, потоки и временная линия
+netreplay inspect capture.nrp
+netreplay flows capture.nrp
+netreplay timeline capture.nrp
+netreplay timeline capture.nrp --types TCP,TLS --limit 50
+
+# Исторический реплей с ускорением x50
+netreplay replay capture.nrp --speed 50
+
+# Список сессий в workspace (переменная окружения NETREPLAY_WORKSPACE,
+# по умолчанию ./netreplay_data)
+netreplay sessions
+
+# Импорт и анализ существующего PCAP/PCAPNG без захвата
+netreplay import-pcap dump.pcap -o dump.nrp
+
+# REST + WebSocket API и GUI
+netreplay serve            # http://127.0.0.1:8000, документация /docs
+netreplay gui              # в отдельном терминале; подключится к API
+```
+
+Быстрая проверка без сети: в папке `examples/` лежит готовый `demo.nrp`
+(11 пакетов: DNS, TCP handshake, TLS, завершение соединения).
+
+```powershell
+netreplay timeline examples/demo.nrp
+```
+
+Офлайн-импорт: `netreplay import-pcap` прогоняет `.pcap`/`.pcapng` через
+тот же пайплайн (разбор → потоки → события → `.nrp`), что и живой захват.
+Результат открывается любыми обычными командами: `flows`, `timeline`,
+`replay`, `serve`/`gui`.
+
+Расшифровка TLS в офлайн-режиме: если передан файл ключей SSLKEYLOGFILE
+(строки `CLIENT_RANDOM`), TLS 1.2 соединения (AES-128/256-GCM, SHA-256/SHA-384)
+расшифровываются и публикуются в таймлайн как события `DECRYPT` с
+превью прикладных данных (например, начала HTTP-запроса/ответа). Такой
+файл умеют отдавать curl, OpenSSL и браузеры через переменную окружения
+`SSLKEYLOGFILE`.
+
+```powershell
+netreplay import-pcap dump.pcap -o dump.nrp --keylog keys.log
+```
+
+## Архитектура
+
+```
+netreplay/
+  core/                     # вся логика, без наружных зависимостей
+    packets/parser.py       # Scapy -> ParsedPacket
+    protocols/dns.py, tls.py
+    protocols/decrypt.py    # TLS 1.2 AES-GCM расшифровка (keylog) + key-block PRF
+    protocols/decrypt_service.py  # пост-проход по .nrp -> события DECRYPT
+    flows/tracker.py        # нормализация 5-tuple, TCP state machine
+    storage/database.py     # SQLite-хранилище сессий
+    storage/nrp.py          # формат .nrp: magic, версия, чанки
+    timeline/service.py     # события + timeline + replay
+    capture/scapy_backend.py
+    capture/pcap_backend.py # офлайн-источник: PCAP/PCAPNG -> CapturedPacket
+    service.py              # CaptureController, NetReplayService, import_pcap
+  api/                      # FastAPI: REST + WebSocket, схемы
+  cli/main.py               # Typer-команды (используют Core)
+gui/                        # Flet-клиент, данные только через API
+tests/                      # pytest (Windows: + реальный TLS 1.2 handshake
+                            # через OpenSSL DLL и проверка расшифровки)
+```
+
+Правила разделения:
+- GUI не трогает захват, хранилище и внутренние структуры — только API.
+- CLI не дублирует логику Core (разбор, потоки, timeline) — только вызывает её.
+- Core не зависит от FastAPI/Typer/Flet.
+- `PcapBackend` реализует тот же `CaptureBackend`, что и `ScapyBackend`,
+  поэтому офлайн-импорт переиспользует пайплайн без изменений.
+
+## API
+
+- `GET /sessions`, `GET /sessions/{id}`, `GET /sessions/{id}/timeline`,
+  `GET /sessions/{id}/flows`
+- `GET /flows/{id}`, `GET /packets/{id}` (с `?raw=true` — hex payload)
+- `POST /capture/start`, `POST /capture/stop`, `GET /capture/status`,
+  `GET /interfaces`
+- `WS /ws` — пульс и live-события захвата:
+  `{"type":"event","timestamp":...,"flow_id":...,"protocol":"TCP","summary":"..."}`
+
+## Тестирование
+
+```powershell
+python -m pytest tests -q
+```
+
+## Roadmap (после MVP)
+
+- ~~Офлайн-анализ существующих PCAP без захвата~~ — `netreplay import-pcap`.
+- ~~Отложенная расшифровка TLS (внешний кейлог-файл)~~ — `--keylog`.
+- TLS 1.3, CBC/ChaCha20-сьюты, проверка Finished-сообщений.
+- Перехват и обратная инъекция пакетов (replay-out).
+- Векторы похожести/поиск по домену и IP в `inspect`.
+- Модульный CLI-бэкенд (Mock/PCAP-файл) без изменения ядра.

netreplay-0.1.0/README.md

@@ -0,0 +1,143 @@
+# NetReplay
+
+Машина времени для сетевого трафика. Захват → разбор → анализ потоков →
+временная линия → «перемотка» событий обратно.
+
+MVP: `netreplay capture` собирает трафик в файл `.nrp`, `netreplay timeline`
+показывает его как читаемую историю, `netreplay replay` воспроизводит события
+с реалистичными паузами, а `netreplay serve` + `netreplay gui` дают REST/WebSocket
+API и оконный клиент.
+
+## Возможности
+
+- Захват пакетов через Scapy (на Windows требуется Npcap).
+- Разбор Ethernet / IPv4 / IPv6 / TCP / UDP / ARP / DNS / TLS: SNI, версии TLS,
+  DNS query/response.
+- Офлайн-расшифровка TLS 1.2 (AES-128/256-GCM, PRF SHA-256/SHA-384) из
+  внешнего SSLKEYLOGFILE: расшифрованные прикладные данные попадают в таймлайн
+  как события `DECRYPT`.
+- Потоки: нормализованный 5-tuple, TCP state machine
+  (SYN → SYN/ACK → ESTABLISHED → FIN → CLOSED, RST).
+- Timeline-события: старт потока, переходы TCP, DNS, TLS, DECRYPT — с фильтрами
+  по времени, типам и потоку.
+- Собственный формат `.nrp` — versioned SQLite (magic `NREP`, v1), WAL,
+  payload отдельными 64 КБ-чанками в `raw_blocks`.
+- API: REST + WebSocket (live-события захвата), GUI как чистый клиент API.
+
+## Установка
+
+```powershell
+pip install -e .
+```
+
+На Windows для живого захвата установите [Npcap](https://npcap.com)
+(с опцией «WinPcap API–compatible Mode»). Без него `netreplay capture`
+завершится с понятной ошибкой.
+
+## Использование
+
+```powershell
+# Список интерфейсов
+netreplay interfaces
+
+# Живой захват 10 секунд
+netreplay capture -i "Ethernet" -o capture.nrp -d 10
+
+# Метаданные, потоки и временная линия
+netreplay inspect capture.nrp
+netreplay flows capture.nrp
+netreplay timeline capture.nrp
+netreplay timeline capture.nrp --types TCP,TLS --limit 50
+
+# Исторический реплей с ускорением x50
+netreplay replay capture.nrp --speed 50
+
+# Список сессий в workspace (переменная окружения NETREPLAY_WORKSPACE,
+# по умолчанию ./netreplay_data)
+netreplay sessions
+
+# Импорт и анализ существующего PCAP/PCAPNG без захвата
+netreplay import-pcap dump.pcap -o dump.nrp
+
+# REST + WebSocket API и GUI
+netreplay serve            # http://127.0.0.1:8000, документация /docs
+netreplay gui              # в отдельном терминале; подключится к API
+```
+
+Быстрая проверка без сети: в папке `examples/` лежит готовый `demo.nrp`
+(11 пакетов: DNS, TCP handshake, TLS, завершение соединения).
+
+```powershell
+netreplay timeline examples/demo.nrp
+```
+
+Офлайн-импорт: `netreplay import-pcap` прогоняет `.pcap`/`.pcapng` через
+тот же пайплайн (разбор → потоки → события → `.nrp`), что и живой захват.
+Результат открывается любыми обычными командами: `flows`, `timeline`,
+`replay`, `serve`/`gui`.
+
+Расшифровка TLS в офлайн-режиме: если передан файл ключей SSLKEYLOGFILE
+(строки `CLIENT_RANDOM`), TLS 1.2 соединения (AES-128/256-GCM, SHA-256/SHA-384)
+расшифровываются и публикуются в таймлайн как события `DECRYPT` с
+превью прикладных данных (например, начала HTTP-запроса/ответа). Такой
+файл умеют отдавать curl, OpenSSL и браузеры через переменную окружения
+`SSLKEYLOGFILE`.
+
+```powershell
+netreplay import-pcap dump.pcap -o dump.nrp --keylog keys.log
+```
+
+## Архитектура
+
+```
+netreplay/
+  core/                     # вся логика, без наружных зависимостей
+    packets/parser.py       # Scapy -> ParsedPacket
+    protocols/dns.py, tls.py
+    protocols/decrypt.py    # TLS 1.2 AES-GCM расшифровка (keylog) + key-block PRF
+    protocols/decrypt_service.py  # пост-проход по .nrp -> события DECRYPT
+    flows/tracker.py        # нормализация 5-tuple, TCP state machine
+    storage/database.py     # SQLite-хранилище сессий
+    storage/nrp.py          # формат .nrp: magic, версия, чанки
+    timeline/service.py     # события + timeline + replay
+    capture/scapy_backend.py
+    capture/pcap_backend.py # офлайн-источник: PCAP/PCAPNG -> CapturedPacket
+    service.py              # CaptureController, NetReplayService, import_pcap
+  api/                      # FastAPI: REST + WebSocket, схемы
+  cli/main.py               # Typer-команды (используют Core)
+gui/                        # Flet-клиент, данные только через API
+tests/                      # pytest (Windows: + реальный TLS 1.2 handshake
+                            # через OpenSSL DLL и проверка расшифровки)
+```
+
+Правила разделения:
+- GUI не трогает захват, хранилище и внутренние структуры — только API.
+- CLI не дублирует логику Core (разбор, потоки, timeline) — только вызывает её.
+- Core не зависит от FastAPI/Typer/Flet.
+- `PcapBackend` реализует тот же `CaptureBackend`, что и `ScapyBackend`,
+  поэтому офлайн-импорт переиспользует пайплайн без изменений.
+
+## API
+
+- `GET /sessions`, `GET /sessions/{id}`, `GET /sessions/{id}/timeline`,
+  `GET /sessions/{id}/flows`
+- `GET /flows/{id}`, `GET /packets/{id}` (с `?raw=true` — hex payload)
+- `POST /capture/start`, `POST /capture/stop`, `GET /capture/status`,
+  `GET /interfaces`
+- `WS /ws` — пульс и live-события захвата:
+  `{"type":"event","timestamp":...,"flow_id":...,"protocol":"TCP","summary":"..."}`
+
+## Тестирование
+
+```powershell
+python -m pytest tests -q
+```
+
+## Roadmap (после MVP)
+
+- ~~Офлайн-анализ существующих PCAP без захвата~~ — `netreplay import-pcap`.
+- ~~Отложенная расшифровка TLS (внешний кейлог-файл)~~ — `--keylog`.
+- TLS 1.3, CBC/ChaCha20-сьюты, проверка Finished-сообщений.
+- Перехват и обратная инъекция пакетов (replay-out).
+- Векторы похожести/поиск по домену и IP в `inspect`.
+- Модульный CLI-бэкенд (Mock/PCAP-файл) без изменения ядра.

netreplay-0.1.0/gui/__init__.py

@@ -0,0 +1,10 @@
+"""Flet GUI - the NetReplay desktop client.
+
+The GUI is a pure API client: it does not parse packets, capture traffic or
+touch the store. All data comes from the NetReplay REST API + WebSocket.
+"""
+from gui.main import main
+
+import netreplay  # noqa: F401  (ensure package is on path)
+
+__all__ = ["main"]

netreplay-0.1.0/gui/api.py

@@ -0,0 +1,81 @@
+"""Thin HTTP client for the NetReplay API."""
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+
+class ApiError(Exception):
+    pass
+
+
+class NetReplayClient:
+    def __init__(self, base_url: str):
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(
+            timeout=httpx.Timeout(10.0, connect=3.0), trust_env=False
+        )
+
+    def _get(self, path: str, **params: Any) -> Any:
+        try:
+            resp = self._client.get(f"{self.base_url}{path}", params=params)
+            resp.raise_for_status()
+            return resp.json()
+        except httpx.HTTPError as exc:
+            raise ApiError(f"GET {path}: {exc}") from exc
+
+    def _post(self, path: str, body: Any | None = None) -> Any:
+        try:
+            resp = self._client.post(f"{self.base_url}{path}", json=body or {})
+            resp.raise_for_status()
+            return resp.json()
+        except httpx.HTTPError as exc:
+            raise ApiError(f"POST {path}: {exc}") from exc
+
+    def interfaces(self) -> list[dict]:
+        return self._get("/api/interfaces")
+
+    def sessions(self) -> list[dict]:
+        return self._get("/api/sessions")
+
+    def session(self, session_id: str) -> dict:
+        return self._get(f"/api/sessions/{session_id}")
+
+    def timeline(
+        self,
+        session_id: str,
+        start: float | None = None,
+        end: float | None = None,
+        flow_id: int | None = None,
+        limit: int = 2000,
+    ) -> list[dict]:
+        params = {}
+        if start is not None:
+            params["start"] = start
+        if end is not None:
+            params["end"] = end
+        if flow_id is not None:
+            params["flow_id"] = flow_id
+        params["limit"] = limit
+        return self._get(f"/api/sessions/{session_id}/timeline", **params)
+
+    def flows(self, session_id: str) -> list[dict]:
+        return self._get(f"/api/sessions/{session_id}/flows")
+
+    def flow(self, flow_id: int, include_packets: bool = True) -> dict:
+        return self._get(
+            "/api/flows/{}".format(flow_id), include_packets="true" if include_packets else "false"
+        )
+
+    def packet(self, packet_id: int, raw: bool = False) -> dict:
+        return self._get("/api/packets/{}".format(packet_id), raw="true" if raw else "false")
+
+    def capture_start(self, interface: str) -> dict:
+        return self._post("/api/capture/start", {"interface": interface})
+
+    def capture_stop(self) -> dict:
+        return self._post("/api/capture/stop")
+
+    def capture_status(self) -> dict:
+        return self._get("/api/capture/status")

netreplay-0.1.0/gui/components/__init__.py

@@ -0,0 +1 @@
+"""Reusable GUI components."""

netreplay-0.1.0/gui/components/details.py

@@ -0,0 +1,71 @@
+"""Event / flow details widget."""
+from __future__ import annotations
+
+import time
+
+import flet as ft
+
+
+def _fmt(ts: float) -> str:
+    local = time.localtime(ts)
+    return time.strftime("%H:%M:%S", local) + f".{int((ts % 1) * 1000):03d}"
+
+
+class DetailsPanel:
+    def __init__(self):
+        self._header = ft.Text("Details", size=14, weight=ft.FontWeight.BOLD)
+        self._event = ft.Text("", size=12, color=ft.Colors.BLUE_200, selectable=True)
+        self._flow = ft.Text("", size=12, color=ft.Colors.TEAL_200, selectable=True)
+        self._body = ft.ListView(expand=True, spacing=2, padding=4)
+
+    def controls(self) -> list[ft.Control]:
+        return [self._header, self._event, self._flow, self._body]
+
+    def show_event(self, event: dict) -> None:
+        self._event.value = (
+            f"{_fmt(event['timestamp'])}  {event['type']}  {event['summary']}"
+        )
+        hint = "select a flow to see its packets" if not event.get("flow_id") else (
+            f"flow #{event['flow_id']} - select it in the list for packets"
+        )
+        self._flow.value = hint
+
+    def show_flow(self, flow: dict) -> None:
+        src = f"{flow['source']}:{flow['src_port']}" if flow["src_port"] else flow["source"]
+        dst = (
+            f"{flow['destination']}:{flow['dst_port']}"
+            if flow["dst_port"]
+            else flow["destination"]
+        )
+        lines = [
+            f"Flow #{flow['id']}",
+            f"{flow['protocol']}  {src} -> {dst}",
+            f"state {flow['state']}   start {_fmt(flow['start_ts'])}   "
+            f"end {_fmt(flow['end_ts'])}",
+            f"packets {flow['packet_count']}   bytes {flow['bytes']}",
+            "",
+            "packets:",
+        ]
+        self._flow.value = "\n".join(lines)
+        tiles: list[ft.Control] = []
+        for pkt in flow.get("packets", []):
+            src = f"{pkt['source']}:{pkt['src_port']}" if pkt["src_port"] else pkt["source"]
+            dst = (
+                f"{pkt['destination']}:{pkt['dst_port']}"
+                if pkt["dst_port"]
+                else pkt["destination"]
+            )
+            tiles.append(
+                ft.Text(
+                    f"{_fmt(pkt['ts'])}  #{pkt['id']}  {pkt['protocol']}  "
+                    f"{src} -> {dst}  len={pkt['length']}",
+                    size=11,
+                    font_family="monospace",
+                )
+            )
+        self._body.controls = tiles
+
+    def show_message(self, message: str) -> None:
+        self._event.value = message
+        self._flow.value = ""
+        self._body.controls = []

netreplay-0.1.0/gui/components/flow_list.py

@@ -0,0 +1,44 @@
+"""Flow list widget."""
+from __future__ import annotations
+
+import flet as ft
+
+
+class FlowList:
+    def __init__(self, on_select):
+        self._on_select = on_select
+        self._count = ft.Text("0 flows", size=11, color=ft.Colors.GREY_400)
+        self._list = ft.ListView(expand=True, spacing=2, padding=4, auto_scroll=False)
+
+    def controls(self) -> list[ft.Control]:
+        return [self._count, self._list]
+
+    def render(self, flows: list[dict]) -> None:
+        self._count.value = f"{len(flows)} flows"
+        tiles: list[ft.Control] = []
+        for flow in flows:
+            src = f"{flow['source']}:{flow['src_port']}" if flow["src_port"] else flow["source"]
+            dst = (
+                f"{flow['destination']}:{flow['dst_port']}"
+                if flow["dst_port"]
+                else flow["destination"]
+            )
+            pkts = flow["packet_count"]
+            size = flow["bytes"]
+            title = ft.Text(f"{src}  ->  {dst}", size=12, font_family="monospace")
+            subtitle = ft.Text(
+                f"{flow['protocol']}  state={flow['state']}  pkts={pkts}  bytes={size}",
+                size=11,
+                color=ft.Colors.GREY_400,
+            )
+            flow_id = flow["id"]
+            tiles.append(
+                ft.ListTile(
+                    title=title,
+                    subtitle=subtitle,
+                    dense=True,
+                    on_click=lambda _e, fid=flow_id: self._on_select(fid),
+                )
+            )
+            tiles.append(ft.Divider(height=1, color=ft.Colors.GREY_800))
+        self._list.controls = tiles

netreplay-0.1.0/gui/components/header.py

@@ -0,0 +1,81 @@
+"""Header widget: capture controls, interface picker, session picker."""
+from __future__ import annotations
+
+import flet as ft
+
+
+class Header:
+    def __init__(self, on_start, on_stop, on_open, on_refresh):
+        self._on_start = on_start
+        self._on_stop = on_stop
+        self._on_open = on_open
+        self._on_refresh = on_refresh
+
+        self.interface = ft.Dropdown(
+            width=420,
+            label="Interface",
+            options=[],
+        )
+        self.start_btn = ft.FilledButton("Start Capture", on_click=lambda _e: self._on_start())
+        self.stop_btn = ft.OutlinedButton("Stop", disabled=True, on_click=lambda _e: self._on_stop())
+        self.session = ft.Dropdown(width=220, label="Capture", options=[])
+        self.open_btn = ft.OutlinedButton("Open", on_click=lambda _e: self._on_open())
+        self.refresh_btn = ft.IconButton(ft.Icons.REFRESH, on_click=lambda _e: self._on_refresh())
+        self.status = ft.Text("", size=11, color=ft.Colors.GREY_400)
+        self.info = ft.Text("", size=11, color=ft.Colors.TEAL_200)
+        self.diag = ft.Text("", size=11, color=ft.Colors.GREY_400)
+
+    def controls(self) -> list[ft.Control]:
+        return [
+            ft.Row(
+                [
+                    self.interface,
+                    self.start_btn,
+                    self.stop_btn,
+                    ft.VerticalDivider(),
+                    self.session,
+                    self.open_btn,
+                    self.refresh_btn,
+                ],
+                wrap=True,
+            ),
+            ft.Row([self.info, self.status, self.diag], wrap=True),
+        ]
+
+    def set_interfaces(self, interfaces: list[dict], selected: str | None = None) -> None:
+        opts = [
+            ft.DropdownOption(
+                key=i["name"],
+                text=f"{i['name']}  [{i['description']}]" if i.get("description") else i["name"],
+                tooltip=i.get("description") or i["name"],
+            )
+            for i in interfaces
+        ]
+        current = self.interface.value
+        self.interface.options = opts
+        keep = selected or current
+        if keep and any(o.key == keep for o in opts):
+            self.interface.value = keep
+
+    def set_sessions(self, sessions: list[dict]) -> None:
+        opts = [
+            ft.DropdownOption(key=s["session_id"], text=f"{s['name']} ({s['packet_count']} pkts)")
+            for s in sessions
+        ]
+        current = self.session.value
+        self.session.options = opts
+        if current and any(o.key == current for o in opts):
+            self.session.value = current
+
+    def set_capture(self, running: bool, packets: int, flows: int, error: str | None) -> None:
+        self.start_btn.disabled = running
+        self.stop_btn.disabled = not running
+        if error:
+            self.status.value = f"capture error: {error}"
+            self.status.color = ft.Colors.RED_300
+        elif running:
+            self.status.value = f"capturing... packets={packets} flows={flows}"
+            self.status.color = ft.Colors.AMBER_200
+        else:
+            self.status.value = f"idle (packets={packets} flows={flows})"
+            self.status.color = ft.Colors.GREY_400