Версия 0.5.3

Добавлена сборка под Linux: nfqws + правила nftables (NFQUEUE) вместо
socks-прокси или службы Windows. Повышение прав — pkexec на каждое
включение/выключение, без службы и без автозапуска.

Стратегии переиспользуют существующий набор Flowseal (strategies.win32.generated.ts):
--wf-tcp/--wf-udp уходят в правила nftables, остальное — в nfqws как есть.
Все правила nftables держат bypass, поэтому упавший или выключенный демон
не рвёт пользователю сеть.

Помощник (resources/linux-helper/rknboost-helper.sh) и бинарник nfqws перед
каждым запуском копируются в userData: root не может прочитать файлы внутри
AppImage (FUSE-примонтирован без allow_other), а обычная файловая система
на диске ему доступна независимо от прав.

Заодно:
- починен баг генератора стратегий (^! не разэкранировался в !, ломало
  fake-tls-auto и на Windows тоже);
- карточка обхода теперь показывает текст ошибки независимо от state;
- счётчик auto-hostlist в настройках больше не привязан к !isWindows;
- CI: отдельная джоба сборки под Linux на ubuntu-latest.

.github/workflows/ci.yml

@@ -34,6 +34,10 @@ jobs:
       contents: write
     steps:
       - uses: actions/checkout@v4
+        with:
+          # fetch-depth: 0 — шагу «Описание релиза» ниже нужны вся история и теги,
+          # чтобы найти предыдущий vX.Y.Z и собрать список коммитов после него.
+          fetch-depth: 0
       - uses: actions/setup-node@v4
         with:
           node-version: 24
@@ -45,14 +49,75 @@ jobs:
       # electron-builder.yml просто копирует resources/zapret, а он у чистого чекаута пуст.
       - run: node scripts/fetch-zapret.mjs
 
+      # electron-builder заливает артефакты несколькими параллельными publisher'ами внутри
+      # этой же джобы, а с приходом Linux-сборки (отдельная джоба ниже) к этому добавилась
+      # ещё и гонка МЕЖДУ джобами: обе проверяют, есть ли релиз с этим тегом, обе видят «нет»
+      # и обе лезут его создавать — вторая падает с 422 already_exists (на v0.5.0 так
+      # потерялся сам .exe, когда конкурентами были два publisher'а внутри одной джобы).
+      # `|| true` — проигравшая гонку джоба не должна из-за этого падать целиком: релиз
+      # к моменту upload всё равно уже существует, просто создала его не она.
+      - name: Заготовка релиза
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          gh release view "$GITHUB_REF_NAME" >/dev/null 2>&1 ||
+            gh release create "$GITHUB_REF_NAME" --title "${GITHUB_REF_NAME#v}" --notes '' || true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
       # Подпись не настроена: артефакты неподписанные.
       # Чтобы подписывать — добавьте секреты CSC_LINK, CSC_KEY_PASSWORD и передайте их в env.
       #
-      # На пуш тега vX.Y.Z (см. on.push.tags выше) electron-builder публикует .exe в GitHub
-      # Release с этим тегом (создаёт его, если нет), используя repository из package.json.
+      # На пуш тега vX.Y.Z (см. on.push.tags выше) electron-builder заливает .exe в релиз,
+      # заготовленный шагом выше, используя repository из package.json.
       # На push в main/PR публикации нет — только упаковка и загрузка в Artifacts ниже.
       - name: Build
-        run: npx --no-install electron-vite build && npx --no-install electron-builder --publish ${{ startsWith(github.ref, 'refs/tags/v') && 'always' || 'never' }}
+        run: npx --no-install electron-vite build && npx --no-install electron-builder --win --publish ${{ startsWith(github.ref, 'refs/tags/v') && 'always' || 'never' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # differentialPackage: false и publishAutoUpdate: false в electron-builder.yml убирают
+      # .blockmap и latest.yml из ассетов (electron-updater в приложении нет — они были бы
+      # мёртвым грузом). В релизе должен остаться только .exe и контрольная сумма к нему.
+      - name: Контрольная сумма
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          set -euo pipefail
+          exe="$(ls release/*.exe)"
+          md5sum "$exe" | awk '{ print $1 }' > "$exe.md5"
+          gh release upload "$GITHUB_REF_NAME" "$exe.md5" --clobber
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Релиз создан с пустым описанием, поэтому список изменений дописываем сами:
+      # коммиты между предыдущим тегом vX.Y.Z и текущим. Только в этой джобе — если то же
+      # самое сделает ещё и Linux-сборка, они просто перезапишут результат друг друга.
+      - name: Описание релиза
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          set -euo pipefail
+          TAG="$GITHUB_REF_NAME"
+          # Предыдущий тег vX.Y.Z, начиная от родителя текущего. Пусто, если релиз первый.
+          PREV="$(git describe --tags --abbrev=0 --match 'v*' "$TAG^" 2>/dev/null || true)"
+          NOTES="$RUNNER_TEMP/release-notes.md"
+          {
+            if [ -n "$PREV" ]; then
+              echo "## Изменения с $PREV"
+              echo
+              git log --no-merges --pretty=format:'- %s (%h)' "$PREV..$TAG"
+              echo
+              echo
+              echo "**Полный diff:** https://github.com/$GITHUB_REPOSITORY/compare/$PREV...$TAG"
+            else
+              echo "## Изменения"
+              echo
+              git log --no-merges --pretty=format:'- %s (%h)' "$TAG"
+              echo
+            fi
+          } > "$NOTES"
+          gh release edit "$TAG" --notes-file "$NOTES"
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
@@ -62,3 +127,71 @@ jobs:
           path: release/*.exe
           if-no-files-found: error
           retention-days: 7
+
+  build-linux:
+    name: Сборка (Linux)
+    needs: check
+    runs-on: ubuntu-latest
+    # На тег vX.Y.Z нужен contents: write — electron-builder публикует релиз через GH_TOKEN.
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - run: npm ci
+
+      # Без этого шага сборка уезжает без nfqws: extraResources в electron-builder.yml
+      # просто копирует resources/zapret, а он у чистого чекаута пуст.
+      - run: node scripts/fetch-zapret.mjs
+
+      # Та же гонка «кто первый создаст релиз», что и в джобе Windows выше — эта джоба
+      # с ней конкурирует наравне (обе стартуют параллельно после check), отсюда и тот же
+      # `|| true`. Комментарий с полным объяснением — в джобе Windows.
+      - name: Заготовка релиза
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          gh release view "$GITHUB_REF_NAME" >/dev/null 2>&1 ||
+            gh release create "$GITHUB_REF_NAME" --title "${GITHUB_REF_NAME#v}" --notes '' || true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Подпись/нотаризация не при чём здесь — это Linux, .AppImage и .deb неподписанные
+      # в любом случае. На push в main/PR публикации нет — только упаковка и Artifacts ниже.
+      - name: Build
+        run: npx --no-install electron-vite build && npx --no-install electron-builder --linux --publish ${{ startsWith(github.ref, 'refs/tags/v') && 'always' || 'never' }}
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      # Тот же мотив, что у Windows-джобы: в релизе должны остаться только сами артефакты
+      # и контрольная сумма к каждому — никаких .blockmap/latest-linux.yml.
+      - name: Контрольная сумма
+        if: startsWith(github.ref, 'refs/tags/v')
+        shell: bash
+        run: |
+          set -euo pipefail
+          shopt -s nullglob
+          files=(release/*.AppImage release/*.deb)
+          if [ "${#files[@]}" -eq 0 ]; then
+            echo "не нашлось ни .AppImage, ни .deb в release/" >&2
+            exit 1
+          fi
+          for file in "${files[@]}"; do
+            md5sum "$file" | awk '{ print $1 }' > "$file.md5"
+            gh release upload "$GITHUB_REF_NAME" "$file.md5" --clobber
+          done
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: rknboost-linux
+          path: |
+            release/*.AppImage
+            release/*.deb
+          if-no-files-found: error
+          retention-days: 7

README.md

@@ -21,11 +21,27 @@ npm run typecheck  # tsc для node- и web-частей отдельно
 npm run build:unpack   # быстрая проверка: приложение без установщика (release/*-unpacked)
 npm run build:mac      # .dmg + .zip  (x64 + arm64)
 npm run build:win      # NSIS .exe    (x64; arm64 не собираем — нет подписанного WinDivert)
-npm run build:linux    # AppImage + .deb
+npm run build:linux    # AppImage + .deb (x64)
 ```
 
+## Обход блокировок по платформам
+
+| Платформа | Движок                                                | Права                                                 |
+| --------- | ----------------------------------------------------- | ----------------------------------------------------- |
+| macOS     | `tpws` — локальный socks5-прокси                      | не нужны                                              |
+| Windows   | `winws` + драйвер WinDivert, служба `rknboost-zapret` | UAC при первой настройке                              |
+| Linux     | `nfqws` + правила nftables (NFQUEUE)                  | пароль через `pkexec` при каждом включении/выключении |
+
+На Linux дополнительно нужны пакеты `nftables` и `polkit` (в .deb — заявлены как зависимости
+и ставятся сами; для AppImage — своими силами, `sudo apt install nftables policykit-1`).
+Ни службы, ни автозапуска с системой на Linux нет: демон и правила nftables переживают выход
+из приложения (правила закрыты флагом `bypass` — без работающего nfqws трафик просто проходит
+как есть, а не блокируется), но после перезагрузки заново их никто не поднимает.
+
 ## Ссылки
 
 - **[bol-van/zapret](https://github.com/bol-van/zapret)** — сам движок zapret, спасибо за столь хороший инструмент
 - **[Flowseal/zapret-discord-youtube](https://github.com/Flowseal/zapret-discord-youtube)** —
   списки сайтов (`resources/zapret/lists/`) и fake-пакеты (`resources/zapret/fakes/`).
+- **[Sergeydigl3/zapret-discord-youtube-linux](https://github.com/Sergeydigl3/zapret-discord-youtube-linux)** —
+  референс для Linux-порта: те же стратегии Flowseal через `nfqws`, nftables вместо WinDivert.

electron-builder.yml

@@ -4,6 +4,18 @@ directories:
   buildResources: build
   output: release
 
+# releaseType: release — публиковать релиз сразу, без черновика (draft — поведение по
+# умолчанию у electron-builder). С черновиком параллельная загрузка нескольких файлов иногда
+# создаёт два черновика с одним и тем же тегом вместо одного релиза.
+#
+# publishAutoUpdate: false — не заливать latest.yml. Это метаданные для electron-updater,
+# которого в приложении нет (обновляется пользователь вручную, скачивая новый инсталлятор
+# со страницы релиза) — файл был бы мёртвым грузом в ассетах.
+publish:
+  provider: github
+  releaseType: release
+  publishAutoUpdate: false
+
 files:
   - '!**/.vscode/*'
   - '!src/*'
@@ -12,16 +24,30 @@ files:
   - '!{.env,.env.*,.npmrc,pnpm-lock.yaml,yarn.lock}'
   - '!{tsconfig.json,tsconfig.node.json,tsconfig.web.json}'
   - '!.github/*'
-  # zapret идёт отдельно через extraResources ниже — не дублировать его в app.asar.
+  # zapret и linux-helper идут отдельно через extraResources ниже — не дублировать их в app.asar.
   - '!resources/zapret/**'
+  - '!resources/linux-helper/**'
 asarUnpack:
   - 'resources/**'
 
 # Бинарники zapret (npm run zapret:fetch) кладём рядом с приложением, а не в asar —
 # это исполняемые файлы, которые main-процесс запускает через spawn.
+#
+# Общие для всех платформ куски (списки, fake-пакеты, лицензии zapret/Flowseal) — здесь;
+# платформенные бинарники — в extraResources соответствующего раздела (win/mac/linux) ниже.
+# extraResources платформы ДОБАВЛЯЕТСЯ к этому списку, а не заменяет его (проверено по
+# исходникам electron-builder, app-builder-lib/fileMatcher.js) — так Windows-сборка не везёт
+# nfqws и Mach-O tpws, а Linux-сборка не везёт WinDivert и winws.exe.
 extraResources:
+  - from: resources/zapret/lists
+    to: zapret/lists
+  - from: resources/zapret/fakes
+    to: zapret/fakes
   - from: resources/zapret
     to: zapret
+    filter:
+      - 'LICENSE.zapret.txt'
+      - 'LICENSE.flowseal.txt'
 
 win:
   executableName: RKNboost
@@ -38,6 +64,13 @@ win:
     # в поставке zapret) — arm64-инсталлятор был бы заведомо нерабочим.
     - target: nsis
       arch: [x64]
+  extraResources:
+    - from: resources/zapret/win32
+      to: zapret/win32
+    - from: resources/zapret
+      to: zapret
+      filter:
+        - 'LICENSE.WinDivert.txt'
 nsis:
   # Быстрая установка per-user, без UAC и без мастера: ставится в %LocalAppData%, куда
   # обычный пользователь и так пишет без повышения прав. Раньше здесь стоял perMachine —
@@ -47,6 +80,10 @@ nsis:
   # в src/main/zapret/service.win32.ts) — сама установка приложения per-user безопасна.
   oneClick: true
   perMachine: false
+  # Без electron-updater (см. publishAutoUpdate выше) differential-обновления не нужны —
+  # differentialPackage: false отключает генерацию .blockmap, который иначе всегда
+  # заливался бы в ассеты релиза рядом с инсталлятором.
+  differentialPackage: false
   # Удалять %APPDATA%\rknboost (списки сайтов, метка первого запуска) вместе с приложением.
   # По умолчанию electron-builder этого НЕ делает, и данные оставались бы в системе после
   # удаления. Обновление приложения под это не попадает — в шаблоне деинсталлятора стоит
@@ -75,17 +112,52 @@ mac:
   # Подпись и нотаризация выключены: без Apple Developer ID сборка иначе падает.
   # Как включить — см. раздел «Подпись» в README.md.
   notarize: false
+  extraResources:
+    - from: resources/zapret/darwin
+      to: zapret/darwin
 dmg:
   artifactName: ${name}-${version}-${arch}.${ext}
 
 linux:
+  executableName: rknboost
+  # desktopName в package.json + syncDesktopName — иначе Electron не свяжет открытые окна
+  # с .desktop-записью (app_id/WM_CLASS), и часть окружений не покажет иконку в панели задач.
+  syncDesktopName: true
   target:
-    - AppImage
-    - deb
+    - target: AppImage
+      arch: [x64]
+    - target: deb
+      arch: [x64]
   maintainer: RKNboost
-  category: Utility
-  synopsis: Кроссплатформенное приложение на Electron
+  category: Network
+  synopsis: Обход блокировок через zapret
+  extraResources:
+    - from: resources/zapret/linux
+      to: zapret/linux
+    # rknboost-helper.sh — привилегированный помощник (nfqws.linux.ts зовёт его через
+    # pkexec). Не из resources/zapret: тот качает fetch-zapret.mjs, а этот файл — свой,
+    # лежит в репозитории (см. src/main/zapret/paths.ts:bundledHelperPath()).
+    - from: resources/linux-helper
+      to: linux-helper
 appImage:
   artifactName: ${name}-${version}-${arch}.${ext}
+deb:
+  artifactName: ${name}-${version}-${arch}.${ext}
+  # electron-builder ЗАМЕНЯЕТ этим списком свои дефолтные зависимости Electron, а не
+  # дополняет их (проверено по исходникам, app-builder-lib/targets/FpmTarget.js) — потерять
+  # хотя бы одну из первых девяти значило бы получить .deb, который ставится и не запускается.
+  # nftables и polkit — уже наши, для nfqws/pkexec.
+  depends:
+    - libgtk-3-0
+    - libnotify4
+    - libnss3
+    - libxss1
+    - libxtst6
+    - xdg-utils
+    - libatspi2.0-0
+    - libuuid1
+    - libsecret-1-0
+    - nftables
+    - policykit-1
 
 npmRebuild: false

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "rknboost",
-  "version": "0.4.0",
+  "version": "0.5.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "rknboost",
-      "version": "0.4.0",
+      "version": "0.5.3",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package.json

@@ -1,8 +1,9 @@
 {
   "name": "rknboost",
-  "version": "0.4.0",
+  "version": "0.5.3",
   "description": "Кроссплатформенное десктопное приложение на Electron + React + TypeScript",
   "main": "./out/main/index.js",
+  "desktopName": "rknboost.desktop",
   "author": "RKNboost",
   "license": "MIT",
   "repository": {

resources/linux-helper/rknboost-helper.sh

@@ -0,0 +1,174 @@
+#!/bin/sh
+# Привилегированный помощник обхода блокировок на Linux — единственное, что RKNboost
+# запускает через `pkexec`. Не редактировать под bash-специфику: /bin/sh на Debian/Ubuntu —
+# это dash, а не bash.
+#
+# Зовётся из src/main/zapret/nfqws.linux.ts ровно двумя способами:
+#   pkexec <этот файл> start <nfqws> <strategy.cfg> <tcp-порты> <udp-порты>
+#   pkexec <этот файл> stop
+#
+# Всё, что можно решить без root (выбор стратегии, генерация strategy.cfg, проверка
+# `nfqws --dry-run`), уже сделано на стороне приложения — сюда попадают только готовые пути
+# и уже провалидированные строки портов (см. nfqwsConfig() в strategies.ts: там же формат
+# портов проверен регуляркой, здесь ему просто доверяем). Раздельные пути/аргументы вместо
+# одной строки — чтобы этот скрипт не собирал команду nft из чего-то похожего на shell-код.
+#
+# Коды выхода — намеренно 3..6, чтобы не путаться с 126/127 самого pkexec (отказ в правах /
+# команда не найдена) при разборе результата на стороне приложения.
+set -eu
+
+RUN_DIR=/run/rknboost
+PIDFILE="$RUN_DIR/nfqws.pid"
+CONFIG="$RUN_DIR/strategy.cfg"
+ERRLOG="$RUN_DIR/nfqws.err"
+TABLE_FAMILY=inet
+TABLE_NAME=rknboost
+QUEUE_NUM=220
+FW_MARK=0x40000000
+
+log() {
+  echo "rknboost-helper: $*" >&2
+}
+
+# pkexec запускает с урезанным PATH (санирует окружение) — sbin, где обычно лежит nft,
+# в нём может не быть. Ищем явно по стандартным местам, а не полагаемся на PATH.
+find_nft() {
+  for candidate in /usr/sbin/nft /sbin/nft /usr/local/sbin/nft /usr/bin/nft; do
+    if [ -x "$candidate" ]; then
+      echo "$candidate"
+      return 0
+    fi
+  done
+  if command -v nft >/dev/null 2>&1; then
+    command -v nft
+    return 0
+  fi
+  return 1
+}
+
+# Сносит и таблицу, и демона. Идёт первым шагом `start` (самолечение: следующий успешный
+# запуск убирает любой мусор от аварийно прерванной прошлой сессии) и отдельной командой
+# `stop`. Всегда завершается успешно — «уже остановлено» не ошибка, тот же принцип, что и
+# у stopService() на Windows.
+cmd_stop() {
+  nft="${1:-}"
+
+  if [ -f "$PIDFILE" ]; then
+    pid="$(cat "$PIDFILE" 2>/dev/null || true)"
+    # /proc/<pid>/comm — это ровно "nfqws\n" (обрезано до 15 символов ядром, но nfqws
+    # короче), сверяем, чтобы не убить чужой процесс, переиспользовавший тот же pid.
+    if [ -n "$pid" ] && [ -r "/proc/$pid/comm" ] && [ "$(cat "/proc/$pid/comm" 2>/dev/null)" = "nfqws" ]; then
+      kill -TERM "$pid" 2>/dev/null || true
+      i=0
+      while [ -d "/proc/$pid" ] && [ "$i" -lt 30 ]; do
+        i=$((i + 1))
+        sleep 0.1
+      done
+      if [ -d "/proc/$pid" ]; then
+        kill -KILL "$pid" 2>/dev/null || true
+      fi
+    fi
+    rm -f "$PIDFILE"
+  fi
+
+  rm -f "$CONFIG" "$ERRLOG"
+
+  if [ -z "$nft" ]; then
+    nft="$(find_nft || true)"
+  fi
+  if [ -n "$nft" ] && "$nft" list table "$TABLE_FAMILY" "$TABLE_NAME" >/dev/null 2>&1; then
+    "$nft" delete table "$TABLE_FAMILY" "$TABLE_NAME" 2>/dev/null || true
+  fi
+}
+
+cmd_start() {
+  nfqws_bin="$1"
+  config_src="$2"
+  tcp_ports="$3"
+  udp_ports="$4"
+
+  nft="$(find_nft || true)"
+  if [ -z "$nft" ]; then
+    log "не найдена утилита nft (пакет nftables)"
+    exit 3
+  fi
+
+  # На всякий случай предупреждаем, если параллельно уже висит другой zapret со своей
+  # таблицей/очередью — двойной приём одного трафика в две очереди работать не будет,
+  # но это не наша таблица, сносить её самовольно нельзя.
+  if "$nft" list table inet zapret >/dev/null 2>&1 || "$nft" list table inet zapretunix >/dev/null 2>&1; then
+    log "внимание: обнаружена таблица nftables другого zapret-инструмента — возможен конфликт очередей"
+  fi
+
+  cmd_stop "$nft"
+
+  mkdir -p "$RUN_DIR"
+  chmod 0755 "$RUN_DIR"
+
+  # strategy.cfg в /run — источник маркера стратегии для LinuxEngine.sync(): читается без
+  # root (0644), первая строка — тот же --comment=rknboost:<id>:<hash>, что и на Windows.
+  cp "$config_src" "$CONFIG"
+  chmod 0644 "$CONFIG"
+
+  if ! "$nft" add table "$TABLE_FAMILY" "$TABLE_NAME"; then
+    log "не удалось создать таблицу nftables"
+    cmd_stop "$nft"
+    exit 4
+  fi
+  "$nft" add chain "$TABLE_FAMILY" "$TABLE_NAME" post '{ type filter hook postrouting priority mangle; }'
+  "$nft" add chain "$TABLE_FAMILY" "$TABLE_NAME" pre '{ type filter hook prerouting priority filter; }'
+
+  # bypass обязателен: без него при завершении/падении nfqws весь трафик на эти порты
+  # молча дропался бы. С bypass ядро принимает пакет, если очередь никто не слушает —
+  # то есть отключение обхода (или его крах) не рвёт пользователю сеть.
+  ok=1
+  "$nft" add rule "$TABLE_FAMILY" "$TABLE_NAME" post \
+    meta mark and $FW_MARK == 0 tcp dport "{$tcp_ports}" \
+    ct original packets 1-6 queue num $QUEUE_NUM bypass || ok=0
+  "$nft" add rule "$TABLE_FAMILY" "$TABLE_NAME" post \
+    meta mark and $FW_MARK == 0 udp dport "{$udp_ports}" \
+    ct original packets 1-6 queue num $QUEUE_NUM bypass || ok=0
+  "$nft" add rule "$TABLE_FAMILY" "$TABLE_NAME" pre \
+    tcp sport "{$tcp_ports}" \
+    ct reply packets 1-3 queue num $QUEUE_NUM bypass || ok=0
+
+  if [ "$ok" -ne 1 ]; then
+    log "не удалось создать правила nftables"
+    cmd_stop "$nft"
+    exit 4
+  fi
+
+  # nfq_init() у nfqws происходит до daemonize() — если очередь занята, модуля нет в ядре
+  # или не хватает прав, процесс завершится с ненулевым кодом ДО демонизации, и мы это
+  # увидим здесь же, без опроса готовности.
+  if ! "$nfqws_bin" --daemon \
+    --pidfile="$PIDFILE" \
+    --qnum=$QUEUE_NUM \
+    --dpi-desync-fwmark=$FW_MARK \
+    "@$CONFIG" 2>"$ERRLOG"; then
+    log "nfqws не запустился: $(cat "$ERRLOG" 2>/dev/null || true)"
+    cmd_stop "$nft"
+    exit 5
+  fi
+
+  exit 0
+}
+
+action="${1:-}"
+case "$action" in
+  start)
+    shift
+    if [ "$#" -ne 4 ]; then
+      log "start ожидает 4 аргумента: <nfqws> <config> <tcp-порты> <udp-порты>"
+      exit 6
+    fi
+    cmd_start "$1" "$2" "$3" "$4"
+    ;;
+  stop)
+    cmd_stop ""
+    ;;
+  *)
+    log "неизвестная команда: $action (ожидается start|stop)"
+    exit 6
+    ;;
+esac

scripts/fetch-zapret.mjs

@@ -41,6 +41,7 @@ const PREFIX = `zapret-${ZAPRET_VERSION}`
 /** Что забираем из архива bol-van/zapret: путь внутри архива → путь внутри resources/zapret. */
 const FILES = {
   'binaries/mac64/tpws': 'darwin/tpws',
+  'binaries/linux-x86_64/nfqws': 'linux/x64/nfqws',
   'binaries/windows-x86_64/winws.exe': 'win32/x64/winws.exe',
   'binaries/windows-x86_64/cygwin1.dll': 'win32/x64/cygwin1.dll',
   'binaries/windows-x86_64/WinDivert.dll': 'win32/x64/WinDivert.dll',
@@ -49,7 +50,7 @@ const FILES = {
 }
 
 /** Исполняемый бит нужен только там, где мы сами запускаем бинарник. */
-const EXECUTABLE = new Set(['darwin/tpws'])
+const EXECUTABLE = new Set(['darwin/tpws', 'linux/x64/nfqws'])
 
 /**
  * Списки доменов Flowseal → наши короткие имена (используются и в `lists.ts`, и
@@ -206,6 +207,7 @@ async function main() {
 if (
   process.argv.includes('--force') ||
   !existsSync(join(DEST, 'darwin', 'tpws')) ||
+  !existsSync(join(DEST, 'linux', 'x64', 'nfqws')) ||
   !existsSync(join(DEST, 'win32', 'x64', 'winws.exe')) ||
   !existsSync(join(DEST, 'lists', 'general.txt'))
 ) {

scripts/import-flowseal-strategies.mjs

@@ -97,6 +97,11 @@ function parseBatFile(filename, content) {
     // Мы передаём argv напрямую в spawn (без шелла) — кавычки внутри значения
     // остались бы буквальными символами в имени файла, поэтому убираем везде.
     .map((t) => t.replaceAll('"', ''))
+    // `^!` — экранирование `!` в cmd.exe (в .bat включён enabledelayedexpansion, где `!`
+    // иначе разворачивался бы как переменная). cmd.exe снимает его сам перед запуском
+    // winws.exe; здесь командную строку разбираем руками, и `^` иначе остался бы буквально
+    // в значении. Реальное значение zapret ожидает — `!` («'!' = standard fake» в readme).
+    .map((t) => t.replaceAll('=^!', '=!'))
     .map(resolvePlaceholders)
 
   if (tokens.length < 5)

src/main/ipc.ts

@@ -1,4 +1,4 @@
-import { BrowserWindow, ipcMain, nativeTheme, type IpcMainInvokeEvent } from 'electron'
+import { app, BrowserWindow, ipcMain, nativeTheme, type IpcMainInvokeEvent } from 'electron'
 import type { IpcChannel, IpcHandlers, ThemeState } from '../shared/ipc-contract'
 import { uninstallApp } from './uninstall.win32'
 import {
@@ -46,6 +46,10 @@ function themeState(): ThemeState {
 export function registerIpcHandlers(): void {
   handle('theme:get', () => themeState())
 
+  // Ровно то же значение, что electron-builder кладёт в имя установщика и в
+  // «Установленные приложения» — оба берут его из "version" в package.json.
+  handle('app:version', () => app.getVersion())
+
   // Кнопка «Удалить приложение» есть в интерфейсе только на Windows (SettingsView.tsx),
   // но канал регистрируем всегда — так и должно быть по контракту, просто на других
   // платформах он никогда не вызывается.
@@ -66,7 +70,14 @@ export function registerIpcHandlers(): void {
   handle('zapret:list-reset', (_event, id) => resetZapretList(id))
   handle('zapret:auto-hostlist', () => zapretAutoHostlist())
   handle('zapret:auto-hostlist-clear', () => clearZapretAutoHostlist())
-  handle('zapret:diagnose', () => zapretDiagnostics())
+  // Результаты уходят не ответом на invoke, а событиями по мере готовности — и именно
+  // в то окно, которое просило проверку, а не всем подряд. Окно могло закрыться, пока
+  // сайт отвечал (или молчал все 10 с таймаута), — тогда показывать результат уже некому.
+  handle('zapret:diagnose', (event) =>
+    zapretDiagnostics((result) => {
+      if (!event.sender.isDestroyed()) event.sender.send('zapret:diagnostic-result', result)
+    })
+  )
 
   // Системная тема поменялась (например, пользователь включил тёмный режим в ОС) —
   // сообщаем всем открытым окнам.

src/main/settings.ts

@@ -0,0 +1,76 @@
+import { randomUUID } from 'node:crypto'
+import { readFile, rename, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { app } from 'electron'
+
+/**
+ * Выбор пользователя между запусками: `settings.json` в userData (на Windows —
+ * `%AppData%\RKNboost`), поэтому переживает обновление и переустановку.
+ *
+ * Списки сайтов сюда не входят: они лежат рядом, в `userData/zapret-lists/*.txt`, и
+ * читаются прямо оттуда самими tpws и winws (см. `zapret/lists.ts`).
+ *
+ * `null` — «пользователь не выбирал», решает движок.
+ */
+export interface AppSettings {
+  strategyId: string | null
+  /** Windows: запускать службу вместе с системой. На macOS не используется. */
+  autoStart: boolean | null
+}
+
+const DEFAULTS: AppSettings = { strategyId: null, autoStart: null }
+
+let cache: AppSettings = { ...DEFAULTS }
+
+/** До первой загрузки не пишем: иначе движок затёр бы файл умолчаниями. */
+let loaded = false
+
+/** Очередь, чтобы два быстрых переключения не переставили rename местами. */
+let writeQueue: Promise<void> = Promise.resolve()
+
+function settingsPath(): string {
+  return join(app.getPath('userData'), 'settings.json')
+}
+
+/** Файл могли испортить или он остался от версии с другими полями — непонятное отбрасываем. */
+function sanitize(raw: unknown): AppSettings {
+  const value = (typeof raw === 'object' && raw !== null ? raw : {}) as Record<string, unknown>
+  return {
+    strategyId: typeof value.strategyId === 'string' && value.strategyId ? value.strategyId : null,
+    autoStart: typeof value.autoStart === 'boolean' ? value.autoStart : null
+  }
+}
+
+/** Читает настройки с диска. Вызывать один раз при старте, до создания окна. */
+export async function loadSettings(): Promise<AppSettings> {
+  try {
+    cache = sanitize(JSON.parse(await readFile(settingsPath(), 'utf8')))
+  } catch {
+    cache = { ...DEFAULTS } // первый запуск или нечитаемый файл
+  }
+  loaded = true
+  return { ...cache }
+}
+
+/** Атомарная запись: временный файл рядом + rename, как в `zapret/lists.ts`. */
+async function writeSettings(settings: AppSettings): Promise<void> {
+  const path = settingsPath()
+  const tmp = `${path}.${randomUUID()}.tmp`
+  await writeFile(tmp, `${JSON.stringify(settings, null, 2)}\n`, 'utf8')
+  await rename(tmp, path)
+}
+
+/**
+ * Вызывается из `ZapretEngine.patch()`, то есть на каждое изменение статуса — отсюда
+ * сравнение с прошлым значением. Записи не ждём: интерфейс не должен зависеть от диска,
+ * а не сохранившийся выбор не повод ломать работающий обход.
+ */
+export function rememberPreferences(settings: AppSettings): void {
+  if (!loaded) return
+  if (settings.strategyId === cache.strategyId && settings.autoStart === cache.autoStart) return
+
+  cache = settings
+  writeQueue = writeQueue
+    .then(() => writeSettings(settings))
+    .catch((error: unknown) => console.warn('[settings] не удалось сохранить:', error))
+}

src/main/window.ts

@@ -29,8 +29,8 @@ export function createWindow(): BrowserWindow {
     width: 440,
     height: 660,
     minWidth: 360,
-    // С запасом на самое высокое обычное состояние главного экрана (ошибка + три
-    // результата проверки), чтобы полоса прокрутки в карточке не появлялась на ровном месте.
+    // С запасом на самое высокое обычное состояние главного экрана (ошибка + результаты
+    // проверки), чтобы полоса прокрутки в карточке не появлялась на ровном месте.
     minHeight: 560,
     show: false,
     autoHideMenuBar: true,

src/main/zapret/deps.linux.ts

@@ -0,0 +1,43 @@
+import { access, constants } from 'node:fs/promises'
+
+/**
+ * `pkexec` из состава polkit — им поднимаем root для nftables/nfqws. Проверяем по конкретным
+ * путям, а не через `PATH`: тот же мотив, что у `find_nft()` в `rknboost-helper.sh` — санитайз
+ * окружения инструментами вроде pkexec/env-с-урезанным-PATH встречается достаточно часто,
+ * чтобы не полагаться на переменную окружения при поиске самого пути к элевации.
+ */
+const PKEXEC_CANDIDATES = ['/usr/bin/pkexec', '/bin/pkexec']
+
+/** `nft` — тот же список путей, что перебирает `find_nft()` в помощнике (держим в синхроне). */
+const NFT_CANDIDATES = ['/usr/sbin/nft', '/sbin/nft', '/usr/local/sbin/nft', '/usr/bin/nft']
+
+async function findExecutable(candidates: readonly string[]): Promise<string | null> {
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.X_OK)
+      return candidate
+    } catch {
+      // пробуем следующий путь
+    }
+  }
+  return null
+}
+
+/**
+ * Проверка окружения до первого запроса пароля — тот же мотив, что у `assertExecutable()`
+ * в `paths.ts`: без неё пользователь увидел бы «spawn pkexec ENOENT» или пустой отказ nft
+ * внутри чужого stderr и не понял бы, что установить.
+ */
+export async function assertLinuxDependencies(): Promise<void> {
+  if (!(await findExecutable(PKEXEC_CANDIDATES))) {
+    throw new Error(
+      'Не найден pkexec — установите пакет polkit ' +
+        '(Debian/Ubuntu: «sudo apt install policykit-1»).'
+    )
+  }
+  if (!(await findExecutable(NFT_CANDIDATES))) {
+    throw new Error(
+      'Не найдена утилита nft — установите пакет nftables (Debian/Ubuntu: «sudo apt install nftables»).'
+    )
+  }
+}

src/main/zapret/diagnostics.ts

@@ -1,7 +1,11 @@
 import { connect as netConnect, type Socket } from 'node:net'
 import { connect as tlsConnect } from 'node:tls'
 import { net } from 'electron'
-import type { ZapretDiagnosticResult, ZapretStatus } from '../../shared/ipc-contract'
+import type {
+  ZapretDiagnosticResult,
+  ZapretDiagnosticTarget,
+  ZapretStatus
+} from '../../shared/ipc-contract'
 
 // 6 секунд не хватало: десинк с `--dpi-desync-repeats` заметно удлиняет установку соединения,
 // и медленный, но живой сайт успевал попасть в «Недоступно».
@@ -9,15 +13,8 @@ const TIMEOUT_MS = 10000
 const TARGET_PORT = 443
 const RETRY_DELAY_MS = 300
 
-interface DiagnosticTarget {
-  id: string
-  label: string
-  host: string
-}
-
 /** Сайты, которые нужно проверять в первую очередь — по просьбе пользователя. */
-const TARGETS: DiagnosticTarget[] = [
-  { id: 'instagram', label: 'Instagram', host: 'instagram.com' },
+export const DIAGNOSTIC_TARGETS: ZapretDiagnosticTarget[] = [
   { id: 'discord', label: 'Discord', host: 'discord.com' },
   { id: 'youtube', label: 'YouTube', host: 'youtube.com' }
 ]
@@ -178,12 +175,21 @@ async function withRetry(attempt: () => Promise<number>): Promise<number> {
  * остальных случаях (Windows, обход выключен, платформа не поддерживается) бьём напрямую:
  * на Windows десинк уже общесистемный через WinDivert, а без обхода тест просто показывает
  * то, что есть сейчас.
+ *
+ * Каждый сайт отдаёт свой результат в `onResult` сам по себе, не дожидаясь остальных:
+ * проверки идут параллельно и заканчиваются вразнобой (живой сайт отвечает за десятки
+ * миллисекунд, заблокированный — только по таймауту в 10 с), и общий ответ одним куском
+ * означал бы пустой экран всё это время. Промис резолвится, когда отработали все, —
+ * по нему вызывающий код понимает, что проверка закончена.
  */
-export async function runDiagnostics(status: ZapretStatus): Promise<ZapretDiagnosticResult[]> {
+export async function runDiagnostics(
+  status: ZapretStatus,
+  onResult: (result: ZapretDiagnosticResult) => void
+): Promise<void> {
   const socksMatch = status.socksAddress ? /^(.+):(\d+)$/.exec(status.socksAddress) : null
 
-  return Promise.all(
-    TARGETS.map(async (target) => {
+  await Promise.all(
+    DIAGNOSTIC_TARGETS.map(async (target) => {
       const attempt = (): Promise<number> =>
         socksMatch
           ? checkViaSocks(target.host, socksMatch[1], Number(socksMatch[2]))
@@ -191,14 +197,14 @@ export async function runDiagnostics(status: ZapretStatus): Promise<ZapretDiagno
 
       try {
         const ms = await withRetry(attempt)
-        return { ...target, ok: true, ms, error: null }
+        onResult({ ...target, ok: true, ms, error: null })
       } catch (error) {
-        return {
+        onResult({
           ...target,
           ok: false,
           ms: null,
           error: error instanceof Error ? error.message : String(error)
-        }
+        })
       }
     })
   )

src/main/zapret/engine.linux.ts

@@ -0,0 +1,123 @@
+import type { ZapretStatus } from '../../shared/ipc-contract'
+import { assertLinuxDependencies } from './deps.linux'
+import { ZapretEngine } from './engine'
+import { dryRun, isProcessAlive, readNfqwsState, startNfqws, stopNfqws } from './nfqws.linux'
+import { defaultStrategyId, nfqwsConfig } from './strategies'
+
+/** Как часто опрашивать /proc — демон нам не дочерний процесс, экзит-событие поймать некому. */
+const WATCH_INTERVAL_MS = 3000
+
+/**
+ * Linux: nfqws (движок zapret на уровне пакетов, как и Windows-версия) + правила nftables
+ * NFQUEUE. Ни служба, ни автозапуск не заведены (см. README.md) — каждое включение просит
+ * пароль через `pkexec` (см. `nfqws.linux.ts`), а сам демон и его правила переживают выход
+ * из приложения: `bypass` на очереди означает, что их отсутствие не рвёт пользователю сеть
+ * (см. `rknboost-helper.sh`), поэтому `dispose()` намеренно пуст — как и на Windows.
+ */
+export class LinuxEngine extends ZapretEngine {
+  private watchTimer: ReturnType<typeof setInterval> | null = null
+
+  constructor() {
+    super('nfqws-nftables', defaultStrategyId('linux'))
+  }
+
+  /**
+   * Вызывается из `recoverZapret()` до открытия окна — как и `Win32Engine.sync()`, подхватывает
+   * состояние, оставшееся от предыдущего запуска приложения (демон root-процессом переживает
+   * закрытие приложения, автозапуска с системой при этом нет — состояние может быть только
+   * «работает с прошлой сессии» или «выключен»).
+   */
+  async sync(): Promise<ZapretStatus> {
+    const { pid, strategyId } = await readNfqwsState()
+
+    if (pid === null) {
+      this.stopWatch()
+      return this.patch({ state: 'stopped', startedAt: null, error: null })
+    }
+
+    this.startWatch(pid)
+    return this.patch({
+      state: 'running',
+      strategyId: strategyId ?? this.status.strategyId,
+      // Момент реального запуска нам не известен — демон мог подняться в прошлой сессии
+      // приложения. Тот же компромисс, что и в Win32Engine.sync().
+      startedAt: new Date().toISOString(),
+      error: null
+    })
+  }
+
+  async start(strategyId: string): Promise<ZapretStatus> {
+    this.patch({ state: 'starting', strategyId, error: null })
+
+    try {
+      // Всё, что можно проверить без пароля, проверяем в этом порядке: сначала формат
+      // самой стратегии, потом окружение, потом сами аргументы через --dry-run — тот же
+      // принцип, что и у Win32Engine.start(), только тут это не опционально, а единственный
+      // шанс не побеспокоить пользователя запросом root ради заведомо неверных данных.
+      const config = nfqwsConfig(strategyId)
+      await assertLinuxDependencies()
+      await dryRun(config.body)
+
+      await startNfqws({
+        configBody: config.body,
+        tcpPorts: config.tcpPorts,
+        udpPorts: config.udpPorts
+      })
+
+      const { pid } = await readNfqwsState()
+      if (pid !== null) this.startWatch(pid)
+
+      return this.patch({ state: 'running', startedAt: new Date().toISOString(), error: null })
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      this.appendLog('error', message)
+      return this.patch({ state: 'error', error: message, startedAt: null })
+    }
+  }
+
+  async stop(): Promise<ZapretStatus> {
+    this.patch({ state: 'stopping' })
+    this.stopWatch()
+    try {
+      await stopNfqws()
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      this.appendLog('error', message)
+      return this.patch({ state: 'error', error: message })
+    }
+    return this.patch({ state: 'stopped', startedAt: null, error: null })
+  }
+
+  async dispose(): Promise<void> {
+    // Демон и правила nftables живут своей жизнью в системе — выход приложения их не
+    // останавливает (см. комментарий класса). Опрос /proc всё равно больше не нужен.
+    this.stopWatch()
+  }
+
+  /**
+   * Демон нам не дочерний процесс (владеет им root, а не Electron) — событие завершения
+   * поймать некому, поэтому опрашиваем `/proc/<pid>` по таймеру. `bypass` в правилах
+   * nftables делает мёртвый демон безопасным для сети, но не для интерфейса: без этого
+   * опроса карточка продолжала бы показывать «Активен» после падения nfqws.
+   */
+  private startWatch(pid: number): void {
+    this.stopWatch()
+    this.watchTimer = setInterval(() => {
+      void isProcessAlive(pid).then((alive) => {
+        if (alive || this.status.state !== 'running') return
+        this.stopWatch()
+        this.appendLog('error', `nfqws (pid ${pid}) больше не запущен`)
+        this.patch({
+          state: 'error',
+          error: 'Процесс nfqws неожиданно завершился.',
+          startedAt: null
+        })
+      })
+    }, WATCH_INTERVAL_MS)
+  }
+
+  private stopWatch(): void {
+    if (this.watchTimer) clearInterval(this.watchTimer)
+    this.watchTimer = null
+  }
+}

src/main/zapret/engine.ts

@@ -5,6 +5,8 @@ import type {
   ZapretStatus,
   ZapretState
 } from '../../shared/ipc-contract'
+import { rememberPreferences, type AppSettings } from '../settings'
+
 /** Сколько строк вывода бинарника держим для UI. */
 const LOG_LIMIT = 200
 
@@ -31,6 +33,21 @@ export abstract class ZapretEngine {
     return { ...this.status }
   }
 
+  /**
+   * Возвращает выбор пользователя из прошлого запуска (`settings.json` в userData) —
+   * вызывается из `recoverZapret()` до открытия окна. Ничего не запускает: восстанавливаем
+   * только то, что было выбрано в интерфейсе, а включает обход по-прежнему сам пользователь
+   * (или, на Windows, автозапуск службы).
+   *
+   * `null` в поле означает «не выбирали» — тогда остаётся то, что решил конструктор движка.
+   */
+  restorePreferences(settings: AppSettings): void {
+    this.patch({
+      strategyId: settings.strategyId ?? this.status.strategyId,
+      autoStart: settings.autoStart ?? this.status.autoStart
+    })
+  }
+
   getLog(): ZapretLogLine[] {
     return [...this.log]
   }
@@ -67,6 +84,10 @@ export abstract class ZapretEngine {
 
   protected patch(changes: Partial<ZapretStatus>): ZapretStatus {
     this.status = { ...this.status, ...changes }
+    // Единая точка сохранения: любой путь смены стратегии или автозапуска (выбор в списке,
+    // start() с другой стратегией, подхваченное из системы состояние службы в sync())
+    // проходит через patch, так что забыть сохранить выбор здесь просто негде.
+    rememberPreferences({ strategyId: this.status.strategyId, autoStart: this.status.autoStart })
     this.broadcast('zapret:status-changed', this.status)
     return this.getStatus()
   }
@@ -95,15 +116,15 @@ export abstract class ZapretEngine {
   }
 }
 
-/** Заглушка для платформ, под которые мы бинарники не собираем (Linux). */
+/** Заглушка для платформ, под которые мы бинарники не собираем (FreeBSD и прочее — не macOS/Windows/Linux). */
 export class UnsupportedEngine extends ZapretEngine {
   constructor() {
     super('unsupported', '')
-    this.status.error = 'Обход блокировок доступен только на macOS и Windows.'
+    this.status.error = 'Обход блокировок доступен только на macOS, Windows и Linux.'
   }
 
   async start(): Promise<ZapretStatus> {
-    throw new Error('Обход блокировок доступен только на macOS и Windows.')
+    throw new Error('Обход блокировок доступен только на macOS, Windows и Linux.')
   }
 
   async stop(): Promise<ZapretStatus> {

src/main/zapret/engine.win32.ts

@@ -1,11 +1,18 @@
 import { execFile } from 'node:child_process'
-import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises'
+import { createHash } from 'node:crypto'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { promisify } from 'node:util'
 import type { ZapretStatus } from '../../shared/ipc-contract'
 import { ZapretEngine } from './engine'
-import { assertExecutable, protectedWinwsPath, serviceConfigPath, winwsPath } from './paths'
+import {
+  SERVICE_BINARY_NAMES,
+  assertExecutable,
+  serviceDataDir,
+  serviceConfigPath,
+  winwsPath
+} from './paths'
 import {
   applyServiceConfig,
   queryService,
@@ -14,7 +21,12 @@ import {
   stopService,
   type ServiceInfo
 } from './service.win32'
-import { defaultStrategyId, winwsConfigFile, type WinwsConfig } from './strategies'
+import {
+  defaultStrategyId,
+  type EngineConfig,
+  parseStrategyMarker,
+  winwsConfigFile
+} from './strategies'
 
 const run = promisify(execFile)
 
@@ -28,18 +40,34 @@ async function readInstalledMarkerLine(): Promise<string | null> {
   }
 }
 
+async function sha256(path: string): Promise<string> {
+  return createHash('sha256')
+    .update(await readFile(path))
+    .digest('hex')
+}
+
 /**
- * Служба всегда запускает защищённую копию winws.exe (protectedWinwsPath), а не оригинал
- * из папки установки приложения (winwsPath) — значит переустановку/обновление приложения
- * по самому пути службы не отследить, как раньше. Вместо этого сравниваем размер и время
- * изменения оригинала с уже скопированным файлом: разошлись — обновление zapret вышло
- * позже последней копии, нужно копировать заново (а значит и UAC).
+ * Служба запускает защищённую копию бинарников, а не оригинал из папки приложения — значит
+ * обновление по самому пути службы не отследить. Сравниваем содержимое: время изменения тут
+ * не годится совсем, `scripts/fetch-zapret.mjs` кладёт файлы через `copyFile`, а тот ставит
+ * текущее время — после каждой сборки CI mtime новее, хотя версия zapret запинована и байты
+ * те же. По mtime мы на ровном месте требовали UAC при каждом обновлении приложения и лезли
+ * копировать поверх WinDivert64.sys, ещё загруженного в ядро.
  */
 async function binariesNeedCopy(): Promise<boolean> {
+  const sourceDir = dirname(winwsPath())
+  const targetDir = serviceDataDir()
   try {
-    const [source, copy] = await Promise.all([stat(winwsPath()), stat(protectedWinwsPath())])
-    return source.size !== copy.size || source.mtimeMs > copy.mtimeMs
+    for (const name of SERVICE_BINARY_NAMES) {
+      const [source, copy] = await Promise.all([
+        sha256(join(sourceDir, name)),
+        sha256(join(targetDir, name))
+      ])
+      if (source !== copy) return true
+    }
+    return false
   } catch {
+    // Какого-то файла ещё нет (первая установка) или он нечитаем — надёжнее скопировать.
     return true
   }
 }
@@ -49,7 +77,7 @@ async function binariesNeedCopy(): Promise<boolean> {
  * winws.exe отстала от оригинала в папке приложения, или если аргументы стратегии
  * изменились (маркер в `strategy.cfg` не совпадает с тем, что сгенерировали сейчас).
  */
-async function needsReconfigure(config: WinwsConfig, info: ServiceInfo | null): Promise<boolean> {
+async function needsReconfigure(config: EngineConfig, info: ServiceInfo | null): Promise<boolean> {
   if (!info) return true
   if (await binariesNeedCopy()) return true
   return (await readInstalledMarkerLine()) !== config.marker
@@ -84,8 +112,7 @@ export class Win32Engine extends ZapretEngine {
     }
 
     const installedLine = await readInstalledMarkerLine()
-    const match = installedLine ? /^--comment=rknboost:([^:]+):/.exec(installedLine) : null
-    const strategyId = match?.[1] ?? this.status.strategyId
+    const strategyId = parseStrategyMarker(installedLine) ?? this.status.strategyId
 
     return this.patch({
       serviceInstalled: true,
@@ -102,7 +129,7 @@ export class Win32Engine extends ZapretEngine {
   async start(strategyId: string): Promise<ZapretStatus> {
     this.patch({ state: 'starting', strategyId, error: null })
 
-    let config: WinwsConfig
+    let config: EngineConfig
     try {
       config = winwsConfigFile(strategyId)
     } catch (error) {

src/main/zapret/index.ts

@@ -1,15 +1,18 @@
 import { readFile, rm } from 'node:fs/promises'
 import type {
   ZapretDiagnosticResult,
+  ZapretDiagnosticTarget,
   ZapretList,
   ZapretListId,
   ZapretLogLine,
   ZapretStatus,
   ZapretStrategy
 } from '../../shared/ipc-contract'
-import { runDiagnostics } from './diagnostics'
+import { loadSettings } from '../settings'
+import { DIAGNOSTIC_TARGETS, runDiagnostics } from './diagnostics'
 import { DarwinEngine } from './engine.darwin'
 import { ZapretEngine, UnsupportedEngine } from './engine'
+import { LinuxEngine } from './engine.linux'
 import { Win32Engine } from './engine.win32'
 import { readAllLists, resetList, seedLists, writeList } from './lists'
 import { autoHostlistPath } from './paths'
@@ -21,6 +24,8 @@ function createEngine(): ZapretEngine {
       return new DarwinEngine()
     case 'win32':
       return new Win32Engine()
+    case 'linux':
+      return new LinuxEngine()
     default:
       return new UnsupportedEngine()
   }
@@ -29,14 +34,35 @@ function createEngine(): ZapretEngine {
 const engine = createEngine()
 
 /**
- * Готовим списки сайтов и синхронизируем состояние с системой — на macOS чиним прокси
- * от прошлого аварийного завершения, на Windows подхватываем службу, которая могла работать
- * ещё до открытия окна (автозапуск с системой). Оба шага нужно сделать до открытия окна.
+ * Готовим списки сайтов, возвращаем выбор пользователя из прошлого запуска и синхронизируем
+ * состояние с системой — на macOS чиним прокси от прошлого аварийного завершения, на Windows
+ * подхватываем службу, которая могла работать ещё до открытия окна (автозапуск с системой),
+ * на Linux — демон nfqws, переживший закрытие приложения (автозапуска у него нет, но сам
+ * процесс и правила nftables продолжают работать). Все шаги нужно сделать до открытия окна.
  */
 export async function recoverZapret(): Promise<void> {
   await seedLists()
+
+  // Сохранённый выбор применяем ДО sync(): на Windows у уже установленной службы реальное
+  // состояние (стратегия в strategy.cfg, StartMode) важнее записанного нами и перекроет его.
+  const settings = await loadSettings()
+  engine.restorePreferences({
+    // Стратегия могла исчезнуть в обновлении (подборка Flowseal меняется) или остаться от
+    // запуска на другой платформе — тогда безопаснее вернуться к умолчанию движка, чем
+    // стартовать с id, которого больше нет.
+    strategyId: knownStrategyId(settings.strategyId),
+    autoStart: settings.autoStart
+  })
+
   if (engine instanceof DarwinEngine) await engine.recoverFromCrash()
   if (engine instanceof Win32Engine) await engine.sync()
+  if (engine instanceof LinuxEngine) await engine.sync()
+}
+
+function knownStrategyId(strategyId: string | null): string | null {
+  if (!strategyId) return null
+  const known = listStrategies(process.platform).some((strategy) => strategy.id === strategyId)
+  return known ? strategyId : null
 }
 
 export function zapretStatus(): ZapretStatus {
@@ -105,6 +131,19 @@ export async function clearZapretAutoHostlist(): Promise<void> {
   await rm(autoHostlistPath(), { force: true })
 }
 
-export function zapretDiagnostics(): Promise<ZapretDiagnosticResult[]> {
-  return runDiagnostics(engine.getStatus())
+/**
+ * Запускает проверку и сразу возвращает список сайтов — результаты приходят в `onResult`
+ * по одному, по мере готовности (см. `runDiagnostics`). Промис проверки намеренно не ждём:
+ * ответ на IPC — это список сайтов, чтобы UI успел показать строки «Проверяю…» до того,
+ * как ответит первый сайт.
+ */
+export function zapretDiagnostics(
+  onResult: (result: ZapretDiagnosticResult) => void
+): ZapretDiagnosticTarget[] {
+  // Каждая проверка ловит свою ошибку сама, наружу выбраться нечему — ловим здесь только
+  // чтобы неожиданное падение не осталось необработанным промисом.
+  runDiagnostics(engine.getStatus(), onResult).catch((error: unknown) => {
+    console.error('[zapret] проверка соединения завершилась ошибкой:', error)
+  })
+  return DIAGNOSTIC_TARGETS
 }

src/main/zapret/nfqws.linux.ts

@@ -0,0 +1,214 @@
+import { execFile, spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import {
+  access,
+  chmod,
+  constants,
+  copyFile,
+  mkdir,
+  mkdtemp,
+  readdir,
+  readFile,
+  rm,
+  writeFile
+} from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+import {
+  bundledFakesDir,
+  bundledHelperPath,
+  linuxInstalledConfigPath,
+  linuxPidfilePath,
+  linuxStagingDir,
+  nfqwsPath,
+  stagedFakesDir,
+  stagedHelperPath,
+  stagedNfqwsPath
+} from './paths'
+import { parseStrategyMarker } from './strategies'
+
+const run = promisify(execFile)
+
+async function sha256(path: string): Promise<string> {
+  return createHash('sha256')
+    .update(await readFile(path))
+    .digest('hex')
+}
+
+async function filesIdentical(a: string, b: string): Promise<boolean> {
+  try {
+    const [hashA, hashB] = await Promise.all([sha256(a), sha256(b)])
+    return hashA === hashB
+  } catch {
+    // Копии ещё нет (первый запуск) или она нечитаема — надёжнее перекопировать.
+    return false
+  }
+}
+
+/**
+ * Копирует nfqws, помощника и fake-пакеты из `resources/zapret`/`resources/linux-helper`
+ * в `linuxStagingDir()` — см. её комментарий в paths.ts про то, почему это не оптимизация,
+ * а необходимость под AppImage. Сравниваем содержимое, а не mtime — тот же мотив, что у
+ * `binariesNeedCopy()` в engine.win32.ts: `copyFile` всегда ставит текущее время, хотя
+ * зафиксированная версия zapret даёт одни и те же байты между сборками.
+ */
+export async function stageRuntime(): Promise<void> {
+  await mkdir(linuxStagingDir(), { recursive: true })
+  await mkdir(stagedFakesDir(), { recursive: true })
+
+  if (!(await filesIdentical(nfqwsPath(), stagedNfqwsPath()))) {
+    await copyFile(nfqwsPath(), stagedNfqwsPath())
+  }
+  await chmod(stagedNfqwsPath(), 0o755)
+
+  if (!(await filesIdentical(bundledHelperPath(), stagedHelperPath()))) {
+    await copyFile(bundledHelperPath(), stagedHelperPath())
+  }
+  await chmod(stagedHelperPath(), 0o755)
+
+  const fakesSrcDir = bundledFakesDir()
+  for (const name of await readdir(fakesSrcDir)) {
+    const src = join(fakesSrcDir, name)
+    const dst = join(stagedFakesDir(), name)
+    if (!(await filesIdentical(src, dst))) {
+      await copyFile(src, dst)
+    }
+  }
+}
+
+/**
+ * `nfqws --dry-run @<файл>` — проверяет только аргументы фильтра, root не нужен (в отличие
+ * от рабочего запуска демона). Запускаем бинарник из сборки напрямую: dry-run идёт от uid
+ * самого приложения, а не root, так что FUSE-примонтированный AppImage тут не помеха —
+ * ограничение касается только `pkexec` (см. linuxStagingDir()). Дословный аналог
+ * `Win32Engine['dryRun']`.
+ */
+export async function dryRun(configBody: string): Promise<void> {
+  const dir = await mkdtemp(join(tmpdir(), 'rknboost-dryrun-'))
+  const configPath = join(dir, 'dry-run.cfg')
+  try {
+    await writeFile(configPath, configBody, 'utf8')
+    await run(nfqwsPath(), ['--dry-run', `@${configPath}`])
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    throw new Error(`Стратегия содержит недопустимые параметры nfqws: ${message}`, {
+      cause: error
+    })
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+}
+
+/** Отрендеренный конфиг лежит здесь до pkexec — сам помощник, уже под root, копирует его в /run. */
+async function writeStagedConfig(body: string): Promise<string> {
+  const path = join(linuxStagingDir(), 'pending-strategy.cfg')
+  await writeFile(path, body, 'utf8')
+  return path
+}
+
+/** Хвост stderr помощника — тот же лимит и мотив, что у `stderrTail` в engine.darwin.ts. */
+const STDERR_TAIL_LIMIT = 4000
+
+function runHelper(args: string[]): Promise<{ code: number; stderr: string }> {
+  return new Promise((resolveHelper) => {
+    const child = spawn('pkexec', [stagedHelperPath(), ...args], {
+      stdio: ['ignore', 'ignore', 'pipe']
+    })
+
+    let stderr = ''
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr = (stderr + chunk.toString('utf8')).slice(-STDERR_TAIL_LIMIT)
+    })
+
+    // pkexec не найден — spawn сообщает об этом событием 'error', а не кодом выхода
+    // (см. launchUninstaller() в uninstall.win32.ts, та же причина).
+    child.on('error', (error) => resolveHelper({ code: 127, stderr: error.message }))
+    child.on('close', (code) => resolveHelper({ code: code ?? 1, stderr }))
+  })
+}
+
+export interface StartNfqwsOptions {
+  configBody: string
+  tcpPorts: string
+  udpPorts: string
+}
+
+/** Единственные два места, где приложение просит root — включение и выключение обхода. */
+export async function startNfqws(options: StartNfqwsOptions): Promise<void> {
+  await stageRuntime()
+  const configPath = await writeStagedConfig(options.configBody)
+
+  const { code, stderr } = await runHelper([
+    'start',
+    stagedNfqwsPath(),
+    configPath,
+    options.tcpPorts,
+    options.udpPorts
+  ])
+
+  if (code !== 0) {
+    throw new Error(
+      `Не удалось запустить обход (pkexec, код ${code})` +
+        (stderr ? `: ${stderr}` : ' — запрос прав администратора отклонён или прерван.')
+    )
+  }
+}
+
+export async function stopNfqws(): Promise<void> {
+  // Помощник может понадобиться, даже если start() в эту сессию ещё не звали — например,
+  // sync() увидел уже работающий с прошлого сеанса демон, и первое действие пользователя
+  // в новом запуске приложения — «Выключить».
+  await stageRuntime()
+
+  const { code, stderr } = await runHelper(['stop'])
+  if (code !== 0) {
+    throw new Error(
+      `Не удалось остановить обход (pkexec, код ${code})` +
+        (stderr ? `: ${stderr}` : ' — запрос прав администратора отклонён или прерван.')
+    )
+  }
+}
+
+export interface NfqwsState {
+  pid: number | null
+  strategyId: string | null
+}
+
+/** `/proc/<pid>` — существование каталога о процессе видно без прав, сигнал слать не нужно. */
+export async function isProcessAlive(pid: number): Promise<boolean> {
+  try {
+    await access(`/proc/${pid}`, constants.F_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Не требует root: `nfqws.pid` и `strategy.cfg` в `/run/rknboost` помощник кладёт с правами
+ * 0644 (см. rknboost-helper.sh) именно затем, чтобы это чтение — и восстановление состояния
+ * в `LinuxEngine.sync()` — обходилось без пароля.
+ */
+export async function readNfqwsState(): Promise<NfqwsState> {
+  let pid: number | null = null
+  try {
+    const raw = (await readFile(linuxPidfilePath(), 'utf8')).trim()
+    const parsed = Number.parseInt(raw, 10)
+    if (Number.isInteger(parsed) && parsed > 0 && (await isProcessAlive(parsed))) {
+      pid = parsed
+    }
+  } catch {
+    // pidfile нет или процесс из него уже не живёт — считаем демон не запущенным.
+  }
+
+  let strategyId: string | null = null
+  try {
+    const content = await readFile(linuxInstalledConfigPath(), 'utf8')
+    strategyId = parseStrategyMarker(content.split('\n')[0]?.trim() ?? null)
+  } catch {
+    // strategy.cfg нет — не страшно, id останется null.
+  }
+
+  return { pid, strategyId }
+}

src/main/zapret/paths.ts

@@ -23,6 +23,71 @@ export function winwsPath(): string {
   return join(zapretRoot(), 'win32', 'x64', 'winws.exe')
 }
 
+/** Linux: nfqws в составе сборки — для `--dry-run` (без root, читает свой же uid). */
+export function nfqwsPath(): string {
+  return join(zapretRoot(), 'linux', 'x64', 'nfqws')
+}
+
+/**
+ * Linux: привилегированный помощник в составе сборки (`resources/linux-helper/`, отдельный
+ * `extraResources` в electron-builder.yml — не качается `fetch-zapret.mjs`, лежит в репозитории).
+ */
+export function bundledHelperPath(): string {
+  return app.isPackaged
+    ? join(process.resourcesPath, 'linux-helper', 'rknboost-helper.sh')
+    : resolve(app.getAppPath(), 'resources', 'linux-helper', 'rknboost-helper.sh')
+}
+
+/**
+ * Linux: каталог, куда `nfqws`, помощник и fake-пакеты копируются перед КАЖДЫМ запуском
+ * (см. `nfqws.linux.ts`). Не оптимизация — необходимость: в AppImage `resources/zapret`
+ * примонтирован через FUSE без `allow_other`, и root (а `pkexec` поднимает именно root)
+ * туда просто не достучится — ни исполнить бинарник, ни прочитать fake-пакет во время
+ * работы. `userData` — обычная файловая система на диске; root видит любой файл на ней
+ * независимо от прав (DAC_OVERRIDE), так что копия здесь читается без проблем что для
+ * AppImage, что для .deb (там `resources/zapret` и так root-owned, копия просто лишняя,
+ * но не вредная — один код-путь на обе цели дешевле двух).
+ */
+export function linuxStagingDir(): string {
+  return join(app.getPath('userData'), 'linux-runtime')
+}
+
+export function stagedNfqwsPath(): string {
+  return join(linuxStagingDir(), 'nfqws')
+}
+
+export function stagedHelperPath(): string {
+  return join(linuxStagingDir(), 'rknboost-helper.sh')
+}
+
+/** Стейджинговая копия `fakesDir()` — то, что реально читает nfqws (см. её комментарий). */
+export function stagedFakesDir(): string {
+  return join(linuxStagingDir(), 'fakes')
+}
+
+/** Встроенные fake-пакеты — источник для копирования в `stagedFakesDir()`. */
+export function bundledFakesDir(): string {
+  return join(zapretRoot(), 'fakes')
+}
+
+/**
+ * Рабочий каталог демона — pidfile и `strategy.cfg` (последний — источник маркера стратегии
+ * для `LinuxEngine.sync()`, читается без root: помощник кладёт его с правами 0644). Создаёт
+ * и чистит сам `rknboost-helper.sh`. `/run` — стандартный FHS-путь для данных, не переживающих
+ * перезагрузку: nfqws её тоже не переживает, автозапуска на Linux нет (см. README.md).
+ */
+export function linuxRuntimeDir(): string {
+  return '/run/rknboost'
+}
+
+export function linuxPidfilePath(): string {
+  return join(linuxRuntimeDir(), 'nfqws.pid')
+}
+
+export function linuxInstalledConfigPath(): string {
+  return join(linuxRuntimeDir(), 'strategy.cfg')
+}
+
 /** Встроенные списки (из Flowseal/zapret-discord-youtube, см. scripts/fetch-zapret.mjs) — только для чтения. */
 export function bundledListsDir(): string {
   return join(zapretRoot(), 'lists')
@@ -37,9 +102,14 @@ export function userListsDir(): string {
   return join(app.getPath('userData'), 'zapret-lists')
 }
 
-/** Fake-пакеты (TLS ClientHello, QUIC initial, ...) для стратегий winws. */
+/**
+ * Fake-пакеты (TLS ClientHello, QUIC initial, ...) — путь, который резолвится в
+ * `{FAKES}` (`strategies.ts`) и должен суметь прочитать сам движок при работе, не только
+ * при запуске. На Linux это стейджинговая копия (`stagedFakesDir()`) — см. её комментарий
+ * про FUSE; на остальных платформах движок и так работает под тем же uid, что видит сборку.
+ */
 export function fakesDir(): string {
-  return join(zapretRoot(), 'fakes')
+  return process.platform === 'linux' ? stagedFakesDir() : join(zapretRoot(), 'fakes')
 }
 
 /**
@@ -56,6 +126,19 @@ export function serviceConfigPath(): string {
   return join(serviceDataDir(), 'strategy.cfg')
 }
 
+/**
+ * Файлы, которые служба запускает из своего защищённого каталога: сам winws и всё, от чего
+ * он зависит при старте. Список нужен и `engine.win32.ts` (решить, надо ли копировать),
+ * и повышенному скрипту в `service.win32.ts` (собственно копирование) — держим его здесь,
+ * чтобы он не разъехался на две копии.
+ */
+export const SERVICE_BINARY_NAMES = [
+  'winws.exe',
+  'cygwin1.dll',
+  'WinDivert.dll',
+  'WinDivert64.sys'
+] as const
+
 /**
  * Защищённая копия `winws.exe` (+ cygwin1.dll, WinDivert.dll, WinDivert64.sys) — на неё,
  * а не на оригинал из папки установки приложения, указывает служба. Установка теперь

src/main/zapret/service.win32.ts

@@ -10,7 +10,7 @@ import {
   isElevated,
   runElevatedServiceTask
 } from './elevated-task.win32'
-import { serviceConfigPath, serviceDataDir, winwsPath } from './paths'
+import { SERVICE_BINARY_NAMES, serviceConfigPath, serviceDataDir, winwsPath } from './paths'
 
 const run = promisify(execFile)
 
@@ -31,6 +31,8 @@ const ERROR_SERVICE_ALREADY_RUNNING = 1056
 const ERROR_SERVICE_NOT_ACTIVE = 1062
 
 export type ServiceState = 'Running' | 'Stopped' | 'StartPending' | 'StopPending' | 'Other'
+/** То, чего можно дождаться от службы. `Absent` — службы в системе нет (снята). */
+type WaitState = 'Running' | 'Stopped' | 'Absent'
 export type ServiceStartMode = 'Auto' | 'Manual' | 'Disabled' | 'Other'
 
 export interface ServiceInfo {
@@ -40,10 +42,6 @@ export interface ServiceInfo {
   binPath: string
 }
 
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 function exitCodeOf(error: unknown): number {
   const code = (error as { code?: number | string } | undefined)?.code
   return typeof code === 'number' ? code : 1
@@ -81,12 +79,29 @@ function normalizeStartMode(raw: string | undefined): ServiceStartMode {
  * Опрос через `Get-CimInstance Win32_Service`, а не парсинг вывода `sc query` — у CIM
  * `State`/`StartMode` это английские константы независимо от языка Windows, а `sc` печатает
  * локализованный текст, который парсить надёжно нельзя.
+ *
+ * Ждём тоже здесь, внутри одного скрипта: запуск powershell.exe стоит около секунды (он
+ * поднимает .NET), а опросов до перехода службы в нужное состояние бывает с десяток. Раньше
+ * каждый опрос был отдельным процессом, и включение обхода складывалось в основном из этих
+ * запусков; теперь на всё ожидание приходится один. Сам опрос внутри CIM — десятки мс.
  */
-export async function queryService(): Promise<ServiceInfo | null> {
-  const script =
-    `Get-CimInstance Win32_Service -Filter "Name='${SERVICE_NAME}'" | ` +
-    'Select-Object State,StartMode,PathName | ConvertTo-Json -Compress'
+function queryScript(until: readonly WaitState[], timeoutMs: number): string {
+  return `
+$targets = @(${until.map((state) => `'${state}'`).join(',')})
+$deadline = [DateTime]::UtcNow.AddMilliseconds(${timeoutMs})
+for (;;) {
+  $svc = Get-CimInstance Win32_Service -Filter "Name='${SERVICE_NAME}'" |
+    Select-Object State,StartMode,PathName
+  $state = if ($svc) { $svc.State } else { 'Absent' }
+  if ($targets.Count -eq 0 -or $targets -contains $state) { break }
+  if ([DateTime]::UtcNow -ge $deadline) { break }
+  Start-Sleep -Milliseconds ${POLL_INTERVAL_MS}
+}
+if ($svc) { $svc | ConvertTo-Json -Compress } else { 'null' }
+`
+}
 
+async function runQuery(script: string): Promise<ServiceInfo | null> {
   let stdout: string
   try {
     ;({ stdout } = await run('powershell.exe', ['-NoProfile', '-Command', script]))
@@ -108,6 +123,19 @@ export async function queryService(): Promise<ServiceInfo | null> {
   }
 }
 
+/** Текущее состояние службы; `null` — службы в системе нет. */
+export function queryService(): Promise<ServiceInfo | null> {
+  return runQuery(queryScript([], 0))
+}
+
+/**
+ * Ждёт одного из состояний и возвращает последнее увиденное — в том числе по таймауту,
+ * поэтому результат у вызывающего кода обязателен к проверке.
+ */
+function waitForService(...states: WaitState[]): Promise<ServiceInfo | null> {
+  return runQuery(queryScript(states, POLL_TIMEOUT_MS))
+}
+
 function explainScError(error: unknown, verb: string): string {
   const message = error instanceof Error ? error.message : String(error)
   if (/access is denied/i.test(message)) {
@@ -119,18 +147,6 @@ function explainScError(error: unknown, verb: string): string {
   return `Не удалось ${verb} службу: ${message}`
 }
 
-async function pollUntil(
-  predicate: (info: ServiceInfo | null) => boolean
-): Promise<ServiceInfo | null> {
-  const deadline = Date.now() + POLL_TIMEOUT_MS
-  for (;;) {
-    const info = await queryService()
-    if (predicate(info)) return info
-    if (Date.now() >= deadline) return info
-    await sleep(POLL_INTERVAL_MS)
-  }
-}
-
 /**
  * `sc start` только просит SCM перевести службу в running и возвращается сразу — если не
  * дождаться реального состояния, свежепадающая служба (например, WinDivert не загрузился)
@@ -147,7 +163,7 @@ export async function startService(): Promise<ServiceInfo | null> {
     }
   }
 
-  const info = await pollUntil((i) => i?.state === 'Running' || i?.state === 'Stopped')
+  const info = await waitForService('Running', 'Stopped')
   if (info?.state !== 'Running') {
     throw new Error(
       `Служба запущена системой, но не перешла в рабочее состояние (текущее: ` +
@@ -169,12 +185,11 @@ export async function stopService(): Promise<ServiceInfo | null> {
       throw new Error(explainScError(error, 'остановить'), { cause: error })
     }
   }
-  // `pollUntil` возвращает последнее состояние и по истечении таймаута, независимо от предиката,
-  // поэтому результат обязательно проверяем. Иначе «остановка», не уложившаяся в POLL_TIMEOUT_MS,
-  // молча сходила бы за успешную — и вызывающий код (перенастройка стратегии в engine.win32.ts)
+  // Результат обязательно проверяем: «остановка», не уложившаяся в POLL_TIMEOUT_MS, иначе
+  // молча сошла бы за успешную — и вызывающий код (перенастройка стратегии в engine.win32.ts)
   // пошёл бы копировать winws.exe поверх ещё работающего, ровно в ту ошибку, от которой
   // остановка и защищает.
-  const info = await pollUntil((i) => i === null || i.state === 'Stopped')
+  const info = await waitForService('Stopped', 'Absent')
   if (info && info.state !== 'Stopped') {
     throw new Error(
       `Служба не остановилась за ${POLL_TIMEOUT_MS / 1000} с (состояние: ${info.state}).`
@@ -270,6 +285,46 @@ function Invoke-ScRaw($rawArgs) {
   return [pscustomobject]@{ ExitCode = $proc.ExitCode; Output = ("$stdout $stderr").Trim() }
 }
 
+# WinDivert64.sys — образ драйвера, загруженного в ядро: пока драйвер не выгружен, файл
+# занят, и Copy-Item поверх него падает с «файл используется другим процессом». SCM
+# рапортует Stopped, как только winws.exe отдал сигнал, а выгрузка идёт уже после — при
+# быстром переподключении попадаем ровно в этот зазор.
+#
+# Отсюда три ступени. Сравнение по ХЕШУ, а не по времени изменения: fetch-zapret.mjs кладёт
+# бинарники через copyFile, тот ставит текущее время, и после каждой сборки CI mtime новее
+# при тех же байтах — по времени мы лезли копировать занятый .sys после каждого обновления
+# приложения. Дальше короткие повторы — вдруг драйвер вот-вот выгрузится. Последняя ступень:
+# уводим занятый файл в сторону переименованием (NTFS разрешает переименовать загруженный
+# образ, хотя удалить его не даёт) и кладём новый на освободившееся имя.
+function Copy-IfChanged($source, $destination) {
+  if (Test-Path -LiteralPath $destination) {
+    $sourceHash = (Get-FileHash -Algorithm SHA256 -LiteralPath $source).Hash
+    $copyHash = (Get-FileHash -Algorithm SHA256 -LiteralPath $destination).Hash
+    if ($sourceHash -eq $copyHash) { return }
+  }
+
+  for ($attempt = 1; $attempt -le 6; $attempt++) {
+    try {
+      Copy-Item -LiteralPath $source -Destination $destination -Force
+      return
+    }
+    catch {
+      Start-Sleep -Milliseconds 500
+    }
+  }
+
+  try {
+    $stale = "$destination.old"
+    Remove-Item -LiteralPath $stale -Force -ErrorAction SilentlyContinue
+    Move-Item -LiteralPath $destination -Destination $stale -Force
+    Copy-Item -LiteralPath $source -Destination $destination -Force
+  }
+  catch {
+    throw "Не удалось обновить $destination : $($_.Exception.Message)"
+  }
+}
+
+
 try {
   $payload = Get-Content -Raw -Path $PayloadPath | ConvertFrom-Json
 
@@ -298,10 +353,15 @@ try {
       # cygwin1.dll/WinDivert.dll/WinDivert64.sys, от них он зависит при запуске.
       $sourceDir = Split-Path -Parent $payload.winwsPath
       $protectedWinws = Join-Path $dir 'winws.exe'
-      foreach ($name in @('winws.exe', 'cygwin1.dll', 'WinDivert.dll', 'WinDivert64.sys')) {
-        Copy-Item -Path (Join-Path $sourceDir $name) -Destination (Join-Path $dir $name) -Force
+      foreach ($name in $payload.binaryNames) {
+        Copy-IfChanged (Join-Path $sourceDir $name) (Join-Path $dir $name)
       }
 
+      # Хвосты от прошлой перенастройки: тогда файл был занят загруженным драйвером, сейчас
+      # он, скорее всего, уже свободен. Не вышло — не беда, попробуем в следующий раз.
+      Get-ChildItem -LiteralPath $dir -Filter '*.old' -ErrorAction SilentlyContinue |
+        Remove-Item -Force -ErrorAction SilentlyContinue
+
       # sc.exe читает binPath как ОДИН аргумент — значит всю строку нужно взять в одну пару
       # кавычек, а внутренние кавычки экранировать как \\" (без этого CommandLineToArgvW режет
       # значение на два токена по пробелу перед "@", и sc create падает с кодом 1639).
@@ -346,8 +406,18 @@ try {
       & sc.exe stop $ServiceName 2>$null | Out-Null
       Start-Sleep -Milliseconds 500
       & sc.exe delete $ServiceName | Out-Null
-      if (Test-Path $payload.serviceDataDir) {
-        Remove-Item -Path $payload.serviceDataDir -Recurse -Force
+      # Тот же занятый WinDivert64.sys, что и при install: сразу после остановки драйвер ещё
+      # загружен, и Remove-Item падает. Повторяем, а если так и не вышло — не проваливаем
+      # удаление: служба уже снята, а оставшиеся файлы система освободит и без нас.
+      for ($attempt = 1; $attempt -le 10; $attempt++) {
+        if (-not (Test-Path $payload.serviceDataDir)) { break }
+        try {
+          Remove-Item -Path $payload.serviceDataDir -Recurse -Force
+          break
+        }
+        catch {
+          Start-Sleep -Milliseconds 500
+        }
       }
       Write-Result $true $null
     }
@@ -456,6 +526,7 @@ export async function applyServiceConfig(options: ApplyServiceConfigOptions): Pr
     configPath: serviceConfigPath(),
     configBody: options.configBody,
     winwsPath: winwsPath(),
+    binaryNames: SERVICE_BINARY_NAMES,
     autoStart: options.autoStart
   })
 }

src/main/zapret/strategies.ts

@@ -13,11 +13,14 @@ import { WIN32_STRATEGIES } from './strategies.win32.generated'
  * переупорядочивать сегменты (`--split-pos`, `--disorder`, `--oob`, `--tlsrec`), но не
  * умеет ни fake-пакетов, ни UDP/QUIC вообще. Профили ниже — свои, под это ограничение.
  *
- * `winws` (Windows) работает на уровне пакетов через WinDivert. Его пресеты — 22 варианта
- * из Flowseal/zapret-discord-youtube, перенесённые в `strategies.win32.generated.ts`
- * генератором `scripts/import-flowseal-strategies.mjs` (не батниками — кодом).
+ * `winws` (Windows) и `nfqws` (Linux) — один и тот же движок zapret на уровне пакетов
+ * (winws — сборка nfq/nfqws.c под WinDivert вместо netfilter), поэтому делят один набор
+ * пресетов — 22 варианта из Flowseal/zapret-discord-youtube, перенесённые в
+ * `strategies.win32.generated.ts` генератором `scripts/import-flowseal-strategies.mjs`
+ * (не батниками — кодом). На Linux `--wf-tcp`/`--wf-udp` из тех же аргументов уходят не в
+ * nfqws, а в правила nftables — см. `nfqwsConfig()` ниже и `resources/linux-helper/`.
  *
- * Оба движка используют одни и те же списки сайтов (`src/main/zapret/lists.ts`):
+ * Все три движка используют одни и те же списки сайтов (`src/main/zapret/lists.ts`):
  * `{LISTS}/<id>.txt` — путь резолвится в `resolvePlaceholders()` ниже.
  */
 interface DarwinStrategyDefinition extends ZapretStrategy {
@@ -143,9 +146,18 @@ const DARWIN_DEFINITIONS: DarwinStrategyDefinition[] = [
   }
 ]
 
-/** Стратегия по умолчанию — своя на каждой платформе, наборы id не пересекаются. */
+/**
+ * Стратегия по умолчанию. win32 и linux делят один набор id (оба читают
+ * `WIN32_STRATEGIES`), поэтому и дефолт у них общий — 'general'; у darwin свой набор.
+ */
 export function defaultStrategyId(platform: NodeJS.Platform): string {
-  return platform === 'win32' ? 'general' : 'split'
+  switch (platform) {
+    case 'win32':
+    case 'linux':
+      return 'general'
+    default:
+      return 'split'
+  }
 }
 
 function resolvePlaceholders(arg: string): string {
@@ -155,6 +167,17 @@ function resolvePlaceholders(arg: string): string {
     .replaceAll(AUTO_PLACEHOLDER, autoHostlistPath())
 }
 
+/** win32 и linux показывают один и тот же список Flowseal-пресетов — читают его из общего массива. */
+function flowsealStrategies(platform: 'win32' | 'linux'): ZapretStrategy[] {
+  return WIN32_STRATEGIES.map(({ id, name }) => ({
+    id,
+    name,
+    // У Flowseal нет описаний стратегий — только имена вариантов, подобранных под провайдера.
+    description: 'Стратегия из подборки Flowseal/zapret-discord-youtube.',
+    platforms: [platform]
+  }))
+}
+
 /** Пресеты, применимые к текущей платформе. */
 export function listStrategies(platform: NodeJS.Platform): ZapretStrategy[] {
   if (platform === 'darwin') {
@@ -165,15 +188,8 @@ export function listStrategies(platform: NodeJS.Platform): ZapretStrategy[] {
       platforms
     }))
   }
-  if (platform === 'win32') {
-    return WIN32_STRATEGIES.map(({ id, name }) => ({
-      id,
-      name,
-      // У Flowseal нет описаний стратегий — только имена вариантов, подобранных под провайдера.
-      description: 'Стратегия из подборки Flowseal/zapret-discord-youtube.',
-      platforms: ['win32']
-    }))
-  }
+  if (platform === 'win32') return flowsealStrategies('win32')
+  if (platform === 'linux') return flowsealStrategies('linux')
   return []
 }
 
@@ -201,12 +217,13 @@ export function winwsArgs(strategyId: string): string[] {
   return strategy.args.map(resolvePlaceholders)
 }
 
-/** Читает служба: `winws.exe @strategy.cfg`, ограничение размера у самого winws — 16 КБ. */
+/** Читают winws и nfqws через `@strategy.cfg` — ограничение размера общее у обоих, 16 КБ. */
 const MAX_CONFIG_FILE_BYTES = 16000
 
 /**
- * winws разбирает файл конфигурации через POSIX `wordexp()` (см. `nfq/nfqws.c` в поставке
- * zapret) — без кавычек он режет аргумент по пробелам и съедает обратные слэши в путях вида
+ * winws и nfqws — один и тот же парсер аргументов (`nfq/nfqws.c` в поставке zapret,
+ * winws — его сборка под WinDivert), файл конфигурации разбирают через POSIX `wordexp()` —
+ * без кавычек он режет аргумент по пробелам и съедает обратные слэши в путях вида
  * `C:\Users\...`. Каждый аргумент поэтому кладём в одинарные кавычки, а `'` внутри значения
  * экранируем как `'\''` — тем же приёмом, что и `networksetup()` в `proxy.darwin.ts` для shell.
  */
@@ -215,33 +232,104 @@ function quoteConfigArg(arg: string): string {
 }
 
 /**
- * Первая строка — маркер: по нему `Win32Engine.sync()` узнаёт, какая стратегия уже установлена
- * в службу, не перечитывая все аргументы. Сам маркер — штатная опция `--comment` winws,
- * в работу процесса не вмешивается.
+ * Первая строка — маркер: по нему `Win32Engine.sync()`/`LinuxEngine.sync()` узнают, какая
+ * стратегия уже установлена, не перечитывая все аргументы. Сам маркер — штатная опция
+ * `--comment` (есть и у winws, и у nfqws), в работу процесса не вмешивается.
  */
 function configMarker(strategyId: string, body: string): string {
   const hash = createHash('sha256').update(body).digest('hex').slice(0, 12)
   return `--comment=rknboost:${strategyId}:${hash}`
 }
 
-export interface WinwsConfig {
-  /** Содержимое `strategy.cfg` — UTF-8 без BOM, как требует winws (docs/windows.md zapret). */
+const MARKER_PATTERN = /^--comment=rknboost:([^:]+):/
+
+/**
+ * Обратная операция к `configMarker()` — достаёт id стратегии из первой строки уже
+ * установленного конфига. Общий разбор для `Win32Engine.sync()` и `LinuxEngine.sync()`,
+ * чтобы регэксп маркера не разъехался на два места.
+ */
+export function parseStrategyMarker(line: string | null): string | null {
+  if (!line) return null
+  return MARKER_PATTERN.exec(line)?.[1] ?? null
+}
+
+export interface EngineConfig {
+  /** Содержимое `strategy.cfg` — UTF-8 без BOM, как требует winws/nfqws (docs/windows.md zapret). */
   body: string
   /** Маркер первой строки — сравнить с уже установленным, чтобы понять, нужна ли перенастройка. */
   marker: string
 }
 
-/** Рендерит стратегию в файл аргументов для `winws.exe @<file>` — см. `WinwsConfig`. */
-export function winwsConfigFile(strategyId: string): WinwsConfig {
-  const args = winwsArgs(strategyId).map(quoteConfigArg).join('\n')
-  const marker = configMarker(strategyId, args)
-  const body = `${marker}\n${args}\n`
+/** Общий рендер: кавычки, маркер первой строкой, проверка лимита в 16 КБ. */
+function renderConfigFile(strategyId: string, args: string[]): EngineConfig {
+  const quoted = args.map(quoteConfigArg).join('\n')
+  const marker = configMarker(strategyId, quoted)
+  const body = `${marker}\n${quoted}\n`
 
   if (Buffer.byteLength(body, 'utf8') > MAX_CONFIG_FILE_BYTES) {
     throw new Error(
-      `Стратегия «${strategyId}» не помещается в лимит winws на файл конфигурации (16 КБ).`
+      `Стратегия «${strategyId}» не помещается в лимит winws/nfqws на файл конфигурации (16 КБ).`
     )
   }
 
   return { body, marker }
 }
+
+/** Рендерит стратегию в файл аргументов для `winws.exe @<file>` — см. `EngineConfig`. */
+export function winwsConfigFile(strategyId: string): EngineConfig {
+  return renderConfigFile(strategyId, winwsArgs(strategyId))
+}
+
+const WF_TCP_PREFIX = '--wf-tcp='
+const WF_UDP_PREFIX = '--wf-udp='
+
+export interface NfqwsConfig extends EngineConfig {
+  /** Порты для правила nftables `post` (исходящий трафик) — см. `rknboost-helper.sh`. */
+  tcpPorts: string
+  /** Порты для правил nftables `post`/`pre` (исходящий и ответный UDP). */
+  udpPorts: string
+}
+
+/**
+ * На Windows `--wf-tcp`/`--wf-udp` — это фильтр самого WinDivert, зашитый в те же аргументы
+ * winws. На Linux фильтрацию делает nftables снаружи nfqws (см. `rknboost-helper.sh`), а
+ * сам nfqws эти два аргумента не понимает — вырезаем их и отдаём отдельно вызывающей стороне.
+ */
+export function nfqwsConfig(strategyId: string): NfqwsConfig {
+  const args = winwsArgs(strategyId)
+  let tcpPorts: string | null = null
+  let udpPorts: string | null = null
+  const nfqwsArgs: string[] = []
+
+  for (const arg of args) {
+    if (arg.startsWith(WF_TCP_PREFIX)) {
+      tcpPorts = arg.slice(WF_TCP_PREFIX.length)
+    } else if (arg.startsWith(WF_UDP_PREFIX)) {
+      udpPorts = arg.slice(WF_UDP_PREFIX.length)
+    } else {
+      nfqwsArgs.push(arg)
+    }
+  }
+
+  // На всех 22 стратегиях сейчас ровно по одному --wf-tcp/--wf-udp (проверено вручную при
+  // добавлении Linux), но если очередной апдейт Flowseal формат изменит — лучше явная ошибка
+  // здесь, чем nftables-правило без портов.
+  if (tcpPorts === null || udpPorts === null) {
+    throw new Error(`Стратегия «${strategyId}»: не найден --wf-tcp/--wf-udp в аргументах.`)
+  }
+
+  // Значение уходит прямо в множество nft-правила (rknboost-helper.sh) без дополнительного
+  // экранирования — только цифры, запятые и дефисы диапазонов. Если Flowseal когда-нибудь
+  // передаст что-то ещё (например, `~` — отрицание порта), лучше явная ошибка тут, чем
+  // нераспознанный текст в командной строке nft, которую выполняет root.
+  for (const [flag, ports] of [
+    ['--wf-tcp', tcpPorts],
+    ['--wf-udp', udpPorts]
+  ] as const) {
+    if (!/^\d+(-\d+)?(,\d+(-\d+)?)*$/.test(ports)) {
+      throw new Error(`Стратегия «${strategyId}»: неожиданный формат ${flag}=${ports}`)
+    }
+  }
+
+  return { ...renderConfigFile(strategyId, nfqwsArgs), tcpPorts, udpPorts }
+}

src/main/zapret/strategies.win32.generated.ts

@@ -1581,7 +1581,7 @@ export const WIN32_STRATEGIES: readonly GeneratedWin32Strategy[] = [
       '--dpi-desync-repeats=11',
       '--dpi-desync-fooling=badseq',
       '--dpi-desync-fake-tls=0x00000000',
-      '--dpi-desync-fake-tls=^!',
+      '--dpi-desync-fake-tls=!',
       '--dpi-desync-fake-tls-mod=rnd,dupsid,sni=www.google.com',
       '--new',
       '--filter-tcp=443',
@@ -1592,7 +1592,7 @@ export const WIN32_STRATEGIES: readonly GeneratedWin32Strategy[] = [
       '--dpi-desync-repeats=11',
       '--dpi-desync-fooling=badseq',
       '--dpi-desync-fake-tls=0x00000000',
-      '--dpi-desync-fake-tls=^!',
+      '--dpi-desync-fake-tls=!',
       '--dpi-desync-fake-tls-mod=rnd,dupsid,sni=www.google.com',
       '--new',
       '--filter-tcp=80,443',
@@ -1604,7 +1604,7 @@ export const WIN32_STRATEGIES: readonly GeneratedWin32Strategy[] = [
       '--dpi-desync-repeats=11',
       '--dpi-desync-fooling=badseq',
       '--dpi-desync-fake-tls=0x00000000',
-      '--dpi-desync-fake-tls=^!',
+      '--dpi-desync-fake-tls=!',
       '--dpi-desync-fake-tls-mod=rnd,dupsid,sni=www.google.com',
       '--dpi-desync-fake-http={FAKES}/tls_clienthello_max_ru.bin',
       '--new',
@@ -1625,7 +1625,7 @@ export const WIN32_STRATEGIES: readonly GeneratedWin32Strategy[] = [
       '--dpi-desync-repeats=11',
       '--dpi-desync-fooling=badseq',
       '--dpi-desync-fake-tls=0x00000000',
-      '--dpi-desync-fake-tls=^!',
+      '--dpi-desync-fake-tls=!',
       '--dpi-desync-fake-tls-mod=rnd,dupsid,sni=www.google.com',
       '--dpi-desync-fake-http={FAKES}/tls_clienthello_max_ru.bin',
       '--new',
@@ -1639,7 +1639,7 @@ export const WIN32_STRATEGIES: readonly GeneratedWin32Strategy[] = [
       '--dpi-desync-repeats=11',
       '--dpi-desync-fooling=badseq',
       '--dpi-desync-fake-tls=0x00000000',
-      '--dpi-desync-fake-tls=^!',
+      '--dpi-desync-fake-tls=!',
       '--dpi-desync-fake-tls-mod=rnd,dupsid,sni=www.google.com',
       '--dpi-desync-fake-http={FAKES}/tls_clienthello_max_ru.bin',
       '--dpi-desync-fake-unknown=0x00000000',

src/preload/index.ts

@@ -6,6 +6,7 @@ import type {
   IpcHandlers,
   ThemeState,
   ZapretDiagnosticResult,
+  ZapretDiagnosticTarget,
   ZapretList,
   ZapretListId,
   ZapretLogLine,
@@ -42,6 +43,9 @@ const api = {
    *  службы только на Windows (см. SettingsView.tsx). */
   platform: process.platform,
 
+  /** Версия запущенной сборки — из package.json через `app.getVersion()` в main. */
+  getAppVersion: (): Promise<string> => invoke('app:version'),
+
   getTheme: (): Promise<ThemeState> => invoke('theme:get'),
   onThemeChanged: (listener: (state: ThemeState) => void): (() => void) =>
     subscribe('theme:changed', listener),
@@ -71,7 +75,10 @@ const api = {
   getZapretAutoHostlist: (): Promise<string[]> => invoke('zapret:auto-hostlist'),
   clearZapretAutoHostlist: (): Promise<void> => invoke('zapret:auto-hostlist-clear'),
 
-  runZapretDiagnostics: (): Promise<ZapretDiagnosticResult[]> => invoke('zapret:diagnose')
+  /** Запускает проверку и отдаёт список сайтов; результаты — через `onZapretDiagnosticResult`. */
+  runZapretDiagnostics: (): Promise<ZapretDiagnosticTarget[]> => invoke('zapret:diagnose'),
+  onZapretDiagnosticResult: (listener: (result: ZapretDiagnosticResult) => void): (() => void) =>
+    subscribe('zapret:diagnostic-result', listener)
 }
 
 export type RendererApi = typeof api

src/renderer/src/components/SettingsView.tsx

@@ -1,6 +1,7 @@
 import { useState } from 'react'
 import type { ZapretListId, ZapretStatus } from '@shared/ipc-contract'
 import { GITHUB_URL } from '@shared/links'
+import { useAppVersion } from '../hooks/useAppVersion'
 import { useZapretLists } from '../hooks/useZapretLists'
 import { LIST_TITLES } from '../lib/zapretListMeta'
 import ListEditor from './ListEditor'
@@ -11,10 +12,8 @@ import ListEditor from './ListEditor'
  * включения, где ими и пользуются. Отдельный экран за шестерёнкой в шапке.
  */
 const isWindows = window.api.platform === 'win32'
+const isDarwin = window.api.platform === 'darwin'
 const APP_CHANNEL = 'beta'
-// Держать в синхроне с "version" в package.json — оттуда её берёт electron-builder
-// для имени установщика и для «Установленные приложения» в Windows.
-const APP_VERSION = '0.4.0'
 
 export default function SettingsView({
   onBack,
@@ -27,6 +26,7 @@ export default function SettingsView({
 }): React.JSX.Element {
   const { lists, autoHostlist, save, reset, clearAuto } = useZapretLists()
   const [openListId, setOpenListId] = useState<ZapretListId | null>(null)
+  const appVersion = useAppVersion()
 
   const openList = lists.find((list) => list.id === openListId)
   if (openList) {
@@ -88,9 +88,9 @@ export default function SettingsView({
           </button>
         ))}
 
-        {/* На Windows ни одна из 22 стратегий Flowseal не использует --hostlist-auto — счётчик
-            всегда пуст, показывать его смысла нет. */}
-        {!isWindows && (
+        {/* --hostlist-auto есть только в darwin-профилях (см. strategies.ts) — ни одна из 22
+            стратегий Flowseal (Windows и Linux) его не использует, счётчик там всегда пуст. */}
+        {isDarwin && (
           <div className="settings-row settings-row--static">
             <span>Найдено автоматически</span>
             <span className="settings-row__count">
@@ -119,9 +119,13 @@ export default function SettingsView({
         <p className="settings__support-hint">Поддержите звёздочкой</p>
       </section>
 
-      <p className="settings__version">
-        {APP_CHANNEL}-{APP_VERSION}-{window.api.platform}
-      </p>
+      {/* Пока версия не пришла из main, строки нет вовсе: иначе на первом кадре
+          мелькнуло бы «beta--win32» с пустотой на месте номера. */}
+      {appVersion && (
+        <p className="settings__version">
+          {APP_CHANNEL}-{appVersion}-{window.api.platform}
+        </p>
+      )}
 
       {isWindows && (
         <button

src/renderer/src/components/ZapretCard.tsx

@@ -4,7 +4,7 @@ import { useZapretDiagnostics } from '../hooks/useZapretDiagnostics'
 /** Карточка обхода блокировок: статус и включение сверху, выбор стратегии и проверка соединения ниже. */
 export default function ZapretCard(): React.JSX.Element {
   const { status, strategies, start, stop, setStrategy, busy } = useZapret()
-  const { results, running: testing, run: runTest } = useZapretDiagnostics()
+  const { targets, results, running: testing, run: runTest } = useZapretDiagnostics()
 
   const running = status?.state === 'running' || status?.state === 'starting'
   const strategyId = status?.strategyId ?? strategies[0]?.id
@@ -47,12 +47,14 @@ export default function ZapretCard(): React.JSX.Element {
         {toggleLabel}
       </button>
 
-      {status?.state === 'error' && status.error && (
-        <p className="list-editor__error">{status.error}</p>
-      )}
+      {/* Не только при state === 'error': UnsupportedEngine (платформа без сборки движка)
+          пишет причину в error, оставляя state 'stopped' — иначе текст был бы недостижим,
+          а пользователь на неподдерживаемой платформе видел бы пустой список стратегий
+          без единого объяснения. */}
+      {status?.error && <p className="list-editor__error">{status.error}</p>}
 
       <div className="settings__field">
-        <span className="settings__label">Стратегия</span>
+        <span className="settings__label">Способ</span>
         {/* На время переключения список заблокирован: смена стратегии на работающем
             обходе останавливает и перенастраивает службу, и второй выбор посреди этого
             наложился бы на первый. */}
@@ -79,23 +81,32 @@ export default function ZapretCard(): React.JSX.Element {
         {testing ? 'Проверяю…' : 'Протестить'}
       </button>
 
-      {results.length > 0 && (
+      {/* Строки появляются сразу все, ещё до первого ответа, и заполняются по мере
+          готовности — иначе список прыгал бы, дорисовываясь по одной строке. */}
+      {targets.length > 0 && (
         <div className="settings__group">
-          {results.map((result) => (
-            <div key={result.id} className="settings-row settings-row--static">
-              {/* Причину показываем текстом, а не только подсказкой при наведении:
-                  «Недоступно» само по себе не говорит, что чинить. */}
-              <span className="diagnostic__label">
-                {result.label}
-                {!result.ok && result.error && (
-                  <small className="diagnostic__error">{result.error}</small>
+          {targets.map((target) => {
+            const result = results[target.id]
+            return (
+              <div key={target.id} className="settings-row settings-row--static">
+                {/* Причину показываем текстом, а не только подсказкой при наведении:
+                    «Недоступно» само по себе не говорит, что чинить. */}
+                <span className="diagnostic__label">
+                  {target.label}
+                  {result && !result.ok && result.error && (
+                    <small className="diagnostic__error">{result.error}</small>
+                  )}
+                </span>
+                {result ? (
+                  <span className={`chip ${result.ok ? 'chip--success' : 'chip--error'}`}>
+                    {result.ok ? `${result.ms} мс` : 'Недоступно'}
+                  </span>
+                ) : (
+                  <span className="chip chip--neutral">Проверяю…</span>
                 )}
-              </span>
-              <span className={`chip ${result.ok ? 'chip--success' : 'chip--error'}`}>
-                {result.ok ? `${result.ms} мс` : 'Недоступно'}
-              </span>
-            </div>
-          ))}
+              </div>
+            )
+          })}
         </div>
       )}
     </section>

src/renderer/src/hooks/useAppVersion.ts

@@ -0,0 +1,29 @@
+import { useEffect, useState } from 'react'
+
+/**
+ * Версия запущенной сборки — та же, что в имени установщика и в «Установленных
+ * приложениях»: main отдаёт её через `app.getVersion()`, то есть прямо из package.json.
+ *
+ * Раньше renderer держал версию своей константой с пометкой «держать в синхроне с
+ * package.json». Синхронизировать вручную забыли: константа осталась на 0.4.0, и релизы
+ * 0.5.0 и 0.5.1 показывали пользователю чужую версию. Спрашивать у main дороже на один
+ * IPC-вызов, зато разъехаться уже нечему.
+ *
+ * `null` — версия ещё не пришла; показывать её в этот момент нечего.
+ */
+export function useAppVersion(): string | null {
+  const [version, setVersion] = useState<string | null>(null)
+
+  useEffect(() => {
+    // Окно могло закрыться, пока шёл ответ — тогда setState уже некому применять.
+    let cancelled = false
+    void window.api.getAppVersion().then((value) => {
+      if (!cancelled) setVersion(value)
+    })
+    return () => {
+      cancelled = true
+    }
+  }, [])
+
+  return version
+}

src/renderer/src/hooks/useZapretDiagnostics.ts

@@ -1,23 +1,46 @@
-import { useCallback, useState } from 'react'
-import type { ZapretDiagnosticResult } from '@shared/ipc-contract'
+import { useCallback, useEffect, useState } from 'react'
+import type { ZapretDiagnosticResult, ZapretDiagnosticTarget } from '@shared/ipc-contract'
 
-/** Проверка соединения по клику — не авто-подписка, как в useZapret/useZapretLists. */
+/**
+ * Проверка соединения по клику — не авто-подписка, как в useZapret/useZapretLists.
+ *
+ * `run()` только запускает проверку и получает список сайтов; результаты приходят по
+ * одному событием и складываются в `results` по мере готовности — живой сайт отвечает за
+ * десятки миллисекунд, заблокированный молчит до таймаута в 10 с, и ждать общего ответа
+ * значило бы держать пользователя перед пустым экраном ровно столько же.
+ */
 export function useZapretDiagnostics(): {
-  results: ZapretDiagnosticResult[]
+  targets: ZapretDiagnosticTarget[]
+  results: Record<string, ZapretDiagnosticResult>
   running: boolean
   run: () => Promise<void>
 } {
-  const [results, setResults] = useState<ZapretDiagnosticResult[]>([])
-  const [running, setRunning] = useState(false)
+  const [targets, setTargets] = useState<ZapretDiagnosticTarget[]>([])
+  const [results, setResults] = useState<Record<string, ZapretDiagnosticResult>>({})
+  const [started, setStarted] = useState(false)
+
+  // Подписка живёт всё время жизни компонента, а не только на время проверки: результат
+  // приходит асинхронно, и подписываться в момент клика — значит гоняться с первым же
+  // быстрым ответом.
+  useEffect(
+    () =>
+      window.api.onZapretDiagnosticResult((result) => {
+        setResults((previous) => ({ ...previous, [result.id]: result }))
+      }),
+    []
+  )
 
   const run = useCallback(async () => {
-    setRunning(true)
-    try {
-      setResults(await window.api.runZapretDiagnostics())
-    } finally {
-      setRunning(false)
-    }
+    setStarted(true)
+    // Чистим до запроса: иначе прошлые результаты остались бы на экране рядом со свежими,
+    // и было бы не понять, какие из них к какой проверке.
+    setResults({})
+    setTargets(await window.api.runZapretDiagnostics())
   }, [])
 
-  return { results, running, run }
+  // Проверка идёт, пока пришли не все результаты. Каждый сайт отдаёт ровно один результат
+  // (см. runDiagnostics — там перехвачена и ошибка), так что счёт всегда сходится.
+  const finished = targets.length > 0 && targets.every((target) => results[target.id])
+
+  return { targets, results, running: started && !finished, run }
 }

src/shared/ipc-contract.ts

@@ -24,11 +24,13 @@ export type ZapretState = 'stopped' | 'starting' | 'running' | 'stopping' | 'err
 
 /**
  * Чем именно обходим на этой платформе:
- *   • `tpws-socks`    — macOS: локальный socks5-прокси, права не нужны;
- *   • `winws-service` — Windows: служба с драйвером WinDivert;
- *   • `unsupported`   — платформа без поддержки (Linux у нас не собран).
+ *   • `tpws-socks`     — macOS: локальный socks5-прокси, права не нужны;
+ *   • `winws-service`  — Windows: служба с драйвером WinDivert;
+ *   • `nfqws-nftables` — Linux: демон nfqws + правила nftables (NFQUEUE), root через pkexec
+ *                        на каждое включение — ни службы, ни автозапуска здесь нет;
+ *   • `unsupported`    — платформа без поддержки (не macOS/Windows/Linux).
  */
-export type ZapretBackend = 'tpws-socks' | 'winws-service' | 'unsupported'
+export type ZapretBackend = 'tpws-socks' | 'winws-service' | 'nfqws-nftables' | 'unsupported'
 
 export interface ZapretStatus {
   state: ZapretState
@@ -39,13 +41,13 @@ export interface ZapretStatus {
   startedAt: string | null
   /** Текст последней ошибки — показываем пользователю как есть. */
   error: string | null
-  /** macOS: адрес socks5-прокси, пока обход работает. */
+  /** macOS: адрес socks5-прокси, пока обход работает. На Linux/Windows всегда null. */
   socksAddress: string | null
-  /** macOS: прописан ли прокси в системных настройках сети. */
+  /** macOS: прописан ли прокси в системных настройках сети. На Linux/Windows не используется. */
   systemProxyApplied: boolean
   /** Windows: установлена ли служба (её ставит и настраивает само приложение при первом включении). */
   serviceInstalled: boolean
-  /** Windows: стоит ли служба на автозапуск с системой (`sc config start=`). */
+  /** Windows: стоит ли служба на автозапуск с системой (`sc config start=`). На Linux автозапуска нет. */
   autoStart: boolean
 }
 
@@ -77,14 +79,18 @@ export interface ZapretList {
   isDefault: boolean
 }
 
-/**
- * Результат проверки соединения (`src/main/zapret/diagnostics.ts`): успех — это успешный
- * TLS-хендшейк до хоста через текущий бэкенд обхода, не полноценный HTTP-запрос.
- */
-export interface ZapretDiagnosticResult {
+/** Сайт, который проверяет `src/main/zapret/diagnostics.ts`. */
+export interface ZapretDiagnosticTarget {
   id: string
   label: string
   host: string
+}
+
+/**
+ * Результат проверки одного сайта (`src/main/zapret/diagnostics.ts`): успех — это успешный
+ * TLS-хендшейк до хоста через текущий бэкенд обхода, не полноценный HTTP-запрос.
+ */
+export interface ZapretDiagnosticResult extends ZapretDiagnosticTarget {
   ok: boolean
   ms: number | null
   error: string | null
@@ -97,6 +103,14 @@ export interface ZapretDiagnosticResult {
 export interface IpcHandlers {
   'theme:get': () => ThemeState
 
+  /**
+   * Версия приложения — `app.getVersion()`, то есть `"version"` из package.json той сборки,
+   * которая сейчас запущена. Раньше renderer держал её отдельной константой «в синхроне
+   * с package.json» вручную: константа осталась на 0.4.0 и релизы 0.5.0 и 0.5.1 показали
+   * пользователю чужую версию. Спрашивать у main — единственный способ не разъехаться.
+   */
+  'app:version': () => string
+
   /** Windows: подтверждает диалогом ОС, запускает деинсталлятор и закрывает приложение. */
   'app:uninstall': () => void
 
@@ -108,7 +122,8 @@ export interface IpcHandlers {
   'zapret:set-system-proxy': (enabled: boolean) => ZapretStatus
   /**
    * Выбор пресета. Если обход выключен — просто запоминается. Если включён — на macOS
-   * перезапускает tpws, на Windows перенастраивает службу (потребуется UAC).
+   * перезапускает tpws, на Windows перенастраивает службу (потребуется UAC), на Linux
+   * перезапускает nfqws и правила nftables (потребуется пароль через pkexec).
    */
   'zapret:set-strategy': (strategyId: string) => ZapretStatus
   /** Windows: автозапуск службы с системой (`sc config start=`); требует UAC. */
@@ -121,8 +136,14 @@ export interface IpcHandlers {
   'zapret:auto-hostlist': () => string[]
   'zapret:auto-hostlist-clear': () => void
 
-  /** Проверка соединения: успешный TLS-хендшейк до нескольких сайтов через текущий бэкенд. */
-  'zapret:diagnose': () => ZapretDiagnosticResult[]
+  /**
+   * Запустить проверку соединения и сразу вернуть список проверяемых сайтов — сами
+   * результаты приходят по одному событием `zapret:diagnostic-result`, как только будет
+   * готов каждый. Сайты проверяются параллельно и отвечают вразнобой: ждать самый
+   * медленный, чтобы показать все разом, значит держать пользователя перед пустым
+   * экраном до последнего таймаута.
+   */
+  'zapret:diagnose': () => ZapretDiagnosticTarget[]
 }
 
 export type IpcChannel = keyof IpcHandlers
@@ -132,6 +153,8 @@ export interface IpcEvents {
   'theme:changed': ThemeState
   'zapret:status-changed': ZapretStatus
   'zapret:log': ZapretLogLine
+  /** Один готовый результат запущенной через `zapret:diagnose` проверки. */
+  'zapret:diagnostic-result': ZapretDiagnosticResult
 }
 
 export type IpcEventChannel = keyof IpcEvents