chore(release): prepare 2.0.0-beta.15 with verified draft publication

Co-authored-by: by-sonic <171230345+by-sonic@users.noreply.github.com>

.github/workflows/android.yml

@@ -0,0 +1,110 @@
+name: Android APK
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: android-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  apk:
+    name: Android ${{ matrix.arch }} debug APK
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: arm64
+            target: aarch64
+            rust-target: aarch64-linux-android
+            abi: arm64-v8a
+          - arch: x86_64
+            target: x86_64
+            rust-target: x86_64-linux-android
+            abi: x86_64
+    runs-on: ubuntu-22.04
+    timeout-minutes: 45
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 17
+      - uses: android-actions/setup-android@v3
+        with:
+          packages: platform-tools
+          log-accepted-android-sdk-licenses: false
+      - name: Install Android SDK and NDK
+        run: |
+          sdkmanager "platforms;android-36" "build-tools;36.0.0" "ndk;28.0.13004108"
+          echo "NDK_HOME=$ANDROID_HOME/ndk/28.0.13004108" >> "$GITHUB_ENV"
+      - uses: dtolnay/rust-toolchain@1.88.0
+        with:
+          targets: ${{ matrix.rust-target }}
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: android-${{ matrix.target }}
+      - name: Install frontend dependencies
+        run: npm ci
+      # Tauri regenerates only ignored machine-specific Gradle glue. The
+      # checked-in Activity, service, manifest and Gradle project stay intact.
+      - name: Build installable APK with the bundled frontend
+        run: |
+          chmod +x gen/android/gradlew
+          npm run tauri -- android build --debug --apk --target ${{ matrix.target }} --ci
+      - name: Check APK signature and packaged Rust engine
+        run: |
+          apk=$(find gen/android/app/build/outputs/apk -name '*.apk' -print -quit)
+          test -n "$apk"
+          "$ANDROID_HOME/build-tools/36.0.0/apksigner" verify "$apk"
+          unzip -l "$apk" | grep 'lib/${{ matrix.abi }}/libtglock_lib.so'
+      - uses: actions/upload-artifact@v4
+        with:
+          name: tglock-android-${{ matrix.arch }}-debug
+          path: gen/android/app/build/outputs/apk/**/*.apk
+          if-no-files-found: error
+          retention-days: 14
+
+  emulator:
+    name: Android 15 emulator smoke
+    needs: apk
+    runs-on: ubuntu-22.04
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/download-artifact@v4
+        with:
+          name: tglock-android-x86_64-debug
+          path: emulator-apk
+      - name: Enable KVM
+        run: |
+          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+          sudo udevadm control --reload-rules
+          sudo udevadm trigger --name-match=kvm
+      - name: Launch and exercise the native app
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 35
+          arch: x86_64
+          target: google_apis
+          profile: pixel_2
+          disable-animations: true
+          emulator-options: -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
+          script: timeout 180 python3 scripts/android_smoke.py emulator-apk
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: android-emulator-smoke-evidence
+          path: android-smoke-evidence/
+          if-no-files-found: warn
+          retention-days: 14

.github/workflows/arm64.yml

@@ -0,0 +1,59 @@
+name: Static ARM64 CLI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  static-cli:
+    name: ARM64 musl build and runtime checks
+    runs-on: ubuntu-24.04-arm
+    env:
+      CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER: musl-gcc
+      CC_aarch64_unknown_linux_musl: musl-gcc
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install musl toolchain
+        run: sudo apt-get update && sudo apt-get install -y musl-tools binutils
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-unknown-linux-musl
+      - name: Test the static headless target
+        run: cargo test --locked --target aarch64-unknown-linux-musl --no-default-features --features cli --lib --bins
+      - name: Build static CLI
+        run: cargo build --locked --release --target aarch64-unknown-linux-musl --no-default-features --features cli --bin tglock-cli
+      - name: Verify architecture and static linkage
+        run: |
+          binary=target/aarch64-unknown-linux-musl/release/tglock-cli
+          readelf -h "$binary" | grep -q 'Machine:.*AArch64'
+          if readelf -l "$binary" | grep -q INTERP; then
+            echo 'A static router binary must not have a dynamic interpreter'; exit 1
+          fi
+          if readelf -d "$binary" | grep -q NEEDED; then
+            echo 'A static router binary must not require shared libraries'; exit 1
+          fi
+          cp "$binary" tglock-cli-aarch64-unknown-linux-musl
+          sha256sum tglock-cli-aarch64-unknown-linux-musl > tglock-cli-aarch64-unknown-linux-musl.sha256
+      - name: Start, persist the secret, stop and restart
+        run: |
+          binary=./tglock-cli-aarch64-unknown-linux-musl
+          "$binary" --version
+          timeout --preserve-status --signal=TERM 5 "$binary" --port 18080 --secret-file "$RUNNER_TEMP/tglock-secret" > first.log 2>&1
+          grep -q '127.0.0.1:18080' first.log
+          grep -q 'tg://proxy' first.log
+          test "$(stat -c '%a' "$RUNNER_TEMP/tglock-secret")" = 600
+          timeout --preserve-status --signal=TERM 5 "$binary" --port 18080 --secret-file "$RUNNER_TEMP/tglock-secret" > second.log 2>&1
+          test "$(grep -o 'secret=[0-9a-f]*' first.log)" = "$(grep -o 'secret=[0-9a-f]*' second.log)"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: tglock-cli-aarch64-unknown-linux-musl
+          path: |
+            tglock-cli-aarch64-unknown-linux-musl
+            tglock-cli-aarch64-unknown-linux-musl.sha256
+          if-no-files-found: error

.github/workflows/ci.yml

@@ -9,6 +9,27 @@ permissions:
   contents: read
 
 jobs:
+  windows-core:
+    name: Windows headless core
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - name: Lint CLI and core
+        run: cargo clippy --locked --no-default-features --features cli --all-targets -- -D warnings
+      - name: Test CLI and core
+        run: cargo test --locked --no-default-features --features cli --lib --bins
+      - name: Build CLI for manual Windows verification
+        run: cargo build --locked --no-default-features --features cli --bin tglock-cli
+      - uses: actions/upload-artifact@v4
+        with:
+          name: tglock-cli-windows-debug
+          path: target/debug/tglock-cli.exe
+          if-no-files-found: error
+          retention-days: 14
+
   rust:
     name: Rust checks
     runs-on: macos-latest
@@ -58,6 +79,40 @@ jobs:
       - name: Test
         run: cargo test --all-targets
 
+  bundle:
+    name: Bundled app must be the GUI binary
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 22
+          cache: npm
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-apple-darwin
+
+      # Явный --target обязателен: без него бандлер выбирал правильный бинарь, а
+      # с ним — нет, и именно так beta.2 и beta.3 уехали с headless CLI внутри.
+      - name: Bundle the app
+        run: npx tauri build --bundles app --target aarch64-apple-darwin
+
+      # Проверяется содержимое, а не имя файла. В beta.3 имя было уже
+      # правильным, потому что бандлер переименовал CLI, и проверка имени
+      # ничего не заметила.
+      - name: The bundled binary must actually be the GUI one
+        run: |
+          exe=$(find target -maxdepth 8 -path '*TGLock.app/Contents/MacOS/tglock' | head -1)
+          test -n "$exe" || { echo "исполняемый файл бандла не найден"; find target -maxdepth 6 -name 'TGLock.app'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
   headless:
     name: Headless CLI (no WebView, no Node)
     runs-on: ubuntu-22.04
@@ -73,13 +128,13 @@ jobs:
       # libwebkit2gtk. It fails the moment anything drags the GUI back into the
       # headless build, which is the whole point of issues #10 and #17.
       - name: Lint
-        run: cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
+        run: cargo clippy --no-default-features --features cli --all-targets -- -D warnings
 
       - name: Test
-        run: cargo test --no-default-features --lib --bins
+        run: cargo test --no-default-features --features cli --lib --bins
 
       - name: Build
-        run: cargo build --release --no-default-features --bin tglock-cli
+        run: cargo build --release --no-default-features --features cli --bin tglock-cli
 
       - name: Start, advertise a proxy link and stop on SIGTERM
         run: |
@@ -101,6 +156,43 @@ jobs:
             ./target/release/tglock-cli --port 18080 --secret-file "$PWD/secret" > restart.log 2>&1
           test "$first" = "$(grep -o 'secret=[0-9a-f]*' restart.log)"
 
+      # Настройки из файла и приоритет флага над файлом.
+      - name: Read settings from a file
+        run: |
+          cat > tglock.toml <<'CONF'
+          port = 18090
+          secret = "dd00112233445566778899aabbccddeeff"
+          worker = ["example.workers.dev"]
+          CONF
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml > conf.log 2>&1
+          cat conf.log
+          grep -q '127.0.0.1:18090' conf.log
+          grep -q 'secret=dd00112233445566778899aabbccddeeff' conf.log
+          grep -q 'example.workers.dev' conf.log
+          # Флаг должен перекрывать файл.
+          timeout --preserve-status --signal=TERM 5 \
+            ./target/release/tglock-cli --config tglock.toml --port 18091 > over.log 2>&1
+          grep -q '127.0.0.1:18091' over.log
+          # Опечатка в файле обязана быть ошибкой, а не молчаливым дефолтом.
+          echo 'porrt = 1443' > bad.toml
+          if ./target/release/tglock-cli --config bad.toml; then
+            echo "опечатка в конфиге прошла незамеченной"; exit 1
+          fi
+
+      # Закрытый stdout не должен ронять демон: println! при ошибке записи
+      # паникует, а канал закрывается штатно — `| head`, закрытый терминал,
+      # перезапуск сборщика логов.
+      - name: Survive a closed stdout
+        run: |
+          set +e
+          timeout --signal=TERM 5 ./target/release/tglock-cli --port 18092 2> pipe-err.log | head -2
+          set -e
+          cat pipe-err.log
+          if grep -qi 'panic' pipe-err.log; then
+            echo "демон упал из-за закрытого stdout"; exit 1
+          fi
+
   msrv:
     name: Rust 1.88 compatibility
     runs-on: macos-latest
@@ -123,7 +215,7 @@ jobs:
         run: cargo check --locked
 
       - name: Check the headless dependency graph too
-        run: cargo check --locked --no-default-features --lib --bins
+        run: cargo check --locked --no-default-features --features cli --lib --bins
 
   frontend:
     name: Frontend
@@ -139,3 +231,9 @@ jobs:
 
       - name: Type-check and build
         run: npm ci && npm run build
+
+      - name: Worker contract and failure-path tests
+        run: npm run test:worker
+
+      - name: Offline protocol probe parser checks
+        run: node scripts/probe_proxy.mjs --self-test

.github/workflows/release.yml

@@ -9,7 +9,40 @@ permissions:
   contents: write
 
 jobs:
+  # Токен Actions умеет создавать релиз только на HEAD ветки по умолчанию. Если
+  # тег отстал хоть на один коммит, GitHub отвечает «Resource not accessible by
+  # integration» — сообщение про права, хотя права в порядке и дело в положении
+  # тега. Так утонул v2.0.0-beta.8: тег поставили, следом дописали коммит в main,
+  # и три сборки по восемь минут закончились загадочным 403.
+  #
+  # Проверка занимает секунды и идёт до сборок. Но она НЕ закрывает гонку: если
+  # запушить в main уже после её прохождения, публикация всё равно упадёт — как и
+  # случилось с beta.8. Единственная настоящая защита — порядок действий: тег
+  # ставится последним, и пока идёт релиз, в main не пушим.
+  guard:
+    name: Тег должен стоять на HEAD
+    runs-on: ubuntu-latest
+    steps:
+      - name: Сверить тег с веткой по умолчанию
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          branch=$(gh api "repos/$GITHUB_REPOSITORY" -q .default_branch)
+          head=$(gh api "repos/$GITHUB_REPOSITORY/commits/$branch" -q .sha)
+          if [ "$head" = "$GITHUB_SHA" ]; then
+            echo "$GITHUB_REF_NAME и $branch указывают на $head — собираем."
+            exit 0
+          fi
+          echo "::error::$GITHUB_REF_NAME стоит на $GITHUB_SHA, а $branch — на $head. Публикация упадёт с 403, потому что токен Actions создаёт релиз только на HEAD ветки по умолчанию."
+          echo "Переставьте тег и запушьте заново:"
+          echo "  git tag -d $GITHUB_REF_NAME"
+          echo "  git push origin :refs/tags/$GITHUB_REF_NAME"
+          echo "  git tag -a $GITHUB_REF_NAME $head -m 'TGLock ...'"
+          echo "  git push origin $GITHUB_REF_NAME"
+          exit 1
+
   publish:
+    needs: guard
     name: Build ${{ matrix.platform }}
     strategy:
       fail-fast: false
@@ -64,39 +97,74 @@ jobs:
         with:
           tagName: v__VERSION__
           releaseName: TGLock v__VERSION__
+          # Только инструкция по скачиванию: она одна и та же для любой версии.
+          # Список изменений дописывается в release notes при выпуске — иначе
+          # выходит как в бетах 1-7, где каждая несла один и тот же текст «новый
+          # TGLock, полностью обновлённый интерфейс» и понять, что поменялось,
+          # было невозможно.
           releaseBody: |
-            Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
+            ## Что скачивать
 
-            - macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
+            - **Windows** — `.exe`, установщик
-            - Windows: скачайте `.exe` установщик
+            - **macOS** — универсальный `.dmg` (или `.app.tar.gz`)
-            - Linux: скачайте `.AppImage` или `.deb`
+            - **Linux** — `.AppImage` или `.deb`
-            - Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
+            - **Сервер, контейнер, машина без монитора** — `tglock-cli-*`: то же самое, но без графического интерфейса
-          releaseDraft: false
+
+            Если Windows ругается на файл — [почему так и что с этим делать](https://github.com/by-sonic/tglock#-антивирус-ругается-smartscreen-предупреждает-virustotal-показывает-детекты).
+          # Publish only after every platform, CLI and exact-commit APK is verified.
+          releaseDraft: true
           prerelease: false
           args: ${{ matrix.args }}
 
-      # Смотрит внутрь собранного бандла. v2.0.0-beta.2 опубликовался с зелёным
+      # Проверяет СОДЕРЖИМОЕ упакованного бинаря, а не его имя.
-      # CI, хотя .app и .deb содержали headless CLI вместо приложения: сборка
+      #
-      # была успешной, просто никто не проверял, что внутри.
+      # v2.0.0-beta.2 и v2.0.0-beta.3 опубликовались с зелёным CI, хотя в бандле
-      - name: The bundle must contain the GUI binary
+      # лежал headless CLI вместо приложения. В beta.3 имя файла было уже
+      # правильным — переименованным — поэтому проверка имени прошла. Отличить
+      # можно только по содержимому: `wry`/`ipc.localhost` есть исключительно в
+      # GUI, а `allow-direct` — исключительно в CLI.
+      - name: The bundled binary must actually be the GUI one
         if: runner.os == 'macOS'
         shell: bash
         run: |
           app=$(find target -maxdepth 6 -name 'TGLock.app' -type d | head -1)
           test -n "$app" || { echo "TGLock.app не найден"; exit 1; }
-          exe=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$app/Contents/Info.plist")
+          exe="$app/Contents/MacOS/tglock"
-          echo "CFBundleExecutable = $exe"
+          test -f "$exe" || { echo "нет $exe:"; ls -la "$app/Contents/MacOS/"; exit 1; }
-          test "$exe" = "tglock" || { echo "в бандле не GUI-бинарь"; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
-          test -x "$app/Contents/MacOS/tglock" || { echo "исполняемый файл отсутствует"; exit 1; }
 
-      - name: The bundle must contain the GUI binary
+      - name: The bundled binary must actually be the GUI one
         if: runner.os == 'Linux'
         shell: bash
         run: |
           deb=$(find target -maxdepth 6 -name '*.deb' | head -1)
           test -n "$deb" || { echo ".deb не найден"; exit 1; }
-          dpkg-deb -c "$deb" | grep -E ' \./usr/bin/tglock$' \
+          root=$(mktemp -d)
-            || { echo "в .deb нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
+          dpkg-deb -x "$deb" "$root"
+          exe="$root/usr/bin/tglock"
+          test -f "$exe" || { echo "нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
+          python3 scripts/verify_bundle_binary.py "$exe"
+
+  arm64-build:
+    needs: guard
+    uses: ./.github/workflows/arm64.yml
+    permissions:
+      contents: read
+
+  arm64-publish:
+    name: Attach verified ARM64 musl CLI
+    needs: [publish, arm64-build]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: tglock-cli-aarch64-unknown-linux-musl
+          path: arm64-cli
+      - uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.ref_name }}
+          draft: true
+          files: arm64-cli/*
 
   cli:
     name: Headless CLI ${{ matrix.platform }}
@@ -136,7 +204,7 @@ jobs:
           IFS=',' read -ra targets <<< "${{ matrix.rust-targets }}"
           binaries=()
           for target in "${targets[@]}"; do
-            cargo build --release --locked --no-default-features \
+            cargo build --release --locked --no-default-features --features cli \
               --bin tglock-cli --target "$target"
             binaries+=("target/$target/release/tglock-cli")
           done
@@ -152,7 +220,7 @@ jobs:
         if: runner.os == 'Windows'
         shell: bash
         run: |
-          cargo build --release --locked --no-default-features \
+          cargo build --release --locked --no-default-features --features cli \
             --bin tglock-cli --target ${{ matrix.rust-targets }}
           cp "target/${{ matrix.rust-targets }}/release/tglock-cli.exe" "${{ matrix.asset }}"
           ./"${{ matrix.asset }}" --version
@@ -163,5 +231,6 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           tag_name: ${{ github.ref_name }}
+          draft: true
           prerelease: false
           files: ${{ matrix.asset }}

.gitignore

@@ -2,26 +2,8 @@
 /dist
 /dist-ui
 /node_modules
+/gen/*
+!/gen/android/
 /tools
 *.zip
 .claude/
-
-# Сгенерированный Android-проект коммитится: в нём манифест, разрешения и
-# Kotlin-код сервиса. Игнорируются только артефакты сборки и локальные пути.
-/gen/apple
-# ACL-схемы генерируются tauri-build при каждой сборке.
-/gen/schemas
-/gen/android/.gradle
-/gen/android/.idea
-/gen/android/build
-/gen/android/app/build
-/gen/android/buildSrc/build
-/gen/android/local.properties
-/gen/android/.tauri
-/gen/android/tauri.settings.gradle
-/gen/android/app/src/main/jniLibs
-/gen/android/app/src/main/assets
-*.keystore
-*.jks
-keystore.properties
-key.properties

Cargo.lock

@@ -230,9 +230,9 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
 
 [[package]]
 name = "async-trait"
-version = "0.1.91"
+version = "0.1.92"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae36dc4177970ef04fde5178d3e2429882def40e57a451f919c098f72baa6cec"
+checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -336,9 +336,9 @@ dependencies = [
 
 [[package]]
 name = "blocking"
-version = "1.6.2"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
+checksum = "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa"
 dependencies = [
  "async-channel",
  "async-task",
@@ -1550,9 +1550,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "hermit-abi"
-version = "0.5.2"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
 
 [[package]]
 name = "hex"
@@ -2498,6 +2498,16 @@ dependencies = [
  "windows-link 0.2.1",
 ]
 
+[[package]]
+name = "pem"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be"
+dependencies = [
+ "base64 0.22.1",
+ "serde_core",
+]
+
 [[package]]
 name = "percent-encoding"
 version = "2.3.2"
@@ -2791,6 +2801,19 @@ version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
+[[package]]
+name = "rcgen"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75e669e5202259b5314d1ea5397316ad400819437857b90861765f24c4cf80a2"
+dependencies = [
+ "pem",
+ "ring",
+ "rustls-pki-types",
+ "time",
+ "yasna",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.5.18"
@@ -2938,9 +2961,9 @@ dependencies = [
 
 [[package]]
 name = "rustls"
-version = "0.23.42"
+version = "0.23.45"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c54fcab019b409d04215d3a17cb438fd7fbf192ee61461f20f4fe18704bc138"
+checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
 dependencies = [
  "once_cell",
  "ring",
@@ -2952,18 +2975,18 @@ dependencies = [
 
 [[package]]
 name = "rustls-pki-types"
-version = "1.15.0"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "764899a24af3980067ee14bc143654f297b22eaebfe3c7b6b211920a5a59b046"
+checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
 dependencies = [
  "zeroize",
 ]
 
 [[package]]
 name = "rustls-webpki"
-version = "0.103.13"
+version = "0.103.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
 dependencies = [
  "ring",
  "rustls-pki-types",
@@ -3655,9 +3678,9 @@ dependencies = [
 
 [[package]]
 name = "tauri-plugin-opener"
-version = "2.5.4"
+version = "2.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17e1bea14edce6b793a04e2417e3fd924b9bc4faae83cdee7d714156cceeed29"
+checksum = "60d60366174b745b4ef5824b8bbc1c457fd08f0ce101ff643c0a49181a9f4e91"
 dependencies = [
  "dunce",
  "glob",
@@ -3799,7 +3822,7 @@ dependencies = [
 
 [[package]]
 name = "tglock"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.15"
 dependencies = [
  "aes",
  "cipher",
@@ -3807,6 +3830,7 @@ dependencies = [
  "ctr",
  "futures-util",
  "rand",
+ "rcgen",
  "rustls",
  "serde",
  "serde_json",
@@ -3815,7 +3839,10 @@ dependencies = [
  "tauri-build",
  "tauri-plugin-opener",
  "tokio",
+ "tokio-rustls",
  "tokio-tungstenite",
+ "toml 0.8.2",
+ "webpki-roots 0.26.11",
 ]
 
 [[package]]
@@ -3942,9 +3969,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-rustls"
-version = "0.26.4"
+version = "0.26.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+checksum = "b0c85f2c3ef0b1cd58b36682f4b17aaa995f0e5db534d85692b4903abce21f67"
 dependencies = [
  "rustls",
  "tokio",
@@ -5054,6 +5081,15 @@ dependencies = [
  "pkg-config",
 ]
 
+[[package]]
+name = "yasna"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
+dependencies = [
+ "time",
+]
+
 [[package]]
 name = "yoke"
 version = "0.8.3"
@@ -5079,9 +5115,9 @@ dependencies = [
 
 [[package]]
 name = "zbus"
-version = "5.18.0"
+version = "5.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe18fb60dc696039e738717b76eaea21e7a4489bbb1885020b43c94236d7e98a"
+checksum = "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907"
 dependencies = [
  "async-broadcast",
  "async-executor",
@@ -5114,14 +5150,14 @@ dependencies = [
 
 [[package]]
 name = "zbus_macros"
-version = "5.18.0"
+version = "5.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe96480bed92df2b442a1a30df364e12d08eed03aeb061f2b8dc6afb2be91119"
+checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40"
 dependencies = [
  "proc-macro-crate 3.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.3",
  "zbus_names",
  "zvariant",
  "zvariant_utils",
@@ -5138,6 +5174,15 @@ dependencies = [
  "zvariant",
 ]
 
+[[package]]
+name = "zcheapstr"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1afec51604565183aeb5c54c20aeab286120d4e4460f7f76e3e8bb8c0d99473"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.8.55"
@@ -5226,40 +5271,41 @@ checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
 
 [[package]]
 name = "zvariant"
-version = "5.13.1"
+version = "5.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bee2a0bcd2a907786a456fff45aaaaf54c9ba5f50b71ae9ec1a4edd200c94911"
+checksum = "c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147"
 dependencies = [
  "endi",
  "enumflags2",
  "serde",
  "winnow 1.0.4",
+ "zcheapstr",
  "zvariant_derive",
  "zvariant_utils",
 ]
 
 [[package]]
 name = "zvariant_derive"
-version = "5.13.1"
+version = "5.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38a708216a18780796770bfe3f4739c7c83a3e8f789b755534bbbc06e4e23e12"
+checksum = "864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497"
 dependencies = [
  "proc-macro-crate 3.5.0",
  "proc-macro2",
  "quote",
- "syn 2.0.119",
+ "syn 3.0.3",
  "zvariant_utils",
 ]
 
 [[package]]
 name = "zvariant_utils"
-version = "3.5.0"
+version = "4.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90cb9383f9b45290407a1258b202d3f8f01db719eb60b4e4055c6375af4fc7c7"
+checksum = "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3"
 dependencies = [
  "proc-macro2",
  "quote",
  "serde",
- "syn 2.0.119",
+ "syn 3.0.3",
  "winnow 1.0.4",
 ]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tglock"
-version = "2.0.0-beta.3"
+version = "2.0.0-beta.15"
 edition = "2021"
 rust-version = "1.88"
 description = "Telegram unblock via local WebSocket tunnel"
@@ -9,19 +9,22 @@ autobins = false
 
 [features]
 default = ["gui"]
-# The graphical application, on desktop and on Android. Turning it off drops
+# The desktop GUI. Turning it off drops Tauri, the system WebView and the
-# Tauri, the system WebView and the frontend bundle from the build, which is
+# frontend bundle from the build, which is what makes headless servers and
-# what makes headless servers and machines without a GPU or monitor able to
+# machines without a GPU or monitor able to build and run TGLock at all.
-# build and run TGLock at all.
 gui = ["dep:tauri", "dep:tauri-build", "dep:tauri-plugin-opener"]
+# The headless binary. Deliberately NOT in `default`.
+#
+# When both binaries exist in one build, the Tauri bundler picks the wrong one
+# as the application: `tauri build --target <triple>` packaged tglock-cli and
+# shipped it as the app in v2.0.0-beta.2 and v2.0.0-beta.3. Keeping the CLI
+# behind its own non-default feature means it simply does not exist during an
+# application build, so there is nothing to pick wrongly.
+cli = ["dep:clap", "dep:toml"]
 
 [lib]
-# Отличается от имени бинаря намеренно: одинаковые имена lib и bin дают
-# коллизию выходных файлов, которую cargo обещает сделать ошибкой.
 name = "tglock_lib"
 path = "src/lib.rs"
-# Android загружает приложение как нативную библиотеку, а не как исполняемый
-# файл, поэтому нужен cdylib. rlib остаётся для CLI и тестов.
 crate-type = ["staticlib", "cdylib", "rlib"]
 
 [[bin]]
@@ -32,12 +35,15 @@ required-features = ["gui"]
 [[bin]]
 name = "tglock-cli"
 path = "src/bin/cli.rs"
+required-features = ["cli"]
 
 [dependencies]
 tauri = { version = "2", features = [], optional = true }
-# Opens the tg:// link. Unlike the `open` crate this works on Android too.
 tauri-plugin-opener = { version = "2", optional = true }
-clap = { version = "4", features = ["derive"] }
+clap = { version = "4", features = ["derive"], optional = true }
+# Файл конфигурации CLI. TOML, а не JSON, потому что файл правят руками и в нём
+# нужны комментарии.
+toml = { version = "0.8", optional = true }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tokio = { version = "1", features = [
@@ -49,19 +55,10 @@ tokio = { version = "1", features = [
   "sync",
   "signal",
 ] }
-# rustls вместо native-tls: на чистом Rust, поэтому кросскомпилируется под
-# Android без OpenSSL, а на Linux снимает зависимость от системного libssl.
-# webpki-roots несёт корневые сертификаты с собой, так что поведение одинаково
-# на всех платформах и не зависит от системного хранилища.
 tokio-tungstenite = { version = "0.24", features = ["rustls-tls-webpki-roots"] }
-# Провайдер выбирается явно: rustls 0.23 не определяет его сам, если фичи не
+# Explicit ring provider supports Android and static musl without OpenSSL.
-# включают ровно один, и падает паникой при первом TLS-соединении. ring выбран
+rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
-# потому что кросскомпилируется под Android без внешнего тулчейна.
+webpki-roots = "0.26"
-rustls = { version = "0.23", default-features = false, features = [
-  "ring",
-  "std",
-  "tls12",
-] }
 futures-util = "0.3"
 aes = "0.8"
 ctr = "0.9"
@@ -71,3 +68,11 @@ rand = "0.8"
 
 [build-dependencies]
 tauri-build = { version = "2", features = [], optional = true }
+
+[dev-dependencies]
+rcgen = "0.13"
+tokio-rustls = { version = "0.26", default-features = false, features = ["ring", "tls12"] }
+# `start_paused` в тестах: таймаут ожидания запроса от клиента — десять секунд,
+# и ждать их по-настоящему в тесте нельзя. В сборку не попадает: dev-зависимости
+# участвуют только в тестах.
+tokio = { version = "1", features = ["test-util"] }

README.md

@@ -58,6 +58,10 @@
 
 TGLock — это **локальный прокси** на твоём компьютере: принимает и MTProto, и SOCKS5. Он перехватывает соединения Telegram, заворачивает их в WebSocket и отправляет на веб-инфраструктуру Telegram — по нескольким маршрутам сразу, переключаясь на следующий, если текущий перестал отвечать. Провайдер видит обычный HTTPS.
 
+Для CDN DC203 есть отдельный маршрут MTProto TCP к его закреплённому адресу:
+этот CDN может не принимать WebSocket. Если его IP блокируется, остаётся
+настроенный пользователем Worker. Диагностика показывает выбранный транспорт.
+
 **Кому подойдёт:**
 
 - 📱 Telegram открывается через раз, сообщения уходят с задержкой, фото и видео не грузятся
@@ -70,7 +74,7 @@ TGLock — это **локальный прокси** на твоём компь
 
 - ❌ **Голосовые и видеозвонки.** Они идут по UDP, а TGLock проксирует только TCP. Со звонками ничего не изменится
 - ❌ **Всё, кроме Telegram.** YouTube, Discord, Instagram, ChatGPT работать не начнут: TGLock разворачивает только MTProto — протокол, который больше нигде не используется
-- ❌ **Android и iOS.** Своего приложения нет. Телефон можно подключить к TGLock на компьютере через [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру)
+- **Android:** экспериментальный APK и инструкция проверки — [docs/ANDROID.md](docs/ANDROID.md). Работа в фоне на физических устройствах требует проверки. **iOS:** отдельного приложения нет; доступен [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру).
 
 **Чем отличается от VPN:** TGLock работает **только с Telegram**. Остальной трафик идёт напрямую — ничего не замедляется, мобильный трафик не расходуется впустую.
 
@@ -90,7 +94,11 @@ TGLock — это **локальный прокси** на твоём компь
 
 Все сборки весят единицы мегабайт. Исключение — `.AppImage`: он несёт своё окружение и поэтому крупный.
 
-> **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно не создаётся: сервер, контейнер, виртуалка, машина без монитора. Доступен начиная с `v2.0.0-beta.2`. Подробности — [ниже](#-без-графического-интерфейса-tglock-cli).
+Дополнительные проверочные сборки доступны в артефактах GitHub Actions:
+[Android ARM64 APK](docs/ANDROID.md) и [статический ARM64 CLI для OpenWrt](docs/OPENWRT.md).
+Они не означают, что выпущен новый релиз.
+
+> **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно не создаётся: сервер, контейнер, виртуалка, машина без монитора. Доступен начиная с `v2.0.0-beta.2`. Если ты скачал beta.2 и приложение не открывалось — это была ошибка сборки, исправлено в beta.3. Подробности — [ниже](#-без-графического-интерфейса-tglock-cli).
 
 ### 🛡 Антивирус ругается, SmartScreen предупреждает, VirusTotal показывает детекты
 
@@ -107,7 +115,7 @@ TGLock — это **локальный прокси** на твоём компь
 1. **Сверить контрольную сумму.** GitHub публикует `sha256` каждого файла прямо на [странице релиза](https://github.com/by-sonic/tglock/releases/latest) — разверни `Assets` и увидишь digest рядом с именем. Сравни с тем, что скачалось:
 
    ```powershell
-   Get-FileHash .\TGLock_2.0.0-beta.2_x64-setup.exe -Algorithm SHA256
+   Get-FileHash .\TGLock_<версия>_x64-setup.exe -Algorithm SHA256
    ```
 
    ```bash
@@ -117,12 +125,12 @@ TGLock — это **локальный прокси** на твоём компь
 
    Это доказывает, что файл не подменили по пути к тебе.
 
-2. **Посмотреть, как файл собирался.** Бинарники собирает GitHub Actions из публичного коммита, лог открыт и его никто не может отредактировать задним числом. Сборка релиза `v2.0.0-beta.2` — [run 30535555083](https://github.com/by-sonic/tglock/actions/runs/30535555083), коммит `b062724`. Видно, какой исходник взят и какими командами собран.
+2. **Посмотреть, как файл собирался.** Бинарники собирает GitHub Actions из публичного коммита, лог открыт и его никто не может отредактировать задним числом. У каждого релиза на странице Actions есть свой запуск: видно, какой коммит взят и какими командами собран. Ссылка на него — в описании релиза.
 
 3. **Собрать самому.** Для CLI это одна команда и никаких зависимостей кроме Rust:
 
    ```bash
-   cargo build --release --locked --no-default-features --bin tglock-cli
+   cargo build --release --locked --no-default-features --features cli --bin tglock-cli
    ```
 
    Полная сборка с интерфейсом — [ниже](#-сборка-из-исходников).
@@ -155,12 +163,23 @@ Telegram → Настройки → **Продвинутые** → Тип сое
 
 В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
 
-Ссылку `tg://proxy` с уже подставленным адресом TGLock открывает сам при включении — её достаточно переслать себе в Telegram и открыть на телефоне. Если нужен адрес руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
+Когда LAN-режим включён, TGLock показывает в окне **готовый адрес** вида `192.168.1.7:1080` — нажми на него, чтобы скопировать. Плюс он сам открывает ссылку `tg://proxy`, где уже подставлены адрес, порт и секрет: её достаточно переслать себе в Telegram и открыть на телефоне.
+
+> ⚠️ На другом устройстве **не вводи `127.0.0.1`** — для него это оно само, а не твой компьютер. Нужен именно тот адрес, который показан в окне TGLock. Это же касается телефона в эмуляторе (MuMuPlayer, BlueStacks и подобных): внутри эмулятора Android — отдельная машина со своей сетью.
+
+Если адрес нужен руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
 
 Удобно, если дома один компьютер всегда включён — он становится «домашним Telegram-роутером».
 
 В LAN-режиме TGLock пропускает **только адреса Telegram**. Открытым SOCKS5-прокси для всего интернета он при этом не становится — иначе им бы воспользовались не только твои устройства.
 
+> **📵 С телефона не подключается?** Открой **Диагностика** на компьютере и посмотри две цифры.
+>
+> - **Соединения `0` и Отклонено `0`** — телефон до компьютера не дошёл. Дело не в TGLock: проверь, что оба устройства в одной сети (телефон может сидеть на гостевом Wi-Fi или в мобильном интернете), что в роутере не включена изоляция клиентов, и что брандмауэр пускает входящие на порт TGLock.
+> - **Соединения растут, Отклонено растёт** — телефон дошёл, но просит адрес, который LAN-режим не пропускает. Конкретный адрес назван в журнале событий ниже — пришли эту строку в issue.
+> - **Не опознаны растёт** — телефон дошёл, но договориться не вышло. Почти всегда в Telegram на телефоне вписана ссылка от прошлого запуска, то есть другой секрет. Сверь её с той, что показана в окне сейчас.
+> - **Соединения растут, Туннели `0`** — до Telegram не доходит уже сам компьютер. Это [Cloudflare Worker](docs/CLOUDFLARE_WORKER.md), а не проблема LAN.
+
 ### 🖥 Без графического интерфейса: `tglock-cli`
 
 Для сервера, виртуалки, контейнера и машины без монитора или без 3D-ускорения. Это отдельный бинарь, в котором **нет ни Tauri, ни системного WebView** — там, где окно просто не создаётся, CLI работает.
@@ -173,7 +192,31 @@ tglock-cli --worker my-name.workers.dev    # резервный маршрут,
 tglock-cli --help                          # все флаги
 ```
 
-При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
+#### Файл настроек
+
+Чтобы не собирать батник с ключами при каждом запуске ([#32](https://github.com/by-sonic/tglock/issues/32)), положите рядом с бинарём `tglock.toml` — он подхватится сам. Или укажите путь: `tglock-cli --config /etc/tglock.toml`.
+
+```toml
+port = 1080
+lan = true
+
+# Секрет — вторая половина ссылки tg://proxy. Для сервиса его нужно закрепить,
+# иначе после перезапуска все настроенные клиенты отвалятся. Запустите один
+# раз, скопируйте из напечатанной ссылки и вставьте сюда.
+secret = "dd00112233445566778899aabbccddeeff"
+
+worker = ["my-name.workers.dev"]
+```
+
+Полный пример со всеми полями и пояснениями — [`tglock.example.toml`](tglock.example.toml).
+
+Приоритеты: значения по умолчанию → файл → флаги. Флаг всегда сильнее файла. Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только включать: их отсутствие означает «взять из файла», а не «выключить».
+
+Опечатка в файле — ошибка при старте с перечислением допустимых полей, а не молча проигнорированная строка. Сервис, который из-за `porrt = 1443` слушает 1080, хуже сервиса, который не запустился.
+
+Файл с секретом внутри держите с правами `600`: это доступ к вашему прокси.
+
+При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев, сколько запросов отклонено политикой «только Telegram» и сколько клиентов не опознано. Отдельными строками отмечаются подключившиеся устройства, адреса, из-за которых был отказ, и клиенты, с которыми не удалось договориться, — по ним видно, дошёл ли телефон до сервиса вообще и не вписан ли в нём устаревший секрет.
 
 Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
 
@@ -189,7 +232,7 @@ Wants=network-online.target
 
 [Service]
 Type=exec
-ExecStart=/usr/local/bin/tglock-cli --lan --secret-file /var/lib/tglock/secret
+ExecStart=/usr/local/bin/tglock-cli --config /etc/tglock.toml
 Restart=on-failure
 RestartSec=5s
 StateDirectory=tglock
@@ -206,11 +249,14 @@ WantedBy=multi-user.target
 
 ```bash
 sudo install -m755 tglock-cli-x86_64-unknown-linux-gnu /usr/local/bin/tglock-cli
+sudo install -m600 tglock.example.toml /etc/tglock.toml   # и отредактировать
 sudo systemctl enable --now tglock
 journalctl -u tglock -f
 ```
 
-`--secret-file` здесь обязателен, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без файла он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. `StateDirectory=tglock` создаёт `/var/lib/tglock` с нужными правами, а сам файл пишется с режимом `600`.
+**Закреплённый секрет здесь обязателен**, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без него он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. Задайте `secret` в `/etc/tglock.toml` (файл с правами `600`) либо `secret_file = "/var/lib/tglock/secret"` — тогда `StateDirectory=tglock` создаст каталог с нужными правами, а файл запишется с режимом `600`.
+
+При старте без закреплённого секрета CLI печатает предупреждение — молча уйти в такое состояние он не даст.
 
 Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.
 
@@ -220,9 +266,11 @@ journalctl -u tglock -f
 FROM rust:1.88 AS build
 WORKDIR /src
 COPY . .
-RUN cargo build --release --locked --no-default-features --bin tglock-cli
+RUN cargo build --release --locked --no-default-features --features cli --bin tglock-cli
 
 FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
 COPY --from=build /src/target/release/tglock-cli /usr/local/bin/tglock-cli
 EXPOSE 1080
 ENTRYPOINT ["tglock-cli", "--lan", "--secret-file", "/data/secret"]
@@ -232,7 +280,7 @@ ENTRYPOINT ["tglock-cli", "--lan", "--secret-file", "/data/secret"]
 docker run -d --name tglock -p 1080:1080 -v tglock-data:/data tglock
 ```
 
-Образу не нужно вообще ничего: ни Node.js, ни `libwebkit2gtk`, ни даже `ca-certificates` — TLS работает на rustls, а корневые сертификаты вшиты в бинарь.
+Образу не нужны ни Node.js, ни `libwebkit2gtk` — только `ca-certificates` для проверки сертификата Telegram.
 
 ---
 
@@ -256,12 +304,12 @@ Telegram Desktop / mobile (через LAN)
 
 1. **Локальный прокси** принимает соединения Telegram: и MTProto (по ссылке `tg://proxy`), и SOCKS5.
 2. Из первых 64 байт `obfuscated2`-пакета **расшифровывается номер DC** — AES-256-CTR, ключ в байтах `[8..40]`, IV в `[40..56]`, индекс DC — `i16` в `[60..62]`. Отрицательное значение означает медиа-соединение.
-3. Трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это тот же домен, через который работает Telegram Web в браузере.
+3. Основной трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это тот же домен, через который работает Telegram Web в браузере. Для CDN DC203 сначала используется обычный обфусцированный MTProto TCP к закреплённому CDN IP; его WebSocket endpoint может быть недоступен.
-4. **Маршрут выбирается каскадом**, и это главное отличие 2.0 от первой версии. Один домен может резолвиться в недоступный адрес, поэтому по очереди пробуются: закреплённые IP Telegram, их дублёры `kwsN-1`, системный DNS и — если ты его настроил — твой собственный Cloudflare Worker. Упавший маршрут уходит в cooldown с удвоением задержки, удачный запоминается для этого DC. Системный DNS и файл `hosts` при этом **не изменяются**: TCP-соединение идёт на закреплённый IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
+4. **Маршруты проверяются с ограниченным параллелизмом:** сначала запомненный или основной Telegram-маршрут, затем настроенный Worker и резервные адреса. Зависший IP не задерживает все остальные попытки. Упавший маршрут уходит в cooldown с удвоением задержки; при отказе всех маршрутов новые подключения соблюдают эту паузу. Для CDN DC203 сохраняется его собственный адрес. Системный DNS и файл `hosts` **не изменяются**: TCP-соединение идёт на выбранный IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
-5. Провайдер видит **TLS-handshake к `web.telegram.org`** — легитимный HTTPS, MTProto в нём не виден.
+5. На прямых WebSocket-маршрутах провайдер видит **TLS-handshake к `web.telegram.org`**; на Worker-маршруте — домен Worker. Прямой CDN TCP не использует TLS и остаётся доступным для блокировки по IP.
 6. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
 
-> Интерфейс различает три состояния и не выдаёт одно за другое: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«Telegram на связи»** — есть установленный туннель, то есть WebSocket-рукопожатие уже прошло. Смешивание первого и третьего состояния и было основной причиной жалоб «прокси подключён, а Telegram не работает».
+> Интерфейс различает три состояния: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«Telegram на связи»** — есть установленный транспорт: WebSocket после upgrade либо открытое TCP-соединение с CDN. Само это состояние ещё не подтверждает ответ MTProto, авторизацию аккаунта или передачу сообщений.
 
 📖 **Архитектура 2.0, различение протоколов и честный список ограничений** — [docs/ARCHITECTURE_V2.md](docs/ARCHITECTURE_V2.md). Запасной маршрут через свой Cloudflare Worker, со скриптом и пошаговой установкой — [docs/CLOUDFLARE_WORKER.md](docs/CLOUDFLARE_WORKER.md). Разбор всех issue и того, что в них было обещано зря — [docs/ISSUE_AUDIT.md](docs/ISSUE_AUDIT.md). Черновик статьи про переход v1 → v2 лежит в [HABR.md](HABR.md) — цифры там описывают код на момент написания, документацией он не является.
 
@@ -316,12 +364,16 @@ TGLock же отправляет трафик на **`web.telegram.org`** — о
 <details>
 <summary><b>Работает ли на iPhone или Android?</b></summary>
 
-Своего приложения под Android и iOS нет — TGLock только для desktop. Есть два обходных пути:
+Для Android есть [экспериментальный APK](docs/ANDROID.md): локальный MTProto-прокси
+на телефоне, без VpnService. Для iOS отдельного приложения нет. Для обеих платформ
+также доступны два варианта:
 
 1. **LAN-режим на компьютере.** Включи галочку LAN, и в настройках Telegram на телефоне укажи прокси с IP компьютера. Работает, пока компьютер включён и телефон в той же сети.
 2. **`tglock-cli` на своём VPS.** Headless-бинарь запускается как systemd-сервис, слушает `0.0.0.0` и пропускает только адреса Telegram — тогда телефон работает откуда угодно, а не только из дома. См. [раздел про CLI](#-без-графического-интерфейса-tglock-cli).
 
-Поддержка Android обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9), сроков нет: Tauri 2 умеет собирать под Android, но перехват трафика там делается через `VpnService` — это другая архитектура, а не пересборка того же кода.
+Проверка Android продолжается в [#9](https://github.com/by-sonic/tglock/issues/9).
+Особенно важна работа после сворачивания на HyperOS и других прошивках с
+ограничениями фоновых процессов; сборка APK сама по себе этого не проверяет.
 </details>
 
 <details>
@@ -409,7 +461,7 @@ TGLock определяет Telegram по IP получателя и завор
 | **Tauri 2** | Нативная оболочка для GUI. Опциональна: за фичей `gui`, в CLI не входит |
 | **TypeScript + Vite** | Интерфейс, внутренняя навигация и строгая типизация |
 | **tokio** | Async I/O, обработка сигналов для корректной остановки сервиса |
-| **tokio-tungstenite** + **rustls** | WebSocket-клиент с TLS на чистом Rust: без системного OpenSSL, кросскомпилируется под Android, корневые сертификаты вшиты |
+| **tokio-tungstenite** | WebSocket-клиент с rustls, ring и встроенными WebPKI roots |
 | **aes** + **ctr** | Расшифровка MTProto `obfuscated2` init-пакета |
 | **clap** | Разбор аргументов `tglock-cli` |
 
@@ -433,7 +485,7 @@ npm run tauri build
 ### Только CLI, без графики
 
 ```bash
-cargo build --release --locked --no-default-features --bin tglock-cli
+cargo build --release --locked --no-default-features --features cli --bin tglock-cli
 ```
 
 Ни Node.js, ни фронтенда, ни `libwebkit2gtk` для этого не нужно — при выключенной фиче `gui` Tauri и системный WebView в сборку не попадают вообще. Именно так CLI собирается на голом сервере.
@@ -443,12 +495,12 @@ cargo build --release --locked --no-default-features --bin tglock-cli
 ```bash
 cargo fmt --check
 cargo clippy --all-targets -- -D warnings
-cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
+cargo clippy --no-default-features --features cli --all-targets -- -D warnings
 cargo test --all-targets
-cargo test --no-default-features --lib --bins
+cargo test --no-default-features --features cli --lib --bins
 ```
 
-Тестов 59: разбор `obfuscated2`, каскад маршрутов и его cooldown, протокольные отказы SOCKS5, устойчивость секрета к перезапуску, плюс сквозной тест туннеля против мок-сервера, который реализует сторону Telegram и проверяет, что до неё доходит ровно тот открытый текст, который отправил клиент. Единственный тест с пометкой `#[ignore]` — тот, что требует живой сети.
+Проверяются `obfuscated2`, выбор маршрутов и cooldown, отказы SOCKS5, сохранение и миграция секрета, двунаправленный туннель, TLS-сертификаты и SNI. `npm run test:worker` проверяет скрипт Cloudflare. Android и ARM64 CLI собираются отдельными заданиями; результаты и ограничения проверки перечислены в [аудите issues](docs/ISSUES_2026-09-19.md). Тесты с `#[ignore]` требуют живой сети.
 
 ### Свой релиз через GitHub Actions
 
@@ -465,7 +517,9 @@ cargo test --no-default-features --lib --bins
 - **Присылаешь PR** — перед отправкой прогони проверки выше, они те же, что в CI. Небольшие PR ревьюятся быстрее.
 - **Не работает после релиза** — это регрессия, пиши сразу, такие вещи в приоритете.
 
-Известные ограничения, о которых не нужно открывать issue: звонки (UDP), сервисы кроме Telegram (только MTProto), Android и iOS (обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9)).
+Известные ограничения: звонки (UDP), сервисы кроме Telegram (только MTProto),
+отсутствие отдельного приложения iOS. Android пока экспериментальный;
+результаты проверки устройств собираются в [#9](https://github.com/by-sonic/tglock/issues/9).
 
 ---
 

capabilities/default.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../gen/schemas/desktop-schema.json",
   "identifier": "default",
-  "description": "TGLock desktop window",
+  "description": "TGLock application window",
   "windows": ["main"],
   "permissions": ["core:default"]
 }

docs/ANDROID.md

@@ -0,0 +1,76 @@
+# Android (experimental)
+
+Issue #9 is implemented as a Tauri Android application sharing the current Rust
+proxy engine and UI with the desktop application. The old Android PR scaffold is
+retained, but its stale engine and desktop code are not imported.
+
+## Install a test APK
+
+Open this PR's **Android APK** check, then the workflow run's **Artifacts** section.
+Download `tglock-android-arm64-debug`, unzip it, and install the `.apk` on an
+ARM64 Android 7.0+ device. GitHub requires signing in to download CI artifacts.
+No compiler or Android Studio is needed on the phone. The artifact expires after
+14 days; maintainers can rerun the workflow to create a fresh build.
+
+This is an automatically debug-signed test build, not a Play Store release.
+Different CI runs can use different debug signing keys: if Android rejects an
+update because the signatures differ, uninstall the previous test build first.
+Uninstalling deletes settings and changes the proxy secret, so reconnect Telegram
+with the new link. A future production release needs a stable signing key.
+
+1. Open TGLock and press **Включить защиту**.
+2. Accept the proxy in Telegram when prompted. If opening Telegram fails, return
+   to TGLock and use **Открыть Telegram** or **Скопировать ссылку**.
+3. Keep LAN access off when Telegram runs on this same phone (`127.0.0.1`).
+4. To stop, return through the ongoing notification and press **Выключить**.
+
+## Lifecycle and limitations
+
+The native foreground service starts only for an explicitly started proxy and
+stops when its Rust accept loop finishes, including a normal Stop action. It is
+not stopped by Activity destruction or rotation. Android 14+ declares the
+`specialUse` service type, its dedicated permission, and a subtype describing the
+user-controlled local proxy. Notification permission denial does not prevent the
+foreground service from running; Android still exposes it in its task manager.
+
+The service uses `START_NOT_STICKY`: after Android kills the process or the user
+force-stops it, it does not restart a notification without a Rust engine. Open
+TGLock and enable protection again. No boot receiver or automatic background
+restart is installed. Vendor battery management and network changes may still
+interrupt connections. The app does not claim to be a device-wide VPN.
+
+The proxy secret lives in the app's private configuration directory. Desktop
+installs migrate an existing valid legacy secret, preserving saved Telegram
+links. The link-copy control intentionally contains this secret; the public
+report-copy control includes only counters, port, route and mode.
+
+## Build and verification
+
+CI uses Java 17, Android SDK 36, NDK 28, Rust 1.88, and the locked npm/Rust
+manifests. `npm run tauri -- android build --debug --apk --target aarch64 --ci`
+bundles the frontend inside a signed APK; no development web server is required.
+CI verifies the signature and the presence of each architecture's Rust library.
+The x86_64 build is installed on an Android 15 emulator. The bounded smoke checks
+Activity launch, process survival, and crash/ANR logs. When UIAutomator exposes
+the WebView buttons, it also checks Start, five seconds in the background, Stop,
+restart, and explicit force-stop/relaunch. It verifies the foreground service and
+performs a real SOCKS5 greeting through ADB port forwarding to the Rust listener.
+If buttons are inaccessible after a bounded wait, CI explicitly reports the
+lifecycle checks as skipped; a launch-only pass is not lifecycle evidence.
+`android-emulator-smoke-evidence` retains the exact result, UI dumps, service
+state and logcat. This does not test automatic low-memory eviction, battery
+behavior, Telegram connectivity, or a physical phone.
+
+Checked-in `gen/android` contains the native source and Gradle wrapper. Tauri's
+machine-specific generated glue, SDK paths, native build output and signing files
+remain ignored. Run the same build command locally after installing Tauri's
+[Android prerequisites](https://v2.tauri.app/start/prerequisites/#android).
+
+No physical-phone or Telegram end-to-end test has been performed by this change.
+Before promoting it beyond an experimental APK, test Android 13 notification
+permission grant/denial, Android 14+ service startup, Start/Stop/restart, switching
+to Telegram for at least 10 minutes, rotation, Activity recreation, process death,
+Wi-Fi/mobile-data handover, and restoration with the same persisted secret.
+
+Native bridging follows [Tauri mobile plugins](https://v2.tauri.app/develop/plugins/develop-mobile/)
+and uses [Tauri opener](https://v2.tauri.app/plugin/opener/) for `tg://` links.

docs/ARCHITECTURE_V2.md

@@ -55,6 +55,125 @@ LAN-режим превращал бы машину в открытый прок
 `config::ListenConfig`, а не в условиях по месту вызова; переопределяется
 только явным `--allow-direct` в CLI.
 
+### Что считается адресом Telegram
+
+Список сетей — опубликованный самим Telegram
+(<https://core.telegram.org/resources/cidr.txt>), он лежит в `telegram_net` и
+проверяется по маске префикса. До 2.0.0-beta.9 сравнивались два первых октета,
+то есть «телеграмом» считались целиком `149.154.0.0/16`, `91.108.0.0/16`,
+`91.105.0.0/16` и `185.76.0.0/16`, а IPv6 не распознавался вовсе. Ошибка была в
+обе стороны:
+
+- чужие адреса внутри этих `/16` уходили в MTProto-туннель и умирали там;
+- настоящие адреса дата-центров по IPv6 отклонялись как посторонние.
+
+Второе и давало «на компьютере работает, с телефона нет» (#42): на loopback
+неопознанный адрес всё равно релеился напрямую, поэтому там дефект не
+проявлялся, а на сетевом слушателе тот же адрес получал отказ.
+
+Назначение делится на три вида:
+
+| Вид | Что это | Что делаем |
+|---|---|---|
+| Дата-центр | IP из опубликованных сетей, v4 или v6 | заворачиваем в WebSocket |
+| Веб Telegram | имя из `telegram.org`, `t.me`, `telegram.me`, `telesco.pe`, `cdn-telegram.org` | пропускаем как есть — это обычный HTTPS, а не MTProto |
+| Всё остальное | — | напрямую на loopback, отказ на сетевом адресе |
+
+Имена сопоставляются по границе метки, поэтому `telegram.org.example.com` —
+посторонний домен. В ограниченном режиме имя разрешается заранее, и адреса
+внутри локальной сети (`127.0.0.0/8`, `10/8`, `172.16/12`, `192.168/16`,
+`100.64/10`, `fc00::/7`, `fe80::/10`) отбрасываются: назначение выбирает чужое
+устройство, и DNS-ответ не должен превращать TGLock в дверь во внутреннюю сеть
+этой машины.
+
+### Отказ перестаёт быть молчаливым
+
+Отклонённый запрос увеличивает счётчик `blocked` и один раз называет адрес в
+журнале; повторы того же адреса склеиваются, чтобы не забить журнал одной
+строкой. Отдельно отмечается первое подключение с каждого сетевого адреса.
+
+Без этого «с телефона не работает» неразличимо распадалось на два случая:
+телефон не дошёл до машины (сеть, брандмауэр, изоляция клиентов на роутере) —
+и дошёл, но попросил адрес, который мы не пропускаем. Первый виден как ноль
+соединений и ноль отказов, второй — как соединения есть, отказы растут.
+
+Третий случай нашёлся, когда репортёр #42 прислал диагностику: у него было ноль
+отказов и работающие туннели, то есть оба счётчика говорили «всё хорошо».
+Клиент, который дошёл до прокси, но не сумел договориться, не попадал ни в
+один из них. Соединение просто закрывалось: `active` дёргался вверх и обратно.
+
+Теперь такие клиенты считает `unknown_clients`, и журнал называет адрес и
+причину. Их две:
+
+- MTProto-init не разбирается под текущим секретом. Почти всегда это ссылка
+  `tg://proxy` от прошлого запуска: секрет — её половина, и клиент со
+  сохранённой старой ссылкой попадает ровно сюда. Со стороны Telegram это и
+  есть «прокси настроен неверно и будет отключён» (#37).
+- SOCKS5-приветствие не разбирается. Сюда же попадает MTProto-соединение,
+  ушедшее в SOCKS5-ветку по неоднозначному первому байту, если полный init не
+  успел прийти за `PROTOCOL_PROBE_TIMEOUT`.
+
+Счётчик `ws_failures` от них отличается тем, что растёт после успешного
+рукопожатия с клиентом: там договорились с клиентом, но не смогли с Telegram.
+
+### Почему не поднялся туннель
+
+`ws_failures` говорит, что каскад маршрутов упал целиком, и молчит о причине.
+Текст с перечислением попыток собирался в `TransportEngine::connect` и там же
+пропадал: наверх уходил `Err`, который выбрасывался в `serve`. При `туннелей 0`
+и растущих сбоях отличить «провайдер режет закреплённые адреса» от «воркер
+отвечает отказом» было нечем — ровно та стена, в которую упёрся репортёр #50.
+
+Теперь причина попадает в журнал одной строкой на каждый набор отказов:
+
+```
+Не поднялся туннель до DC2: 149.154.167.51 — не отвечает (таймаут TCP);
+kws2.web.telegram.org — таймаут TLS/WebSocket; my.workers.dev — рукопожатие
+WebSocket: HTTP error: 403 Forbidden
+```
+
+Дедупликация журнала делает эту строку разовой: маршруты у DC стабильны, и
+повтор той же комбинации отказов не пишется.
+
+Домены Cloudflare Worker отчитываются так же. Строка, не похожая на имя хоста,
+раньше отбрасывалась молча — `https://name.workers.dev/` со схемой или слэшем не
+проходит `valid_domain`, маршрут не появлялся, и «воркер настроен» ничем не
+отличалось от «воркера нет». Теперь отвергнутая строка называется вместе с
+причиной, а принятая подтверждается: `Cloudflare Worker в списке маршрутов:
+name.workers.dev`.
+
+## Туннель: два независимых направления
+
+Каждое клиентское соединение получает свой WebSocket-туннель, и внутри него
+данные идут в обе стороны сразу. До 2.0.0-beta.12 оба направления обслуживал
+один `select!` с пометкой `biased`, и это давало два дефекта, снаружи
+выглядевших одинаково: «Подключено», а ничего не идёт.
+
+`biased` опрашивает ветки строго по порядку. Пока в первой — «Telegram →
+клиент» — есть данные, до второй очередь не доходит вообще. То есть при
+непрерывном потоке вниз (первичная синхронизация телефона, загрузка медиа)
+исходящие пакеты клиента не читались.
+
+Второй дефект — одна задача на оба направления. `tcp_w.write_all` ждёт, пока
+клиент разберёт присланное, и всё это время не опрашивается чтение от клиента.
+Телефон по Wi-Fi разбирает поток медленнее, чем Telegram Desktop на той же
+машине через loopback, — отсюда асимметрия «на компьютере работает, на телефоне
+нет» из #42.
+
+Для MTProto это фатально: клиент обязан слать подтверждения, а за каждым
+следующим куском файла — свой `upload.getFile`. Первый запрос уходит, дальше
+идёт поток вниз, и следующие запросы наверх не попадают. Загрузка встаёт при
+живом туннеле, нулевых сбоях и нулевых отклонениях — ровно картина из #32.
+
+Теперь это две независимые половины: `ws.split()` плюс `CryptoContext::split()`,
+потому что шифры направлений независимы — два потока AES-CTR со своими ключами.
+Ping приходит в читающую половину, а отвечает на него пишущая, через канал на
+четыре слота: владелец отправляющей половины должен оставаться ровно один.
+
+Оба дефекта закрыты тестами, которые падают на beta.11. Первый: за пять секунд
+непрерывной загрузки наверх не уходит ни одного байта. Второй: клиент, не
+успевающий читать, замораживает собственную отправку.
+
 ## Учёт состояния
 
 `Stats::ws` считает **установленные** туннели: счётчик поднимается после
@@ -63,6 +182,14 @@ LAN-режим превращал бы машину в открытый прок
 несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
 «туннель установлен» различимы и в GUI, и в выводе CLI.
 
+Дата-центр и маршрут пишутся **одним значением**, в момент, когда туннель
+поднялся. Пока это были два независимых поля, номер писало соединение при
+разборе init, а маршрут — другое соединение после рукопожатия, и при десятках
+одновременных соединений в строку статуса попадала пара из разных из них.
+Читалась она как «до этого DC шли этим маршрутом», хотя означала другое: в
+диагностике #42 встречались строки `DC5 · Запасной Telegram IP`, а у DC5
+закреплённый адрес всего один и запасного у него не бывает вовсе.
+
 Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
 файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
 путь по умолчанию не определяется, и секрет генерировался бы заново при каждом
@@ -74,35 +201,38 @@ LAN-режим превращал бы машину в открытый прок
 
 1. сохранённый успешный маршрут;
 2. точный Telegram IP с `kwsN` или `kwsN-1` в TLS SNI и WebSocket Host;
-3. дополнительный Telegram IP, если он определён;
+3. явно настроенный пользователем Cloudflare Worker;
-4. системный DNS;
+4. дополнительные Telegram IP и варианты хоста;
-5. явно настроенный пользователем Cloudflare Worker.
+5. системный DNS (кроме CDN DC203).
 
-Поддерживаются DC1–5 и media/CDN DC203. DC203 использует WebSocket-host DC2,
+Поддерживаются DC1–5 и CDN DC203. Для DC203 первым используется обычный MTProto
-но подключается к собственному IP.
+TCP к закреплённому `91.105.192.100:443`; этот сервер может принимать MTProto,
+не принимая TLS/WebSocket. Резерв через Worker соединяется с тем же IP.
+WebSocket-попытки также сохраняют закреплённый адрес. DNS fallback на DC2 для DC203 запрещён:
+успешный WebSocket handshake с другим DC не доставляет CDN-запрос в нужный
+датацентр. Worker также получает именно IP DC203.
 
 После ошибки маршрут получает exponential cooldown от 30 секунд до 30 минут.
 Успешный маршрут становится первым для следующего соединения того же DC и
-типа трафика.
+типа трафика. Попытки запускаются с интервалом 250 мс, не больше трёх
+одновременно на соединение; остальные отменяются после первого успеха.
+Если все маршруты на паузе, возвращается причина и время до повторной
+попытки. Новое подключение клиента не обходит cooldown. Ошибка upstream
+после handshake также снимает предпочтение маршрута и добавляет cooldown.
 
 ## TLS policy
 
 Проверка сертификатов и hostname никогда не отключается. При подключении к
 заданному Telegram IP TCP destination отделён от URI host: TLS продолжает
-проверять сертификат настоящего `kws*.web.telegram.org`.
+проверять сертификат настоящего `kws*.web.telegram.org`. Используется rustls
+с провайдером ring и встроенными WebPKI roots; системный OpenSSL для ядра
+и CLI не нужен. Собственные корневые сертификаты ОС автоматически не
+подхватываются. Тесты проверяют доверенный сертификат, SNI, неверное имя
+хоста и недоверенного издателя.
 
-Стек — **rustls** с корневыми сертификатами webpki, вшитыми в бинарь. Выбран не
+Это относится к TLS-маршрутам. Прямой CDN TCP — отдельный транспорт MTProto,
-из вкуса: `native-tls` на Linux и Android тянет OpenSSL, а `openssl-sys` не
+а не TLS с отключённой проверкой. Он доступен только для точного назначения
-кросскомпилируется под `aarch64-linux-android` без сборки OpenSSL вручную.
+DC203. Для произвольных адресов такой обход политики не добавляется.
-Побочные выгоды: на Linux исчезла зависимость от системного `libssl`, а образу
-Docker больше не нужен даже `ca-certificates`.
-
-Криптопровайдер rustls выбирается явно (`ring`). Без этого rustls 0.23
-отказывается угадывать и **паникует на первом TLS-рукопожатии** — это не
-ошибка компиляции и её не видят офлайновые тесты, потому что они ходят через
-локальный маршрут без TLS. Провайдер устанавливается в `ensure_crypto_provider`
-перед подключением, а тест `a_crypto_provider_is_available_for_tls` не даёт
-регрессии вернуться.
 
 Cloudflare Worker принимается только как пользовательская настройка. TGLock
 не загружает и не скрывает публичные списки чужих доменов.
@@ -115,9 +245,19 @@ Worker должен принимать WebSocket на:
 /apiws?dst=<telegram-ip>&dc=<dc-id>
 ```
 
-и проксировать бинарные frames в TCP `<telegram-ip>:443`. Рекомендуется
+и проксировать бинарные frames в TCP `<telegram-ip>:443`. Ответ 101 отправляется
-добавить собственную авторизацию до стабильного релиза; поэтому Worker
+после открытия upstream TCP; таймаут/отказ — HTTP 504/502. Список назначений
-остаётся расширенной опцией alpha-версии.
+фиксирован, текстовые сообщения отклоняются. Очередь входящих записей ограничена
+1 МиБ и 256 сообщениями. Авторизация токеном требует собственного клиента:
+штатный TGLock токен Worker пока не передаёт.
+
+Запись в сокет Telegram обязана быть последовательной: следующий чанк уходит
+после того, как записан предыдущий, и только когда писатель к этому готов
+(`writer.ready`). В `worker/tglock-worker.js` этого не было — `write()`
+вызывался поверх незавершённого, без backpressure. Пока в клиенте голодала
+отправка, настоящего потока вверх через воркер не возникало и это не
+проявлялось; после того как голодание починили, поток появился. Кто разворачивал
+воркер раньше — обновите скрипт.
 
 ## Current limitations
 
@@ -141,5 +281,9 @@ Worker должен принимать WebSocket на:
   CLI собирается одной командой. Подробно — в разделе README про антивирус.
 - Работоспособность медиа зависит от конкретного DC аккаунта и доступности
   Telegram/Cloudflare у провайдера.
+- Соединение, открытое клиентом и молчащее дольше `IO_TIMEOUT` (10 секунд),
+  закрывается. Для клиента, открывающего соединения про запас, это норма; счётчик
+  «промолчали» показывает, как часто это происходит, — раньше такие соединения
+  не попадали никуда.
 - Пулы заранее открытых WebSocket-соединений будут добавлены после измерения,
   что они не создают лишнюю нагрузку и не ухудшают стабильность.

docs/CLOUDFLARE_WORKER.md

@@ -37,10 +37,14 @@
 
 ### Проверка, что воркер жив
 
-Открой в браузере `https://tglock.имя.workers.dev/apiws`. Должно вернуться `expected a websocket upgrade` — это правильный ответ: значит код развёрнут и работает, просто браузер пришёл обычным запросом.
+Открой в браузере `https://tglock.имя.workers.dev/apiws`. Должно вернуться `expected a websocket upgrade` (HTTP 426). Это проверяет только публикацию скрипта. Соединение Worker → Telegram обычный GET **не проверяет**.
 
 Если вернулось `not found` — проверь, что путь именно `/apiws`. Если ошибка про `cloudflare:sockets` — у воркера слишком старая дата совместимости, поставь в **Settings → Compatibility date** сегодняшнюю.
 
+> **Обнови скрипт при переходе с beta.14.** Теперь Worker ждёт открытия TCP к Telegram перед ответом 101: отказ возвращает 502, таймаут за 3 секунды — 504. Очередь записи ограничена 1 МиБ / 256 сообщениями; переполнение закрывает соединение с кодом 1009, ошибки сокета — 1011. Старый Worker мог показать успешное соединение ещё до попытки подключения к Telegram и не ограничивал очередь сообщений.
+
+Для установки через Wrangler есть [`worker/wrangler.toml`](../worker/wrangler.toml). Из каталога `worker` можно выполнить `npx wrangler deploy` в своём Cloudflare-аккаунте. Эта команда публикует Worker; локальные тесты ничего не публикуют.
+
 ## Подключение в TGLock
 
 **В приложении:** Настройки → поле **Cloudflare Worker** → вставь `tglock.имя.workers.dev` → Сохранить. Настройки меняются только при выключенной защите.
@@ -52,13 +56,13 @@ tglock-cli --worker tglock.имя.workers.dev
 tglock-cli --worker первый.workers.dev --worker второй.workers.dev
 ```
 
-Worker всегда пробуется **последним**, после всех маршрутов Telegram. Пока обычные маршруты живы, трафик через него не пойдёт, и это осознанно: чужая инфраструктура в цепочке — это лишнее звено, а не улучшение.
+Настроенный Worker участвует в ограниченном параллельном переборе маршрутов: его проверка начинается вслед за первым Telegram-маршрутом, без ожидания всех таймаутов. Успешный маршрут запоминается. При быстром ответе Telegram Worker не нужен; при медленном прямом маршруте может победить Worker. Поэтому добавляй только свой домен или домен доверенного оператора.
 
 ## Ограничение доступа
 
-Адрес воркера сам по себе секрет, но лучше поставить токен: **Settings → Variables → Add variable**, имя `TGLOCK_TOKEN`, значение — любая длинная строка.
+Адрес Worker не является механизмом авторизации. Для своего клиента можно задать секрет `TGLOCK_TOKEN` в настройках Cloudflare и передавать его параметром `token`.
 
-Пока переменная не задана, проверка токена выключена. Когда задана — воркер начнёт отвечать `403` без параметра `?token=`. Клиент TGLock этот параметр пока не отправляет, так что включать токен есть смысл, если ты правишь и сам скрипт, и адрес.
+Штатный клиент TGLock параметр `token` пока не отправляет. **Не задавай TGLOCK_TOKEN для штатного клиента:** это приведёт к HTTP 403. При отсутствии переменной любой, кто знает домен, может использовать Worker для разрешённых адресов Telegram и расходовать лимиты твоего аккаунта.
 
 Независимо от токена воркер соединяется **только** с семью адресами Telegram, которые запрашивает TGLock. Любой другой `dst` получает `403`, так что открытым TCP-прокси он не станет.
 
@@ -74,6 +78,7 @@ Sec-WebSocket-Protocol: binary
 - `dst` — адрес Telegram, к которому нужно подключиться по TCP на порт 443;
 - `dc` — номер датацентра, для логов;
 - **подпротокол `binary` обязательно нужно подтвердить в ответе** — без этого клиент разорвёт рукопожатие;
+- ответ 101 означает, что TCP к разрешённому Telegram IP уже открыт; HTTP 502/504 означает отказ/таймаут этого подключения;
 - дальше бинарные frames пересылаются в обе стороны без изменений;
 - TLS до самого воркера обеспечивает Cloudflare.
 
@@ -83,4 +88,6 @@ Sec-WebSocket-Protocol: binary
 
 Скрипт написан по контракту, вычитанному из исходников клиента, и путь с параметрами закреплён тестом `connects_through_the_documented_worker_contract` — он поднимает локальный сервер, который ведёт себя ровно так, как описано выше, и проверяет, что туннель через него поднимается и данные доходят в обе стороны.
 
-Чего этот тест не проверяет: развёрнутый воркер в самом Cloudflare. Если что-то не сойдётся с их API — [открой issue](https://github.com/by-sonic/tglock/issues/new), поправлю.
+`npm run test:worker` дополнительно исполняет настоящий файл Worker с заменой платформенных API: проверяет готовность TCP, отказ, таймаут, обе стороны передачи, порядок записи, переполнение и закрытие сокета. API `opened` и `close()` описаны в [документации Cloudflare](https://developers.cloudflare.com/workers/runtime-apis/tcp-sockets/).
+
+Эти тесты не проверяют развёрнутый Worker в Cloudflare и доступность Telegram из конкретного региона. Если ошибка остаётся, приложи версию клиента, диагностическую строку и HTTP/close-код Worker. Секрет прокси и приватные адреса Worker перед публикацией убери.

docs/ISSUES_2026-09-19.md

@@ -0,0 +1,78 @@
+# Открытые issues: исправления и проверка, 19 сентября 2026
+
+База: `8617d25`, версия `2.0.0-beta.14`. Проверены все семь открытых issues
+и существующие PR #36 (Android), #49 (секрет GUI). Эта работа готовится как PR,
+без слияния, публикации релиза и автоматического закрытия жалоб.
+
+## Что изменено
+
+| Issue | Подтверждённая проблема / выполненная работа | Проверка и предел вывода |
+|---|---|---|
+| #59 — 11 тысяч неудачных соединений | Все маршруты в cooldown раньше приводили к немедленной новой попытке. Теперь пауза соблюдается; зависшие соединения не блокируют резервные | Тесты времени, числа параллельных попыток, отмены проигравших. Доступность Telegram у автора issue не проверена |
+| #58 — Worker, туннели 0/1 | Worker отвечал 101 до открытия TCP; ошибки после handshake терялись | Worker 502/504 и диагностические WebSocket close-коды, Rust-тесты раннего закрытия и reset. HTTP 426 проверяет только публикацию Worker |
+| #50 — ни один маршрут не работает | Последовательные TCP/TLS таймауты задерживали резерв; кратковременные туннели ошибочно сохраняли предпочтение маршрута | Ограниченный параллелизм, cooldown после upstream failure, ошибки Worker. Нельзя обещать обход, когда недоступны и Telegram, и собственный Worker |
+| #42 — Android через LAN | Прежние duplex-исправления уже в main; потеря ошибок upstream скрывала дальнейший отказ | Независимый Android-compatible криптографический вектор, фрагментированные init и одновременная передача 128/256 КиБ, диагностика разрывов. Нужна проверка Play Market-клиента в сети репортёра |
+| #32 — медиа | DC203 fallback через DNS попадал в DC2, хотя CDN имеет свой DC и ключи; на закреплённом CDN IP WebSocket не отвечает, но обычный MTProto TCP работает | DC203 использует точный CDN IP по TCP с преобразованием transport-шифрования; Worker остаётся резервом. Проверка живым req_pq/resPQ и тесты обеих сторон. Реальные фотографии аккаунта репортёра не проверены |
+| #53 — статическая aarch64 | Системный OpenSSL мешал самостоятельной musl-сборке | rustls + ring, ARM64 CI с проверкой ELF и запуском CLI, артефакт и OpenWrt-инструкция. Физический NanoPi R4S не проверен |
+| #9 — Android | Старый PR отстал от main, сборка требовала ручной настройки; жизненный цикл сервиса мог останавливать прокси или оставлять ложное уведомление | Перенос актуального ядра, foreground service по состоянию прокси, APK CI, постоянный секрет в каталоге приложения. HyperOS и длительная фоновая работа требуют устройства |
+
+Дополнительно: журнал больше не замолкает после первых 64 разных событий;
+Unicode-секрет больше не вызывает panic; GUI сохраняет секрет
+в каталоге приложения с миграцией прежнего файла; npm lock обновляет уязвимый
+транзитивный `nanoid` без смены версии приложения.
+
+## Протокол и доверие
+
+- TLS проверяет имя из WebSocket URI даже при подключении к закреплённому IP.
+  Переход на rustls использует встроенные WebPKI roots; системные пользовательские
+  корневые сертификаты автоматически не импортируются.
+- Прямой маршрут CDN203 использует обычный MTProto TCP к одному закреплённому
+  адресу, без TLS-обёртки. Ключи и шифрование содержимого Telegram не меняются;
+  снимается только transport-obfuscation локального прокси и накладывается
+  transport-obfuscation сервера. Если провайдер блокирует CDN IP, нужен Worker.
+- [Telegram WebSocket](https://core.telegram.org/mtproto/transports#websocket)
+  является потоком байтов. Границы TCP read и WS messages не обязаны совпадать
+  с MTProto-пакетами; дополнительный парсер пакетов не добавлялся.
+- [CDN DC](https://core.telegram.org/cdn) требует соответствующего назначения;
+  успешный handshake другого DC не доказывает работоспособность медиа.
+- Worker остаётся опциональной инфраструктурой пользователя. Домен не является
+  авторизацией; `TGLOCK_TOKEN` не поддерживается штатным клиентом.
+
+## Воспроизводимые проверки
+
+```text
+npm ci
+npm run test:worker
+npm run build
+cargo fmt --check
+cargo clippy --locked --all-targets -- -D warnings
+cargo test --locked --all-targets
+cargo clippy --locked --no-default-features --features cli --all-targets -- -D warnings
+cargo test --locked --no-default-features --features cli --lib --bins
+```
+
+CI дополнительно проверяет MSRV 1.88, состав macOS GUI bundle, статическую
+ARM64 musl-сборку, подпись/содержимое Android debug APK и запуск на Android 15
+эмуляторе. Пропуск UI lifecycle отмечается отдельно от успешного запуска. Конкретные результаты
+и ссылки на прогоны фиксируются в описании PR после завершения CI.
+
+Worker: `npm run test:worker` исполняет настоящий deployment-файл с подменой
+только Cloudflare API; `wrangler deploy --dry-run` проверяет сборку без публикации.
+Это не тест живого Cloudflare-аккаунта. Отдельный тест Rust поднимает локальный
+WebSocket и проверяет совместимость клиента с контрактом Worker.
+
+Для проверки реального бинаря без Telegram-аккаунта добавлен
+[независимый Node.js probe](LIVE_PROBE.md). Он проверяет `req_pq_multi → resPQ`,
+nonce и целостность ответа; это ещё не авторизация и не скачивание медиа.
+
+## Что нужно проверить на устройствах
+
+Android: установка APK, старт/стоп, ссылка в Telegram, сохранение секрета после
+перезапуска, передача текста/медиа, работа в фоне 15 минут и политика батареи.
+OpenWrt: запуск CLI на NanoPi R4S, подключение нескольких устройств по LAN,
+перезапуск сервиса с прежним секретом. Инструкции: [Android](ANDROID.md),
+[OpenWrt](OPENWRT.md).
+
+Issues о пользовательских симптомах остаются открыты до этой проверки.
+Наличие исправленного дефекта и зелёных регрессий не доказывает, что в конкретной
+сети отсутствует дополнительная блокировка.

docs/ISSUE_AUDIT.md

@@ -1,5 +1,8 @@
 # TGLock 2.0 issue audit
 
+Актуальный разбор семи открытых issues и границ проверки:
+[19 сентября 2026](ISSUES_2026-09-19.md). Ниже сохранены исторические записи.
+
 Проверено 29 июля 2026 года: все 15 issues и 5 pull requests, существовавшие
 в репозитории на момент аудита.
 
@@ -41,6 +44,44 @@
 > кодом, LAN-режим ограничен адресами Telegram на уровне типа, Cloudflare Worker
 > остаётся исключительно пользовательской настройкой.
 
+> **Статус на 19 августа 2026.** С прошлой отметки вышли beta.6, beta.7,
+> beta.8 и beta.9. Что закрыто и что осталось:
+>
+> - **#32 (медиа).** Файл настроек `tglock.toml` сделан в beta.6 — это была
+>   отдельная просьба из того же issue. Заодно исправлена паника `println!` при
+>   закрытом stdout. Причина проблем с медиа не подтверждена: репортёр не
+>   прислал строку статуса в момент, когда фото не грузится. Слабое место
+>   названо в самом issue — у DC203 закреплён один IP, резерва по адресам для
+>   медиа нет.
+> - **#37 («прокси настроен неверно»).** В beta.7 перестала проглатываться
+>   ошибка записи секрета: раньше при неудачной записи в `%APPDATA%\TGLock`
+>   секрет молча генерировался заново при каждом запуске, и ссылка `tg://proxy`
+>   переставала совпадать с сохранённой в Telegram. Это гипотеза, а не
+>   подтверждённый диагноз — воспроизвести случай репортёра не удалось, но
+>   теперь видно, тот это случай или нет.
+> - **#39 (не работает).** По скриншоту: соединения есть, DC определяется,
+>   туннелей ноль, 678 падений маршрутов за пять минут. Наружу не отвечает ни
+>   один маршрут — у провайдера заблокирована веб-инфраструктура Telegram
+>   целиком. Кодом это не лечится, остаётся свой Cloudflare Worker. Счётчик
+>   падений маршрутов, по которому это стало видно, появился в beta.7.
+> - **#40, #41 (свои).** В LAN-режиме окно показывает готовый адрес для других
+>   устройств — люди искали его в интерфейсе и вписывали `127.0.0.1`. И страж
+>   тега в CI, который ловит тег, поставленный не на HEAD.
+> - **#42 (LAN не работает с телефона).** Нашлось в коде. Принадлежность адреса
+>   Telegram проверялась по двум первым октетам, то есть «телеграмом» считались
+>   целиком четыре `/16`, а IPv6 не распознавался вовсе. На loopback это не
+>   проявлялось: неопознанный адрес там всё равно релеится напрямую. На сетевом
+>   слушателе тот же адрес получал отказ — отсюда ровно то, что описал
+>   репортёр: на компьютере работает, с телефона нет. В beta.9 список сетей
+>   взят опубликованный Telegram, добавлены IPv6 и имена веб-инфраструктуры.
+>   Отказ перестал быть молчаливым: счётчик «Отклонено» и адрес в журнале.
+> - **#9 (Android)** остаётся открытым. PR #36 собирает APK, но приложение
+>   никто ни разу не запускал — нужен человек с телефоном.
+>
+> Общее по трём разобранным issue: во всех трёх диагноз упирался в то, что
+> программа не рассказывала о себе достаточно. Каждый выпуск с beta.7 добавлял
+> не функцию, а показание прибора.
+
 ## Выводы
 
 Главная причина жалоб «прокси подключён, но Telegram не работает» — приложение

docs/LIVE_PROBE.md

@@ -0,0 +1,61 @@
+# Manual protocol probe
+
+`scripts/probe_proxy.mjs` uses only Node.js built-ins and is independent of the
+Rust transport helpers. It connects to an already running TGLock listener at
+`127.0.0.1`, sends one unauthenticated `req_pq_multi` through a secret-protected
+obfuscated2 padded-intermediate stream, and validates the returned `resPQ`, its
+request nonce, and the lengths of its TL fields. It stops before creating an
+authorization key. No Telegram account, API ID, API hash or login is needed.
+
+The secret is read from an explicitly supplied file and is never printed. Use
+the same secret file as the running CLI. Do not paste proxy links or secret
+values into public logs.
+
+```sh
+# Offline validation first: no network access.
+node scripts/probe_proxy.mjs --self-test
+
+# Start a local CLI separately, using a persistent secret file.
+tglock-cli --port 18080 --secret-file /private/path/tglock-secret
+
+# Ordinary DC, media route, and CDN route; run each explicitly.
+node scripts/probe_proxy.mjs --port 18080 --secret-file /private/path/tglock-secret --dc 2
+node scripts/probe_proxy.mjs --port 18080 --secret-file /private/path/tglock-secret --dc -4 --fragment-size 7
+node scripts/probe_proxy.mjs --port 18080 --secret-file /private/path/tglock-secret --dc 203
+```
+
+On Windows, supply the downloaded CLI executable and a Windows file path in the
+same commands. Supported DC values are `1` through `5` and `203`; a negative
+value requests a media route. `--timeout-ms` defaults to 15000 and is bounded at
+120000. The response is bounded at 2 MiB. `--fragment-size 7` sends small writes
+with 2 ms gaps to exercise stream fragmentation; TCP can still combine writes.
+
+A successful JSON report contains `response: "resPQ"`, `nonceMatches: true`, the
+requested DC, the public RSA fingerprint count, and elapsed time. Exit status 1
+means connection, timeout, decryption/framing or response validation failed.
+The ordinary CI suite does not run this live probe.
+
+Success demonstrates a correctly relayed protocol exchange. It does **not**
+authenticate the responding server, prove its DC identity, log into an account,
+or verify message sending, media downloads or Android lifecycle. In particular,
+`requestedDc` describes the request, not an independently confirmed backend.
+
+## Isolate CDN transport failures
+
+To distinguish an unavailable CDN WebSocket endpoint from an unavailable CDN
+TCP connection, explicitly run:
+
+```sh
+node scripts/probe_proxy.mjs --direct-cdn --dc 203
+```
+
+This optional mode bypasses local TGLock and connects **only** to the pinned
+Telegram CDN address `91.105.192.100:443`, using raw obfuscated2 TCP without a
+proxy secret or TLS. It supports no arbitrary host. It performs the same single
+unauthenticated exchange and still does not prove account or media operation.
+The parser accepts trailing bytes after the complete `resPQ` TL object because
+live CDN replies can include random padding in the declared message length.
+
+Protocol references: [handshake initiation](https://core.telegram.org/mtproto/auth_key),
+[obfuscated transports](https://core.telegram.org/mtproto/mtproto-transports),
+and [unencrypted messages](https://core.telegram.org/mtproto/description#unencrypted-message).

docs/OPENWRT.md

@@ -0,0 +1,93 @@
+# CLI для ARM64 / OpenWrt
+
+Цель сборки — `aarch64-unknown-linux-musl`: ARM64 Linux, статический бинарь без
+зависимости от glibc, OpenSSL или WebView. Это подходит для 64-битной прошивки
+NanoPi R4S и других ARM64-роутеров. MIPS и 32-битный ARM требуют другой сборки.
+Проверьте архитектуру прошивки командой `uname -m`: ожидается `aarch64`.
+
+Workflow **Static ARM64 CLI** собирает и запускает тесты на ARM64 runner,
+проверяет ELF (нет `INTERP` и `NEEDED`), запуск CLI, завершение по SIGTERM и
+сохранение секрета между запусками. Артефакт содержит бинарь и SHA-256.
+Release workflow прикладывает такой же проверенный артефакт к будущим релизам.
+Наличие сборки в PR не означает, что уже опубликован новый релиз.
+
+Это проверка ARM64 Linux, а не испытание конкретной прошивки OpenWrt или
+доступности Telegram через вашего провайдера.
+
+## Установка
+
+Скачайте артефакт успешного запуска workflow нужного PR либо файл
+`tglock-cli-aarch64-unknown-linux-musl` из релиза, если он там опубликован.
+Сверьте SHA-256, скопируйте бинарь на роутер и выполните:
+
+```sh
+chmod 755 /usr/bin/tglock-cli
+/usr/bin/tglock-cli --version
+mkdir -p /etc/tglock
+chmod 700 /etc/tglock
+```
+
+Создайте `/etc/tglock/tglock.toml`:
+
+```toml
+port = 1080
+lan = true
+secret_file = "/etc/tglock/secret"
+# worker = ["your-name.workers.dev"]
+```
+
+`lan = true` нужен для телефонов и компьютеров в домашней сети. По умолчанию
+CLI слушает только loopback. Секрет создаётся при первом запуске и сохраняется
+в указанном файле; он не должен теряться при перезагрузке или обновлении.
+
+```sh
+chmod 600 /etc/tglock/tglock.toml
+/usr/bin/tglock-cli --config /etc/tglock/tglock.toml
+```
+
+В Telegram выберите MTProto и используйте LAN-адрес роутера, порт `1080` и
+секрет из напечатанной ссылки. `127.0.0.1` на телефоне означает сам телефон.
+Разрешайте входящий TCP `1080` только из доверенной LAN; не публикуйте порт
+в WAN. Звонки через UDP эта сборка не реализует.
+
+## Сервис procd
+
+После проверки ручного запуска сохраните `/etc/init.d/tglock`:
+
+```sh
+#!/bin/sh /etc/rc.common
+START=95
+STOP=10
+USE_PROCD=1
+
+start_service() {
+    procd_open_instance
+    procd_set_param command /usr/bin/tglock-cli --config /etc/tglock/tglock.toml
+    procd_set_param respawn 3600 5 5
+    procd_set_param stdout 1
+    procd_set_param stderr 1
+    procd_close_instance
+}
+```
+
+```sh
+chmod 755 /etc/init.d/tglock
+/etc/init.d/tglock enable
+/etc/init.d/tglock start
+logread -e tglock
+```
+
+Обновление: остановите сервис, замените бинарь после проверки контрольной суммы,
+сохраните `/etc/tglock`, запустите сервис снова. Для отмены автозапуска используйте
+`/etc/init.d/tglock stop` и `/etc/init.d/tglock disable`.
+
+## TLS и маршруты
+
+Встроенный набор доверенных корневых сертификатов webpki обновляется вместе с
+бинарём. Проверка сертификата и имени включена: при подключении к закреплённому
+IP имя Telegram по-прежнему используется для SNI и проверки сертификата.
+На роутере должно быть установлено правильное время.
+
+Если все Telegram IP недоступны, нужен доступный маршрут через собственный
+[Cloudflare Worker](CLOUDFLARE_WORKER.md). Статическая сборка сама по себе не
+устраняет блокировку всех внешних маршрутов.

docs/RELEASING.md

@@ -0,0 +1,100 @@
+# Как выпускать релиз
+
+## Подготовка через PR
+
+1. Поднять версию согласованно в шести файлах:
+   - `Cargo.toml` — версия пакета `tglock`;
+   - `Cargo.lock` — версия только пакета `tglock`, без обновления зависимостей;
+   - `tauri.conf.json` — версия приложения и имён установщиков;
+   - `package.json` — версия frontend-пакета;
+   - `package-lock.json` — верхняя версия и `packages[""].version`;
+   - `ui/main.ts` — версия копируемого диагностического отчёта.
+2. Подготовить описание изменений и проверок, отдельно указав экспериментальные
+   платформы и непроверенные сценарии. Android получает `versionName`/`versionCode`
+   из конфигурации Tauri при сборке; сгенерированный `tauri.properties` не коммитится.
+3. Проверить финальные изменения PR и слить его в `main` с соблюдением обязательных
+   проверок ветки. Дождаться зелёных проверок и Android workflow на итоговом HEAD
+   `main` до создания тега. APK предыдущего PR-коммита не заменяет артефакт этого
+   коммита: `headSha` Android run должен совпадать с коммитом будущего тега.
+
+## Тег и сборка
+
+Release workflow этого репозитория допускает тег только на текущем HEAD ветки
+по умолчанию. Guard сохраняет прежнюю защиту от выпуска другого коммита:
+ранее расхождение тега и `main` сопровождалось ошибкой публикации
+`Resource not accessible by integration`.
+
+1. Сверить `git ls-remote origin refs/heads/main` и локальный
+   `git rev-parse HEAD` после перехода на финальный коммит `main`.
+2. Убедиться, что выбранная версия и тег ещё не существуют, затем поставить
+   аннотированный тег на этот коммит:
+
+   ```bash
+   git tag -a v2.0.0-beta.N -m "TGLock 2.0.0-beta.N"
+   git push origin v2.0.0-beta.N
+   ```
+
+3. Пока релиз собирается, не добавлять коммиты в `main`. Guard проверяет HEAD
+   в начале работы и не устраняет гонку после проверки.
+4. Дождаться **всех** jobs Release. Workflow создаёт **draft** и сохраняет его
+   черновиком при загрузке GUI, CLI и ARM64. Частично загруженный выпуск не должен
+   становиться общедоступным до проверок.
+
+Ручной `workflow_dispatch` запускайте на релизном теге, а не на ветке: часть
+загрузчиков использует `github.ref_name` как имя релиза.
+
+## Проверка артефактов и публикация
+
+Зелёный workflow сам по себе недостаточен. В бетах 2 и 3 в GUI-бандл попадал
+headless-бинарь, поэтому проверяются содержимое и происхождение:
+
+- Windows: GUI `.exe` и `tglock-cli-x86_64-pc-windows-msvc.exe`.
+- macOS: универсальные `.dmg`, `.app.tar.gz` и CLI.
+- Linux x64: `.AppImage`, `.deb` и CLI.
+- ARM64 Linux: `tglock-cli-aarch64-unknown-linux-musl` и его `.sha256`;
+  workflow проверяет ELF без динамических зависимостей и запуск бинаря.
+- Android: скачать ARM64 debug APK из успешного Android run с `headSha`,
+  совпадающим с коммитом тега. Сохранить имя с версией и явной пометкой
+  `android-arm64-debug`, прикрепить APK к тому же draft. Указать экспериментальный
+  статус и ограничения debug-подписи из [ANDROID.md](ANDROID.md).
+
+Пример проверки скачанного macOS-бандла:
+
+```bash
+gh release download vX.Y.Z --repo by-sonic/tglock -p 'TGLock_universal.app.tar.gz' -D /tmp/check
+tar -xzf /tmp/check/TGLock_universal.app.tar.gz -C /tmp/check
+python scripts/verify_bundle_binary.py /tmp/check/TGLock.app/Contents/MacOS/tglock
+```
+
+Проверьте версию скачанного CLI и хотя бы один реальный протокольный обмен
+через него по [LIVE_PROBE.md](LIVE_PROBE.md). Зафиксируйте, какие платформы
+исполнены локально, а какие проверены CI. Секрет локального прокси в заметки и
+публичные артефакты не включается.
+
+Когда набор файлов полон, подписи/контрольные суммы и версии сверены, а release
+notes готовы, опубликуйте draft. Например:
+
+```bash
+gh release edit vX.Y.Z --repo by-sonic/tglock --draft=false --notes-file release-notes.md
+```
+
+Исторически `v2.0.0-beta.*` в этом репозитории публикуются с `prerelease=false`;
+workflow сохраняет эту настройку. После публикации проверьте публичную страницу
+релиза, ссылки скачивания и список файлов. Краткий пост об обновлении должен
+ссылаться на опубликованный релиз и отделять проверенные исправления от
+экспериментальных платформ.
+
+## Если сборка или публикация упала
+
+Сначала прочитайте ошибку и сверяйте коммит тега, `main`, workflow run и версии.
+Не делайте вывод о причине только из текста `Resource not accessible by
+integration`: он может относиться и к правам токена.
+
+```bash
+git ls-remote origin refs/heads/main 'refs/tags/vX.Y.Z^{}'
+```
+
+Если это ошибка инфраструктуры, повторите упавшие jobs на том же коммите.
+Если нужна правка исходников, внесите её через PR и выберите новую версию для
+нового тега. Опубликованные теги и бинарные артефакты не заменяйте: пользователи
+должны иметь возможность воспроизвести уже выпущенную версию.

gen/android/app/build.gradle.kts

@@ -15,6 +15,7 @@ val tauriProperties = Properties().apply {
 
 android {
     compileSdk = 36
+    ndkVersion = "28.0.13004108"
     namespace = "com.bysonic.tglock"
     defaultConfig {
         manifestPlaceholders["usesCleartextTraffic"] = "false"
@@ -30,7 +31,8 @@ android {
             isDebuggable = true
             isJniDebuggable = true
             isMinifyEnabled = false
-            packaging {                jniLibs.keepDebugSymbols.add("*/arm64-v8a/*.so")
+            packaging {
+                jniLibs.keepDebugSymbols.add("*/arm64-v8a/*.so")
                 jniLibs.keepDebugSymbols.add("*/armeabi-v7a/*.so")
                 jniLibs.keepDebugSymbols.add("*/x86/*.so")
                 jniLibs.keepDebugSymbols.add("*/x86_64/*.so")
@@ -45,6 +47,10 @@ android {
             )
         }
     }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
     kotlinOptions {
         jvmTarget = "1.8"
     }
@@ -62,7 +68,6 @@ dependencies {
     implementation("androidx.appcompat:appcompat:1.7.1")
     implementation("androidx.activity:activity-ktx:1.10.1")
     implementation("com.google.android.material:material:1.12.0")
-    implementation("androidx.lifecycle:lifecycle-process:2.10.0")
     testImplementation("junit:junit:4.13.2")
     androidTestImplementation("androidx.test.ext:junit:1.1.4")
     androidTestImplementation("androidx.test.espresso:espresso-core:3.5.0")

gen/android/app/proguard-rules.pro

@@ -19,3 +19,6 @@
 # If you keep the line number information, uncomment this to
 # hide the original source file name.
 #-renamesourcefileattribute SourceFile
+# Registered by class name from Rust, so no Java call site keeps it alive.
+-keep class com.bysonic.tglock.TunnelPlugin { *; }
+-keep class com.bysonic.tglock.TunnelArgs { *; }

gen/android/app/src/main/java/com/bysonic/tglock/MainActivity.kt

@@ -20,14 +20,6 @@ class MainActivity : TauriActivity() {
     enableEdgeToEdge()
     super.onCreate(savedInstanceState)
     askForNotificationPermission()
-    // Started here rather than when the proxy turns on: the proxy is a thread in
-    // this same process, so what has to survive backgrounding is the process.
-    TunnelService.start(this)
-  }
-
-  override fun onDestroy() {
-    TunnelService.stop(this)
-    super.onDestroy()
   }
 
   private fun askForNotificationPermission() {

gen/android/app/src/main/java/com/bysonic/tglock/TunnelPlugin.kt

@@ -0,0 +1,28 @@
+package com.bysonic.tglock
+
+import android.app.Activity
+import app.tauri.annotation.Command
+import app.tauri.annotation.InvokeArg
+import app.tauri.annotation.TauriPlugin
+import app.tauri.plugin.Invoke
+import app.tauri.plugin.Plugin
+
+@InvokeArg
+class TunnelArgs {
+    var enabled: Boolean = false
+}
+
+/** Called by Rust only; no WebView JavaScript interface or exported component. */
+@TauriPlugin
+class TunnelPlugin(private val activity: Activity) : Plugin(activity) {
+    @Command
+    fun setEnabled(invoke: Invoke) {
+        try {
+            val args = invoke.parseArgs(TunnelArgs::class.java)
+            if (args.enabled) TunnelService.start(activity) else TunnelService.stop(activity)
+            invoke.resolve()
+        } catch (error: Exception) {
+            invoke.reject(error.message ?: "Cannot change tunnel foreground service")
+        }
+    }
+}

gen/android/app/src/main/java/com/bysonic/tglock/TunnelService.kt

@@ -13,12 +13,11 @@ import android.os.IBinder
 import androidx.core.app.NotificationCompat
 
 /**
- * Keeps the application process alive while the tunnel is in use.
+ * Gives the running proxy Android foreground-service priority.
  *
  * The proxy itself runs on a Rust thread inside this process, so nothing here
- * touches networking. The only job is to stop Android from killing the process
+ * touches networking. This reduces background eviction while Telegram is in
- * as soon as the user switches away from the app — without this, Telegram loses
+ * use; force-stop and vendor battery management can still end the process.
- * its proxy within minutes of the app going to the background.
  */
 class TunnelService : Service() {
     override fun onBind(intent: Intent?): IBinder? = null
@@ -29,6 +28,10 @@ class TunnelService : Service() {
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        if (intent == null) {
+            stopSelf()
+            return START_NOT_STICKY
+        }
         val notification = buildNotification()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
             startForeground(
@@ -39,9 +42,10 @@ class TunnelService : Service() {
         } else {
             startForeground(NOTIFICATION_ID, notification)
         }
-        // The process must come back if the system reclaims it while the user
+        // The Rust engine belongs to this process. A sticky service restart
-        // still has the app open.
+        // would display a working notification without restarting the engine.
-        return START_STICKY
+        // After process death the user explicitly starts protection again.
+        return START_NOT_STICKY
     }
 
     private fun createChannel() {

gen/android/build.gradle.kts

@@ -5,7 +5,7 @@ buildscript {
     }
     dependencies {
         classpath("com.android.tools.build:gradle:8.11.0")
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.25")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.21")
     }
 }
 

index.html

@@ -2,7 +2,7 @@
 <html lang="ru">
   <head>
     <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
     <meta name="theme-color" content="#070a10" />
     <title>TGLock</title>
   </head>

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "tglock-ui",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.15",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "tglock-ui",
-      "version": "2.0.0-beta.1",
+      "version": "2.0.0-beta.15",
       "dependencies": {
         "@tauri-apps/api": "^2.8.0"
       },
@@ -1118,9 +1118,9 @@
       }
     },
     "node_modules/nanoid": {
-      "version": "3.3.16",
+      "version": "3.3.19",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz",
-      "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
+      "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==",
       "dev": true,
       "funding": [
         {

package.json

@@ -1,9 +1,10 @@
 {
   "name": "tglock-ui",
   "private": true,
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.15",
   "type": "module",
   "scripts": {
+    "test:worker": "node --experimental-vm-modules --test worker/tglock-worker.test.js",
     "dev": "vite --port 1420",
     "build": "tsc && vite build",
     "preview": "vite preview",

scripts/android_smoke.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""Bounded installed-APK smoke; no Telegram account or external network needed."""
+import json
+import os
+from pathlib import Path
+import re
+import socket
+import subprocess
+import sys
+import time
+import xml.etree.ElementTree as ET
+
+PACKAGE = "com.bysonic.tglock"
+COMPONENT = f"{PACKAGE}/.MainActivity"
+EVIDENCE = Path("android-smoke-evidence")
+EVIDENCE.mkdir(exist_ok=True)
+RESULT = {"launch": "not_run", "lifecycle": "not_run"}
+
+
+def adb(*args, check=True, timeout=20):
+    return subprocess.run(
+        ["adb", *args], check=check, capture_output=True, text=True,
+        encoding="utf-8", errors="replace", timeout=timeout,
+    ).stdout.strip()
+
+
+def wait_for(description, predicate, seconds=20):
+    deadline = time.monotonic() + seconds
+    while time.monotonic() < deadline:
+        if predicate():
+            return
+        time.sleep(1)
+    raise AssertionError(f"Timed out: {description}")
+
+
+def ui_dump(label):
+    # Dump first, then read the file; never tap coordinates inferred from a
+    # screenshot, a previous Activity, or assumed phone dimensions.
+    adb("shell", "rm", "-f", "/sdcard/tglock-ui.xml")
+    adb("shell", "uiautomator", "dump", "/sdcard/tglock-ui.xml")
+    text = adb("shell", "cat", "/sdcard/tglock-ui.xml")
+    (EVIDENCE / f"{label}.xml").write_text(text, encoding="utf-8")
+    return ET.fromstring(text)
+
+
+def label_node(tree, label):
+    for node in tree.iter("node"):
+        # Android aggregates the decorative arrow into the button's accessible
+        # text (observed in the API35 CI dump). Accept only that exact suffix.
+        names = (node.get("text", "").strip(), node.get("content-desc", "").strip())
+        if any(name in (label, f"{label} →") for name in names):
+            bounds = re.fullmatch(r"\[(\d+),(\d+)\]\[(\d+),(\d+)\]", node.get("bounds", ""))
+            if bounds:
+                x1, y1, x2, y2 = map(int, bounds.groups())
+                if x2 > x1 and y2 > y1:
+                    return (x1 + x2) // 2, (y1 + y2) // 2
+    return None
+
+
+def tap_label(label, stage):
+    for attempt in range(3):
+        point = label_node(ui_dump(f"{stage}-{attempt}"), label)
+        if point is not None:
+            adb("shell", "input", "tap", str(point[0]), str(point[1]))
+            return
+        time.sleep(1)
+    raise AssertionError(f"Visible action not found: {label}")
+
+
+def service_running():
+    text = adb("shell", "dumpsys", "activity", "services", f"{PACKAGE}/.TunnelService")
+    (EVIDENCE / "services-last.txt").write_text(text, encoding="utf-8")
+    return "isForeground=true" in text
+
+
+def proxy_ready():
+    # ADB forwards to emulator loopback. A real SOCKS5 greeting proves the
+    # Rust listener is serving, beyond just a notification being displayed.
+    try:
+        with socket.create_connection(("127.0.0.1", 11080), timeout=1) as peer:
+            peer.sendall(bytes([5, 1, 0]))
+            return peer.recv(2) == bytes([5, 0])
+    except (OSError, TimeoutError):
+        return False
+
+
+def launch():
+    adb("shell", "am", "start", "-W", "-n", COMPONENT)
+    wait_for("Activity resumed", lambda: any(
+        "ResumedActivity" in line and PACKAGE in line
+        for line in adb("shell", "dumpsys", "activity", "activities").splitlines()
+    ))
+    assert adb("shell", "pidof", PACKAGE), "App process is absent"
+
+
+def main():
+    apks = sorted(Path(sys.argv[1]).rglob("*.apk"))
+    assert len(apks) == 1, f"Expected one x86_64 APK, got {len(apks)}"
+    adb("install", "-r", str(apks[0]), timeout=60)
+    adb("shell", "pm", "grant", PACKAGE, "android.permission.POST_NOTIFICATIONS")
+    adb("logcat", "-c")
+    adb("forward", "tcp:11080", "tcp:1080")
+    launch()
+    RESULT["launch"] = "passed"
+    deadline = time.monotonic() + 20
+    tree = None
+    start_point = None
+    attempt = 0
+    while time.monotonic() < deadline:
+        try:
+            tree = ui_dump(f"launched-{attempt}")
+            start_point = label_node(tree, "Включить защиту")
+            if start_point is not None:
+                break
+        except (subprocess.SubprocessError, ET.ParseError):
+            pass
+        attempt += 1
+        time.sleep(1)
+    assert not service_running(), "Foreground service started without user action"
+    assert not proxy_ready(), "Proxy started without user action"
+    if tree is not None:
+        assert any(
+            node.get("class") == "android.webkit.WebView"
+            for node in tree.iter("node")
+        ), "App Activity is resumed but its WebView is absent"
+    if start_point is None:
+        RESULT["lifecycle"] = "skipped: WebView Start not accessible after 20s"
+        print("::warning::Activity launch passed; lifecycle skipped because UIAutomator did not expose Start after 20s")
+        return
+    RESULT["lifecycle"] = "failed: lifecycle assertions incomplete"
+    tap_label("Включить защиту", "before-start")
+    wait_for("foreground service after Start", service_running)
+    wait_for("Rust SOCKS listener after Start", proxy_ready)
+    adb("shell", "input", "keyevent", "KEYCODE_HOME")
+    time.sleep(5)
+    assert service_running() and proxy_ready(), "Proxy stopped after backgrounding"
+    launch()
+    tap_label("Выключить", "before-stop")
+    wait_for("foreground service after Stop", lambda: not service_running())
+    wait_for("Rust listener after Stop", lambda: not proxy_ready())
+    # Explicit restart and user force-stop, then relaunch. This tests the
+    # user-stop contract, not Android's automatic low-memory process eviction.
+    tap_label("Включить защиту", "before-restart")
+    wait_for("Rust listener after restart", proxy_ready)
+    adb("shell", "am", "force-stop", PACKAGE)
+    launch()
+    assert not service_running() and not proxy_ready(), "Proxy silently restarted after force-stop"
+    RESULT["lifecycle"] = "passed: Start, background 5s, Stop, restart, force-stop"
+
+
+try:
+    main()
+except Exception as error:
+    RESULT["failure"] = str(error)
+    raise
+finally:
+    try:
+        logs = adb("logcat", "-d", "-v", "threadtime")
+        (EVIDENCE / "logcat.txt").write_text(logs, encoding="utf-8")
+        crashes = adb("logcat", "-b", "crash", "-d")
+        (EVIDENCE / "crash.txt").write_text(crashes, encoding="utf-8")
+        if PACKAGE in crashes or f"ANR in {PACKAGE}" in logs or not adb("shell", "pidof", PACKAGE):
+            RESULT["launch"] = "failed: application crash, ANR, or missing process"
+            raise AssertionError("Application did not remain healthy")
+    finally:
+        (EVIDENCE / "result.json").write_text(json.dumps(RESULT, indent=2), encoding="utf-8")
+        summary = os.environ.get("GITHUB_STEP_SUMMARY")
+        if summary:
+            with open(summary, "a", encoding="utf-8") as report:
+                report.write("\nAndroid emulator smoke: " + json.dumps(RESULT) + "\n")
+        print(json.dumps(RESULT))

scripts/probe_proxy.mjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+// Manual, account-free probe of an ALREADY RUNNING local TGLock instance.
+// Protocol sources (this does not import the Rust implementation):
+// https://core.telegram.org/mtproto/auth_key
+// https://core.telegram.org/mtproto/mtproto-transports#transport-obfuscation
+// https://core.telegram.org/mtproto/description#unencrypted-message
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createConnection } from "node:net";
+import { setTimeout as sleep } from "node:timers/promises";
+import assert from "node:assert/strict";
+
+const MAX_RESPONSE = 2 * 1024 * 1024;
+const HELP = `Usage: node scripts/probe_proxy.mjs --secret-file PATH [--port 1080] [--dc 2] [--timeout-ms 15000] [--fragment-size 0]
+Or: node scripts/probe_proxy.mjs --direct-cdn --dc 203
+DC: 1..5 or 203; negative values request the media route.
+Default connects only to 127.0.0.1. --direct-cdn explicitly probes only 91.105.192.100:443 without a secret.
+Reads the local proxy secret from the explicit file; never prints it.
+Sends one req_pq_multi and checks resPQ/nonce. No account, API credentials, login or auth key is created.
+This proves a protocol response, not DC identity, account operation or media downloads.
+Use --self-test for offline parser checks; --fragment-size 7 sends small writes with 2ms gaps.`;
+
+function options(args) {
+  const result = { port: 1080, dc: 2, timeoutMs: 15000, fragmentSize: 0 };
+  const numeric = { "--port": "port", "--dc": "dc", "--timeout-ms": "timeoutMs", "--fragment-size": "fragmentSize" };
+  for (let i = 0; i < args.length; i++) {
+    const name = args[i];
+    if (name === "--direct-cdn") { result.directCdn = true; continue; }
+    const value = args[++i];
+    if (value === undefined) throw new Error(`Missing value for ${name}`);
+    if (name === "--secret-file") result.secretFile = value;
+    else if (numeric[name] && /^-?\d+$/.test(value)) result[numeric[name]] = Number(value);
+    else throw new Error(`Invalid option ${name}`);
+  }
+  if (!result.secretFile && !result.directCdn) throw new Error("--secret-file is required");
+  if (result.directCdn && result.dc !== 203) throw new Error("Direct CDN probe requires --dc 203");
+  if (!Number.isInteger(result.port) || result.port < 1 || result.port > 65535) throw new Error("Invalid port");
+  if (![1, 2, 3, 4, 5, 203].includes(Math.abs(result.dc))) throw new Error("Unsupported DC");
+  if (result.timeoutMs < 100 || result.timeoutMs > 120000) throw new Error("Timeout must be 100..120000ms");
+  if (result.fragmentSize < 0 || result.fragmentSize > 65536) throw new Error("Fragment size must be 0..65536");
+  return result;
+}
+
+function makeRequest(secret, dc) {
+  let header;
+  do {
+    header = randomBytes(64);
+  } while (header[0] === 0xef || ["HEAD", "POST", "GET ", "OPTI"].includes(header.toString("ascii", 0, 4))
+    || [0xeeeeeeee, 0xdddddddd, 0x02010316].includes(header.readUInt32LE()) || header.readUInt32LE(4) === 0);
+  header.fill(0xdd, 56, 60); // padded intermediate transport
+  header.writeInt16LE(dc, 60);
+  const salted = (key) => secret ? createHash("sha256").update(key).update(secret).digest() : Buffer.from(key);
+  const encrypt = createCipheriv("aes-256-ctr", salted(header.subarray(8, 40)), header.subarray(40, 56));
+  const reversed = Buffer.from(header.subarray(8, 56)).reverse();
+  const decrypt = createDecipheriv("aes-256-ctr", salted(reversed.subarray(0, 32)), reversed.subarray(32));
+  const wireHeader = Buffer.from(header);
+  encrypt.update(header).copy(wireHeader, 56, 56); // advances outgoing CTR by all 64 bytes
+
+  const nonce = randomBytes(16);
+  const payload = Buffer.alloc(40);
+  // auth_key_id = 0, client message ID divisible by four, TL payload length = 20.
+  const now = BigInt(Date.now());
+  const messageId = ((now / 1000n << 32n) | ((now % 1000n) * (1n << 32n) / 1000n)) & ~3n;
+  payload.writeBigUInt64LE(messageId, 8);
+  payload.writeUInt32LE(20, 16);
+  payload.writeUInt32LE(0xbe7e8ef1, 20);
+  nonce.copy(payload, 24);
+  const padded = Buffer.concat([payload, randomBytes(7)]);
+  const length = Buffer.alloc(4);
+  length.writeUInt32LE(padded.length);
+  return { wire: Buffer.concat([wireHeader, encrypt.update(Buffer.concat([length, padded]))]), decrypt, nonce };
+}
+
+function parseResPQ(frame, nonce) {
+  if (frame.length === 4) throw new Error(`MTProto transport error ${frame.readInt32LE()}`);
+  if (frame.length < 20 || frame.readBigUInt64LE() !== 0n) throw new Error("Expected an unencrypted MTProto response");
+  const length = frame.readUInt32LE(16);
+  if (length < 48 || length % 4 !== 0 || length > frame.length - 20) throw new Error("Invalid MTProto message length");
+  const body = frame.subarray(20, 20 + length);
+  if (body.readUInt32LE() !== 0x05162463) throw new Error("Response is not resPQ");
+  if (!body.subarray(4, 20).equals(nonce)) throw new Error("resPQ nonce does not match request");
+  // pq is at most eight bytes for this handshake, so its TL string uses the
+  // one-byte length encoding followed by padding to a four-byte boundary.
+  const pqLength = body[36];
+  if (pqLength < 1 || pqLength > 8) throw new Error("Invalid resPQ pq length");
+  const vectorOffset = 36 + Math.ceil((1 + pqLength) / 4) * 4;
+  if (vectorOffset + 8 > body.length || body.readUInt32LE(vectorOffset) !== 0x1cb5c415) throw new Error("Invalid RSA fingerprint vector");
+  const count = body.readUInt32LE(vectorOffset + 4);
+  // A CDN may include trailing random bytes in its declared message length.
+  // Validate the complete TL object fits; do not mistake padding for corruption.
+  if (count < 1 || count > 64 || vectorOffset + 8 + count * 8 > body.length) throw new Error("Invalid RSA fingerprint count");
+  // Deliberately do not infer DC identity from these public fingerprints.
+  return { response: "resPQ", nonceMatches: true, rsaFingerprintCount: count };
+}
+
+async function probe(config) {
+  let secret = null;
+  if (!config.directCdn) {
+    let hex = (await readFile(config.secretFile, "utf8")).trim();
+    if (/^dd[0-9a-f]{32}$/i.test(hex)) hex = hex.slice(2);
+    if (!/^[0-9a-f]{32}$/i.test(hex)) throw new Error("Secret file must contain 32 hex characters or dd followed by 32 hex characters");
+    secret = Buffer.from(hex, "hex");
+  }
+  const { wire, decrypt, nonce } = makeRequest(secret, config.dc);
+  const started = Date.now();
+  return new Promise((resolve, reject) => {
+    const socket = createConnection(config.directCdn
+      ? { host: "91.105.192.100", port: 443 }
+      : { host: "127.0.0.1", port: config.port });
+    let pending = Buffer.alloc(0);
+    let received = 0;
+    let finished = false;
+    const finish = (error, result) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      socket.destroy();
+      if (error) reject(error);
+      else resolve({ transport: config.directCdn ? "direct-cdn-tcp" : "local-proxy", requestedDc: config.dc, ...result, elapsedMs: Date.now() - started });
+    };
+    const timer = setTimeout(() => finish(new Error("Timed out waiting for resPQ")), config.timeoutMs);
+    socket.on("error", (error) => finish(error));
+    socket.on("end", () => finish(new Error("Proxy closed before a complete resPQ response")));
+    socket.on("data", (chunk) => {
+      try {
+        received += chunk.length;
+        if (received > MAX_RESPONSE) throw new Error("Response exceeded the 2MiB limit");
+        pending = Buffer.concat([pending, decrypt.update(chunk)]);
+        while (pending.length >= 4) {
+          const length = pending.readUInt32LE();
+          if (length & 0x80000000) { // optional intermediate quick acknowledgment
+            pending = pending.subarray(4);
+            continue;
+          }
+          if (length < 4 || length > MAX_RESPONSE - 4) throw new Error("Invalid intermediate frame length");
+          if (pending.length < 4 + length) return;
+          if (length >= 8 && length <= 16 && pending.readUInt32LE(4) === 0xffffffff) {
+            pending = pending.subarray(4 + length); // padded intermediate quick ACK
+            continue;
+          }
+          finish(null, parseResPQ(pending.subarray(4, 4 + length), nonce));
+          return;
+        }
+      } catch (error) { finish(error); }
+    });
+    socket.on("connect", async () => {
+      try {
+        socket.setNoDelay(true);
+        const size = config.fragmentSize || wire.length;
+        for (let offset = 0; offset < wire.length && !finished; offset += size) {
+          socket.write(wire.subarray(offset, offset + size));
+          if (config.fragmentSize) await sleep(2);
+        }
+      } catch (error) { finish(error); }
+    });
+  });
+}
+
+function selfTest() {
+  // Fixed TL fixture: resPQ, request nonce 00..0f, server nonce 10..1f,
+  // eight-byte pq, a one-element vector of public RSA fingerprints.
+  const body = Buffer.from("63241605000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f08112233445566778800000015c4b51c010000008877665544332211", "hex");
+  const envelope = Buffer.alloc(20);
+  envelope.writeUInt32LE(body.length, 16);
+  const frame = Buffer.concat([envelope, body, Buffer.from([1, 2, 3])]);
+  const nonce = Buffer.from("000102030405060708090a0b0c0d0e0f", "hex");
+  assert.equal(parseResPQ(frame, nonce).rsaFingerprintCount, 1);
+  const paddedEnvelope = Buffer.from(envelope);
+  paddedEnvelope.writeUInt32LE(body.length + 128, 16);
+  assert.equal(parseResPQ(Buffer.concat([paddedEnvelope, body, Buffer.alloc(128, 0x42)]), nonce).rsaFingerprintCount, 1);
+  assert.throws(() => parseResPQ(frame, Buffer.alloc(16)), /nonce/);
+  assert.throws(() => parseResPQ(frame.subarray(0, 30), nonce), /length/);
+  const wrongConstructor = Buffer.from(frame);
+  wrongConstructor[20] = 0;
+  assert.throws(() => parseResPQ(wrongConstructor, nonce), /not resPQ/);
+  const oversizedVector = Buffer.from(frame);
+  oversizedVector.writeUInt32LE(65, 72);
+  assert.throws(() => parseResPQ(oversizedVector, nonce), /count/);
+  assert.throws(() => parseResPQ(Buffer.from("6cfeffff", "hex"), nonce), /-404/);
+  console.log("Offline parser checks passed; no network connection made.");
+}
+
+try {
+  const args = process.argv.slice(2);
+  if (args.length === 1 && args[0] === "--self-test") selfTest();
+  else if (args.length === 1 && ["--help", "-h"].includes(args[0])) console.log(HELP);
+  else console.log(JSON.stringify(await probe(options(args)), null, 2));
+} catch (error) {
+  console.error(`Probe failed: ${error.message}`);
+  process.exitCode = 1;
+}

scripts/verify_bundle_binary.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Проверяет, что в бандл приложения попал GUI-бинарь, а не headless CLI.
+
+Зачем это существует. В v2.0.0-beta.2 и v2.0.0-beta.3 бандлер Tauri упаковал
+`tglock-cli` как исполняемый файл приложения, и оно не запускалось ни на одной
+платформе. В beta.3 имя файла было уже правильным — бандлер переименовал CLI —
+поэтому проверка имени или `CFBundleExecutable` ничего не заметила. Отличить
+можно только по содержимому.
+
+Почему на Python, а не grep. BSD grep на macOS в UTF-8-локали молча не находит
+строки в бинарных данных там, где GNU grep находит: проверка проходила на
+Linux и давала ложное «не GUI» на macOS. Один скрипт для всех платформ и для
+всех трёх мест, где проверка вызывается, исключает подобные расхождения.
+
+Использование:
+    python3 scripts/verify_bundle_binary.py <путь-к-бинарю>
+"""
+
+import sys
+
+# Присутствуют только в GUI: строка CSP из tauri.conf.json и имя движка WebView.
+GUI_MARKERS = (b"ipc.localhost", b"wry")
+# Присутствуют только в CLI: имена флагов clap.
+CLI_MARKERS = (b"allow-direct", b"secret-file")
+
+
+def main(argv: list[str]) -> int:
+    if len(argv) != 2:
+        print(f"использование: {argv[0]} <путь-к-бинарю>", file=sys.stderr)
+        return 2
+
+    path = argv[1]
+    try:
+        with open(path, "rb") as handle:
+            data = handle.read()
+    except OSError as error:
+        print(f"не удалось прочитать {path}: {error}", file=sys.stderr)
+        return 1
+
+    found_gui = [marker.decode() for marker in GUI_MARKERS if marker in data]
+    found_cli = [marker.decode() for marker in CLI_MARKERS if marker in data]
+
+    print(f"файл:     {path}")
+    print(f"размер:   {len(data) / 1048576:.1f} МБ")
+    print(f"GUI:      {found_gui or 'признаков нет'}")
+    print(f"CLI:      {found_cli or 'признаков нет'}")
+
+    if found_cli:
+        print("ОШИБКА: в бандле headless CLI вместо приложения", file=sys.stderr)
+        return 1
+    if not found_gui:
+        print("ОШИБКА: это не GUI-бинарь, признаков GUI нет", file=sys.stderr)
+        return 1
+
+    print("OK: в бандле GUI-бинарь")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

src/bin/cli.rs

@@ -12,11 +12,22 @@ use std::process::ExitCode;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
 use std::time::Duration;
-use tglock_lib::config::ListenConfig;
+use tglock_lib::cli_settings as config;
-use tglock_lib::{mtproto, proxy, transport};
+use tglock_lib::{proxy, transport};
 
 const STATUS_POLL: Duration = Duration::from_secs(1);
 
+/// Напечатать строку, вернув `false`, если stdout больше не принимает данные.
+///
+/// `println!` при ошибке записи паникует, а у демона stdout исчезает штатно: его
+/// пускают в `head`, закрывают терминал, перезапускают сборщик логов. Падать из
+/// за этого туннель не должен — он продолжает работать молча.
+fn say(text: &str) -> bool {
+    use std::io::Write;
+    let mut out = std::io::stdout().lock();
+    writeln!(out, "{text}").and_then(|()| out.flush()).is_ok()
+}
+
 #[derive(Debug, Parser)]
 #[command(
     name = "tglock-cli",
@@ -24,13 +35,17 @@ const STATUS_POLL: Duration = Duration::from_secs(1);
     about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
 )]
 struct Args {
-    /// Адрес для прослушивания. 127.0.0.1 — только этот компьютер
+    /// Файл настроек. Если не задан, ищется tglock.toml рядом с бинарём
-    #[arg(short, long, value_name = "IP", default_value = "127.0.0.1")]
+    #[arg(short, long, value_name = "PATH")]
-    bind: IpAddr,
+    config: Option<PathBuf>,
 
-    /// Порт локального прокси
+    /// Адрес для прослушивания. По умолчанию 127.0.0.1 — только этот компьютер
-    #[arg(short, long, value_name = "PORT", default_value_t = proxy::DEFAULT_PORT)]
+    #[arg(short, long, value_name = "IP")]
-    port: u16,
+    bind: Option<IpAddr>,
+
+    /// Порт локального прокси. По умолчанию 1080
+    #[arg(short, long, value_name = "PORT")]
+    port: Option<u16>,
 
     /// То же, что --bind 0.0.0.0: доступ с других устройств в локальной сети
     #[arg(long, conflicts_with = "bind")]
@@ -44,8 +59,8 @@ struct Args {
     #[arg(long)]
     allow_direct: bool,
 
-    /// Файл с секретом прокси. Обязателен для сервиса: иначе после перезапуска
+    /// Файл с секретом прокси. Для сервиса нужен он или secret в настройках:
-    /// секрет будет новым и уже настроенные клиенты перестанут подключаться
+    /// иначе после перезапуска секрет будет новым и настроенные клиенты отвалятся
     #[arg(long, value_name = "PATH")]
     secret_file: Option<PathBuf>,
 
@@ -55,28 +70,31 @@ struct Args {
 }
 
 impl Args {
-    fn stats(&self) -> Arc<proxy::Stats> {
+    fn overrides(&self) -> config::Overrides {
-        match &self.secret_file {
+        config::Overrides {
-            Some(path) => proxy::Stats::with_secret(mtproto::load_or_create_secret_at(path)),
+            bind: self.bind,
-            None => proxy::Stats::new(),
+            port: self.port,
+            lan: self.lan,
+            allow_direct: self.allow_direct,
+            worker: self.worker.clone(),
+            secret_file: self.secret_file.clone(),
+            quiet: self.quiet,
         }
     }
 
-    fn listen(&self) -> ListenConfig {
+    /// Файл настроек и путь, по которому он найден.
-        let base = if self.lan {
+    ///
-            ListenConfig::lan(self.port)
+    /// Явный `--config` обязателен к существованию: если человек указал путь и
-        } else {
+    /// опечатался, молча стартовать с настройками по умолчанию — худшее из
-            ListenConfig::new(self.bind, self.port)
+    /// возможных поведений.
-        };
+    fn load_file(&self) -> Result<(config::FileConfig, Option<PathBuf>), String> {
-        if self.allow_direct {
+        if let Some(path) = &self.config {
-            base.with_allow_direct(true)
+            return Ok((config::FileConfig::load(path)?, Some(path.clone())));
-        } else {
-            base
         }
+        match config::path_next_to_executable() {
+            Some(path) if path.is_file() => Ok((config::FileConfig::load(&path)?, Some(path))),
+            _ => Ok((config::FileConfig::default(), None)),
         }
-
-    fn worker_domains(&self) -> String {
-        self.worker.join(",")
     }
 }
 
@@ -100,30 +118,55 @@ fn main() -> ExitCode {
 }
 
 async fn serve(args: Args) -> Result<(), String> {
-    let listen = args.listen();
+    let (file, file_path) = args.load_file()?;
-    let stats = args.stats();
+    let settings = config::resolve(file, args.overrides())?;
-    stats.set_worker_domain(&args.worker_domains());
+    let listen = settings.listen;
+    let stats = settings.stats();
+    let quiet = settings.quiet;
 
     // Bind before printing anything: a busy port must be an error, not a
     // daemon that reports success and silently does nothing.
     let listener = proxy::bind(listen).await?;
 
-    if !args.quiet {
+    if !quiet {
-        println!("Слушаю {}", listen.addr);
+        let intro = match &file_path {
-        println!(
+            Some(path) => format!("Настройки: {}", path.display()),
+            None => format!(
+                "Настройки: только флаги ({} рядом с бинарём не найден)",
+                config::DEFAULT_FILE_NAME
+            ),
+        };
+        say(&intro);
+        say(&format!("Слушаю {}", listen.addr));
+        say(&format!(
             "Ссылка для Telegram: {}",
             listen.telegram_link(&stats.telegram_secret())
-        );
+        ));
-        if listen.allow_direct && !listen.addr.ip().is_loopback() {
+        // Запись секрета могла провалиться — тогда после перезапуска ссылка
-            println!(
+        // изменится и Telegram скажет «прокси настроен неверно». Раньше это
-                "Внимание: --allow-direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
+        // происходило молча (by-sonic/tglock#37).
-                listen.addr.ip()
+        if let Some(error) = stats.secret_write_error() {
-            );
+            say(&format!(
-        } else if !listen.allow_direct {
+                "Внимание: секрет НЕ сохранён ({error}). После перезапуска ссылка \
-            println!("Пропускаю только адреса Telegram");
+                 изменится, и Telegram откажется подключаться к старой"
+            ));
         }
-        if !args.worker.is_empty() {
+        if matches!(settings.secret, config::SecretSource::Ephemeral) {
-            println!("Резервные Worker-домены: {}", args.worker_domains());
+            say(
+                "Внимание: секрет не закреплён и будет новым после перезапуска — \
+                 задайте secret в настройках или --secret-file",
+            );
+        }
+        if listen.allow_direct && !listen.addr.ip().is_loopback() {
+            say(&format!(
+                "Внимание: allow_direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
+                listen.addr.ip()
+            ));
+        } else if !listen.allow_direct {
+            say("Пропускаю только адреса Telegram");
+        }
+        if !settings.workers.is_empty() {
+            say(&format!("Резервные Worker-домены: {}", settings.workers));
         }
     }
 
@@ -132,14 +175,14 @@ async fn serve(args: Args) -> Result<(), String> {
         tokio::spawn(
             async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
         );
-    let watcher = (!args.quiet).then(|| tokio::spawn(watch_status(stats.clone())));
+    let watcher = (!quiet).then(|| tokio::spawn(watch_status(stats.clone())));
 
     let outcome = tokio::select! {
         joined = &mut server => joined.map_err(|error| format!("рабочая задача упала: {error}"))?,
         signal = shutdown_signal() => {
             signal.map_err(|error| format!("обработчик сигналов: {error}"))?;
-            if !args.quiet {
+            if !quiet {
-                println!("Получен сигнал остановки, закрываю соединения…");
+                say("Получен сигнал остановки, закрываю соединения…");
             }
             stats.stop();
             server
@@ -162,19 +205,35 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
     let mut previous = None;
     loop {
         tokio::time::sleep(STATUS_POLL).await;
+
+        // Отдельные события — кто подключился и какой адрес отклонён. Без них
+        // journalctl показывает только счётчики, по которым нельзя отличить
+        // «телефон не дошёл» от «дошёл и получил отказ» (by-sonic/tglock#42).
+        for event in stats.drain_events() {
+            if !say(&event) {
+                return;
+            }
+        }
+
         let current = (
             stats.active.load(Ordering::Relaxed),
             stats.ws.load(Ordering::Relaxed),
-            stats.last_dc.load(Ordering::Relaxed),
+            stats.last_dc(),
-            stats.last_route.load(Ordering::Relaxed),
+            stats.last_route(),
             stats.ws_failures.load(Ordering::Relaxed),
+            stats.route_failures(),
+            stats.blocked.load(Ordering::Relaxed),
+            stats.unknown_clients.load(Ordering::Relaxed),
+            stats.silent_clients.load(Ordering::Relaxed),
         );
         if previous.as_ref() == Some(&current) {
             continue;
         }
-        let (active, tunnels, dc, route, failures) = current;
+        let (active, tunnels, dc, route, failures, route_failures, blocked, unknown, silent) =
-        println!(
+            current;
-            "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
+        let line = format!(
+            "соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures} · \
+             падений маршрутов {route_failures} · отклонено {blocked} · не опознано {unknown} ·              промолчали {silent}",
             if dc > 0 {
                 format!("DC{dc}")
             } else {
@@ -182,6 +241,11 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
             },
             transport::route_label(route)
         );
+        // Закрытый stdout — не ошибка: печатать больше некому, туннель работает
+        // дальше без наблюдателя.
+        if !say(&line) {
+            return;
+        }
         previous = Some(current);
     }
 }
@@ -213,6 +277,11 @@ mod tests {
         Args::try_parse_from(std::iter::once("tglock-cli").chain(args.iter().copied())).unwrap()
     }
 
+    /// Итоговые настройки только из флагов, без файла.
+    fn from_flags(args: &[&str]) -> config::Resolved {
+        config::resolve(config::FileConfig::default(), parse(args).overrides()).unwrap()
+    }
+
     #[test]
     fn command_definition_is_valid() {
         Args::command().debug_assert();
@@ -220,7 +289,7 @@ mod tests {
 
     #[test]
     fn defaults_to_loopback_on_the_default_port() {
-        let listen = parse(&[]).listen();
+        let listen = from_flags(&[]).listen;
         assert_eq!(listen.addr.to_string(), "127.0.0.1:1080");
         assert!(listen.allow_direct);
     }
@@ -228,50 +297,50 @@ mod tests {
     #[test]
     fn lan_flag_matches_explicit_wildcard_bind() {
         assert_eq!(
-            parse(&["--lan"]).listen(),
+            from_flags(&["--lan"]).listen,
-            parse(&["-b", "0.0.0.0"]).listen()
+            from_flags(&["-b", "0.0.0.0"]).listen
         );
     }
 
     #[test]
     fn lan_does_not_relay_non_telegram_traffic() {
-        let listen = parse(&["--lan"]).listen();
+        let listen = from_flags(&["--lan"]).listen;
         assert_eq!(listen.addr.to_string(), "0.0.0.0:1080");
         assert!(!listen.allow_direct);
     }
 
     #[test]
     fn allow_direct_is_the_only_way_to_open_a_network_listener() {
-        assert!(!parse(&["-b", "192.168.1.10"]).listen().allow_direct);
+        assert!(!from_flags(&["-b", "192.168.1.10"]).listen.allow_direct);
         assert!(
-            parse(&["-b", "192.168.1.10", "--allow-direct"])
+            from_flags(&["-b", "192.168.1.10", "--allow-direct"])
-                .listen()
+                .listen
                 .allow_direct
         );
     }
 
     #[test]
     fn bind_and_port_are_honoured() {
-        let listen = parse(&["--bind", "10.0.0.7", "--port", "1443"]).listen();
+        let listen = from_flags(&["--bind", "10.0.0.7", "--port", "1443"]).listen;
         assert_eq!(listen.addr.to_string(), "10.0.0.7:1443");
     }
 
     #[test]
     fn ipv6_bind_is_accepted() {
-        let listen = parse(&["-b", "::1", "-p", "2080"]).listen();
+        let listen = from_flags(&["-b", "::1", "-p", "2080"]).listen;
         assert_eq!(listen.addr.to_string(), "[::1]:2080");
         assert!(listen.allow_direct);
     }
 
     #[test]
     fn repeated_worker_flags_collapse_into_one_list() {
-        let args = parse(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
+        let settings = from_flags(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
-        assert_eq!(args.worker_domains(), "a.workers.dev,b.workers.dev");
+        assert_eq!(settings.workers, "a.workers.dev,b.workers.dev");
     }
 
     #[test]
     fn no_worker_flag_means_no_domains() {
-        assert!(parse(&[]).worker_domains().is_empty());
+        assert!(from_flags(&[]).workers.is_empty());
     }
 
     #[test]
@@ -288,10 +357,10 @@ mod tests {
         ));
         let _ = std::fs::remove_file(&path);
 
-        let first = parse(&["--secret-file", path.to_str().unwrap()])
+        let first = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
-        let second = parse(&["--secret-file", path.to_str().unwrap()])
+        let second = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
 
@@ -303,11 +372,11 @@ mod tests {
 
         // A corrupted file must not wedge the daemon: it is replaced.
         std::fs::write(&path, "garbage").unwrap();
-        let third = parse(&["--secret-file", path.to_str().unwrap()])
+        let third = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
         assert_ne!(third, first);
-        let fourth = parse(&["--secret-file", path.to_str().unwrap()])
+        let fourth = from_flags(&["--secret-file", path.to_str().unwrap()])
             .stats()
             .telegram_secret();
         assert_eq!(third, fourth, "the replacement must be persisted in turn");

src/cli_settings.rs

@@ -0,0 +1,360 @@
+//! Файл конфигурации для `tglock-cli`.
+//!
+//! Живёт в библиотеке, а не рядом с бинарём: каталожная форма `src/bin/cli/`
+//! ломает перечисление бинарей в Tauri — он выводит имя приложения из имени
+//! каталога и пытается упаковать несуществующий `cli`.
+//!
+//! Запрошен в by-sonic/tglock#32: держать все параметры и секрет в одном месте,
+//! чтобы не собирать батник с ключами при каждом запуске.
+//!
+//! Порядок приоритетов: значения по умолчанию → файл → флаги командной строки.
+//! Флаги-переключатели (`--lan`, `--allow-direct`, `--quiet`) могут только
+//! включать: их отсутствие означает «взять из файла», а не «выключить».
+
+use crate::config::ListenConfig;
+use crate::{mtproto, proxy};
+use serde::Deserialize;
+use std::net::IpAddr;
+use std::path::{Path, PathBuf};
+
+/// Имя файла, который ищется рядом с бинарём, если `--config` не задан.
+pub const DEFAULT_FILE_NAME: &str = "tglock.toml";
+
+/// Содержимое файла конфигурации.
+///
+/// `deny_unknown_fields` намеренно: опечатка вроде `porrt = 1080` должна быть
+/// ошибкой при старте, а не молча проигнорированной строкой, из-за которой
+/// сервис слушает не тот порт.
+#[derive(Debug, Default, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct FileConfig {
+    pub bind: Option<IpAddr>,
+    pub port: Option<u16>,
+    pub lan: Option<bool>,
+    pub allow_direct: Option<bool>,
+    pub worker: Option<Vec<String>>,
+    pub secret: Option<String>,
+    pub secret_file: Option<PathBuf>,
+    pub quiet: Option<bool>,
+}
+
+impl FileConfig {
+    pub fn parse(text: &str) -> Result<Self, String> {
+        toml::from_str(text).map_err(|error| format!("конфиг разобрать не удалось: {error}"))
+    }
+
+    pub fn load(path: &Path) -> Result<Self, String> {
+        let text = std::fs::read_to_string(path)
+            .map_err(|error| format!("не удалось прочитать {}: {error}", path.display()))?;
+        Self::parse(&text)
+    }
+}
+
+/// Значения, пришедшие из командной строки.
+#[derive(Debug, Default)]
+pub struct Overrides {
+    pub bind: Option<IpAddr>,
+    pub port: Option<u16>,
+    pub lan: bool,
+    pub allow_direct: bool,
+    pub worker: Vec<String>,
+    pub secret_file: Option<PathBuf>,
+    pub quiet: bool,
+}
+
+/// Откуда взять секрет прокси.
+#[derive(Debug, PartialEq)]
+pub enum SecretSource {
+    /// Записан прямо в конфиге.
+    Inline([u8; 16]),
+    /// Лежит в отдельном файле, создаётся при первом запуске.
+    File(PathBuf),
+    /// Ни того, ни другого: секрет будет новым при каждом старте.
+    Ephemeral,
+}
+
+/// Итоговые настройки запуска.
+#[derive(Debug, PartialEq)]
+pub struct Resolved {
+    pub listen: ListenConfig,
+    /// Домены Worker'ов в том виде, в каком их ждёт `Stats::set_worker_domain`.
+    pub workers: String,
+    pub secret: SecretSource,
+    pub quiet: bool,
+}
+
+impl Resolved {
+    pub fn stats(&self) -> std::sync::Arc<proxy::Stats> {
+        let stats = match &self.secret {
+            SecretSource::Inline(secret) => proxy::Stats::with_secret(*secret),
+            SecretSource::File(path) => {
+                proxy::Stats::with_stored_secret(mtproto::load_or_create_secret_at(path))
+            }
+            SecretSource::Ephemeral => proxy::Stats::new(),
+        };
+        stats.set_worker_domain(&self.workers);
+        stats
+    }
+}
+
+/// Свести файл и флаги в одни настройки.
+pub fn resolve(file: FileConfig, cli: Overrides) -> Result<Resolved, String> {
+    let port = cli.port.or(file.port).unwrap_or(proxy::DEFAULT_PORT);
+    if port == 0 {
+        return Err("порт должен быть от 1 до 65535".to_owned());
+    }
+
+    let lan = cli.lan || file.lan.unwrap_or(false);
+    let bind = cli.bind.or(file.bind);
+    if lan && bind.is_some() {
+        return Err("нельзя задать одновременно lan и bind: выберите одно".to_owned());
+    }
+
+    let listen = match (lan, bind) {
+        (true, _) => ListenConfig::lan(port),
+        (false, Some(ip)) => ListenConfig::new(ip, port),
+        (false, None) => ListenConfig::loopback(port),
+    };
+    let allow_direct = cli.allow_direct || file.allow_direct.unwrap_or(false);
+    let listen = if allow_direct {
+        listen.with_allow_direct(true)
+    } else {
+        listen
+    };
+
+    let workers = if cli.worker.is_empty() {
+        file.worker.unwrap_or_default()
+    } else {
+        cli.worker
+    };
+
+    // Секрет из файла конфигурации важнее отдельного файла: если человек вписал
+    // его сюда, значит хотел держать всё в одном месте.
+    let secret = match (&file.secret, cli.secret_file.or(file.secret_file)) {
+        (Some(value), _) => SecretSource::Inline(
+            mtproto::parse_secret(value)
+                .ok_or("секрет в конфиге неверный: нужны 32 hex-символа, можно с префиксом dd")?,
+        ),
+        (None, Some(path)) => SecretSource::File(path),
+        (None, None) => SecretSource::Ephemeral,
+    };
+
+    Ok(Resolved {
+        listen,
+        workers: workers.join(","),
+        secret,
+        quiet: cli.quiet || file.quiet.unwrap_or(false),
+    })
+}
+
+/// Путь к конфигу рядом с исполняемым файлом.
+///
+/// Именно этого просили в #32: «размещение рядом с бинарником частично решает
+/// вопрос». Текущий каталог не используется, чтобы сервис не зависел от того,
+/// откуда его запустили.
+pub fn path_next_to_executable() -> Option<PathBuf> {
+    let executable = std::env::current_exe().ok()?;
+    Some(executable.parent()?.join(DEFAULT_FILE_NAME))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const SECRET: &str = "00112233445566778899aabbccddeeff";
+
+    fn cli() -> Overrides {
+        Overrides::default()
+    }
+
+    #[test]
+    fn empty_config_and_no_flags_give_the_documented_defaults() {
+        let resolved = resolve(FileConfig::default(), cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "127.0.0.1:1080");
+        assert!(resolved.listen.allow_direct);
+        assert_eq!(resolved.workers, "");
+        assert_eq!(resolved.secret, SecretSource::Ephemeral);
+        assert!(!resolved.quiet);
+    }
+
+    #[test]
+    fn file_values_are_used_when_no_flags_are_given() {
+        let file = FileConfig::parse(
+            r#"
+            bind = "10.0.0.5"
+            port = 1443
+            allow_direct = true
+            worker = ["a.workers.dev", "b.workers.dev"]
+            quiet = true
+        "#,
+        )
+        .unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "10.0.0.5:1443");
+        assert!(resolved.listen.allow_direct);
+        assert_eq!(resolved.workers, "a.workers.dev,b.workers.dev");
+        assert!(resolved.quiet);
+    }
+
+    #[test]
+    fn flags_win_over_the_file() {
+        let file = FileConfig::parse(
+            r#"
+            bind = "10.0.0.5"
+            port = 1443
+            worker = ["from-file.workers.dev"]
+        "#,
+        )
+        .unwrap();
+        let resolved = resolve(
+            file,
+            Overrides {
+                bind: Some("192.168.1.7".parse().unwrap()),
+                port: Some(2080),
+                worker: vec!["from-flag.workers.dev".to_owned()],
+                ..Overrides::default()
+            },
+        )
+        .unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "192.168.1.7:2080");
+        assert_eq!(resolved.workers, "from-flag.workers.dev");
+    }
+
+    #[test]
+    fn a_switch_flag_can_only_turn_things_on() {
+        // Отсутствие --quiet не должно отменять quiet = true из файла: иначе
+        // файл нельзя было бы использовать для включения ничего.
+        let file = FileConfig::parse("quiet = true\nallow_direct = true").unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert!(resolved.quiet);
+        assert!(resolved.listen.allow_direct);
+    }
+
+    #[test]
+    fn lan_from_the_file_restricts_to_telegram() {
+        let resolved = resolve(FileConfig::parse("lan = true").unwrap(), cli()).unwrap();
+        assert_eq!(resolved.listen.addr.to_string(), "0.0.0.0:1080");
+        assert!(
+            !resolved.listen.allow_direct,
+            "сетевой слушатель не должен релеить произвольные адреса без явного разрешения"
+        );
+    }
+
+    #[test]
+    fn lan_and_bind_together_are_rejected_wherever_they_come_from() {
+        let both_in_file = FileConfig::parse("lan = true\nbind = \"10.0.0.5\"").unwrap();
+        assert!(resolve(both_in_file, cli()).is_err());
+
+        let file = FileConfig::parse("bind = \"10.0.0.5\"").unwrap();
+        let flag_lan = Overrides {
+            lan: true,
+            ..Overrides::default()
+        };
+        assert!(
+            resolve(file, flag_lan).is_err(),
+            "конфликт должен ловиться и когда стороны пришли из разных мест"
+        );
+    }
+
+    #[test]
+    fn inline_secret_is_accepted_in_both_written_forms() {
+        for value in [SECRET.to_owned(), format!("dd{SECRET}")] {
+            let file = FileConfig::parse(&format!("secret = \"{value}\"")).unwrap();
+            let resolved = resolve(file, cli()).unwrap();
+            assert_eq!(
+                resolved.secret,
+                SecretSource::Inline([
+                    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
+                    0xdd, 0xee, 0xff,
+                ]),
+                "форма {value} должна приниматься"
+            );
+        }
+    }
+
+    #[test]
+    fn a_broken_inline_secret_stops_the_start() {
+        let file = FileConfig::parse("secret = \"явно не секрет\"").unwrap();
+        let error = resolve(file, cli()).unwrap_err();
+        assert!(
+            error.contains("32"),
+            "ошибка должна объяснять формат, получено: {error}"
+        );
+    }
+
+    #[test]
+    fn inline_secret_wins_over_a_secret_file() {
+        let file =
+            FileConfig::parse(&format!("secret = \"{SECRET}\"\nsecret_file = \"s.bin\"")).unwrap();
+        let resolved = resolve(file, cli()).unwrap();
+        assert!(matches!(resolved.secret, SecretSource::Inline(_)));
+    }
+
+    #[test]
+    fn secret_file_from_the_flag_wins_over_the_file() {
+        let file = FileConfig::parse("secret_file = \"from-file.bin\"").unwrap();
+        let resolved = resolve(
+            file,
+            Overrides {
+                secret_file: Some(PathBuf::from("from-flag.bin")),
+                ..Overrides::default()
+            },
+        )
+        .unwrap();
+        assert_eq!(
+            resolved.secret,
+            SecretSource::File(PathBuf::from("from-flag.bin"))
+        );
+    }
+
+    #[test]
+    fn a_typo_in_the_config_is_an_error_not_a_silent_default() {
+        // Самая опасная поломка конфига — та, которую не видно. Сервис не должен
+        // слушать 1080, если человек написал porrt = 1443.
+        let error = FileConfig::parse("porrt = 1443").unwrap_err();
+        assert!(
+            error.contains("porrt"),
+            "ошибка должна называть неизвестное поле, получено: {error}"
+        );
+    }
+
+    #[test]
+    fn malformed_values_are_rejected() {
+        for text in [
+            "bind = \"не адрес\"",
+            "port = \"1080\"",
+            "port = 70000",
+            "worker = \"строка вместо списка\"",
+            "lan = \"да\"",
+        ] {
+            assert!(
+                FileConfig::parse(text).is_err(),
+                "{text:?} должен быть отвергнут"
+            );
+        }
+    }
+
+    #[test]
+    fn zero_port_is_rejected() {
+        assert!(resolve(FileConfig::parse("port = 0").unwrap(), cli()).is_err());
+    }
+
+    #[test]
+    fn comments_and_blank_lines_are_fine() {
+        let file = FileConfig::parse(
+            r#"
+            # порт для второго экземпляра
+            port = 1081
+
+            # свой воркер как резерв
+            worker = ["backup.workers.dev"]
+        "#,
+        )
+        .unwrap();
+        assert_eq!(file.port, Some(1081));
+        assert_eq!(
+            file.worker.as_deref(),
+            Some(&["backup.workers.dev".to_owned()][..])
+        );
+    }
+}

src/gui.rs

@@ -43,8 +43,32 @@ struct StatusSnapshot {
     data_center: Option<u16>,
     route: String,
     failures: u32,
+    /// Падения отдельных маршрутов. Растёт даже когда соединение в итоге
+    /// состоялось через запасной адрес (by-sonic/tglock#32).
+    route_failures: u32,
+    /// Запросы, отклонённые политикой «в LAN-режиме только Telegram».
+    ///
+    /// Ноль означает, что фильтр не отклонял запросы. Доходит ли телефон до
+    /// машины, показывают соединения и журнал, а не этот счётчик (#42).
+    blocked: u32,
+    /// Клиенты, которые дошли, но не сумели договориться. Почти всегда это
+    /// ссылка `tg://proxy` от прошлого запуска, то есть другой секрет.
+    unknown_clients: u32,
+    /// Соединения, которые открылись и ничего не прислали до таймаута.
+    ///
+    /// Растущее число в такт с переподключениями клиента означает, что он
+    /// открывает соединения впрок, а мы закрываем их по таймауту
+    /// (by-sonic/tglock#42).
+    silent_clients: u32,
     uptime_seconds: u64,
     port: u16,
+    /// Адрес, который нужно вписать в Telegram на другом устройстве.
+    ///
+    /// В LAN-режиме это адрес этого компьютера в локальной сети. Люди искали
+    /// его в интерфейсе и не находили: вписывали `127.0.0.1`, который на
+    /// телефоне или в эмуляторе означает само устройство, и подключение не
+    /// работало (by-sonic/tglock#36).
+    share_address: Option<String>,
     logs: Vec<LogLine>,
 }
 
@@ -52,24 +76,31 @@ struct AppState {
     stats: Arc<proxy::Stats>,
     settings: Mutex<Settings>,
     active_port: Mutex<u16>,
+    /// Слушатель работающего прокси. Нужен, чтобы показать адрес для других
+    /// устройств именно тот, на котором прокси реально поднят, а не тот, что
+    /// сейчас выбран в настройках.
+    active_listen: Mutex<Option<ListenConfig>>,
     started_at: Mutex<Option<Instant>>,
     logs: Arc<Mutex<Vec<LogLine>>>,
     settings_path: PathBuf,
+    task: tokio::sync::Mutex<Option<tokio::task::JoinHandle<()>>>,
 }
 
 impl AppState {
-    fn new(settings_path: PathBuf) -> Self {
+    fn new(settings_path: PathBuf, stats: Arc<proxy::Stats>) -> Self {
         let settings = std::fs::read(&settings_path)
             .ok()
             .and_then(|contents| serde_json::from_slice(&contents).ok())
             .unwrap_or_default();
         Self {
-            stats: proxy::Stats::new(),
+            stats,
             settings: Mutex::new(settings),
             active_port: Mutex::new(proxy::DEFAULT_PORT),
+            active_listen: Mutex::new(None),
             started_at: Mutex::new(None),
             logs: Arc::new(Mutex::new(Vec::new())),
             settings_path,
+            task: tokio::sync::Mutex::new(None),
         }
     }
 
@@ -86,8 +117,13 @@ impl AppState {
     }
 
     fn snapshot(&self) -> StatusSnapshot {
-        let data_center = self.stats.last_dc.load(Ordering::Relaxed);
+        // События прокси доходят до журнала только здесь: у ядра нет своего
-        let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
+        // способа что-то показать, а интерфейс и так опрашивает состояние.
+        for event in self.stats.drain_events() {
+            self.log(event, false);
+        }
+        let data_center = self.stats.last_dc();
+        let route = transport::route_label(self.stats.last_route());
         StatusSnapshot {
             running: self.stats.running.load(Ordering::SeqCst),
             active_connections: self.stats.active.load(Ordering::Relaxed),
@@ -95,12 +131,17 @@ impl AppState {
             data_center: (data_center > 0).then_some(data_center),
             route: route.to_owned(),
             failures: self.stats.ws_failures.load(Ordering::Relaxed),
+            route_failures: self.stats.route_failures(),
+            blocked: self.stats.blocked.load(Ordering::Relaxed),
+            unknown_clients: self.stats.unknown_clients.load(Ordering::Relaxed),
+            silent_clients: self.stats.silent_clients.load(Ordering::Relaxed),
             uptime_seconds: self
                 .started_at
                 .lock()
                 .unwrap()
                 .map_or(0, |started| started.elapsed().as_secs()),
             port: *self.active_port.lock().unwrap(),
+            share_address: share_address(*self.active_listen.lock().unwrap()),
             logs: self.logs.lock().unwrap().clone(),
         }
     }
@@ -117,6 +158,18 @@ impl AppState {
     }
 }
 
+/// Адрес, который нужно вписать в Telegram на другом устройстве.
+///
+/// Только для слушателя на `0.0.0.0`: на loopback делиться нечем, туда никто
+/// извне не достучится. Возвращается адрес этой машины в сети, а не `0.0.0.0`
+/// и не `127.0.0.1` — последний на телефоне или в эмуляторе означает само
+/// устройство, и именно на этом спотыкались (by-sonic/tglock#36).
+fn share_address(listen: Option<ListenConfig>) -> Option<String> {
+    listen
+        .filter(|listen| listen.addr.ip().is_unspecified())
+        .map(|listen| format!("{}:{}", listen.advertised_host(), listen.addr.port()))
+}
+
 fn current_time() -> String {
     let seconds = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -155,70 +208,123 @@ fn save_settings(settings: Settings, state: State<'_, AppState>) -> Result<Setti
 }
 
 #[tauri::command]
-fn start_proxy(
+async fn start_proxy(
     app: tauri::AppHandle,
     state: State<'_, AppState>,
 ) -> Result<StatusSnapshot, String> {
+    // Serialize transitions, including shutdown, so a rapid double click cannot
+    // create two listeners or stop a newly started Android service.
+    let mut task = state.task.lock().await;
     if state.stats.running.load(Ordering::SeqCst) {
         return Ok(state.snapshot());
     }
-
+    if let Some(previous) = task.take() {
+        let _ = previous.await;
+    }
     let settings = state.settings.lock().unwrap().clone();
-    state.stats.set_worker_domain(&settings.worker_domain);
-    *state.active_port.lock().unwrap() = settings.port;
-    *state.started_at.lock().unwrap() = Some(Instant::now());
-    state.log("Запускаю защищённый маршрут…", false);
-
     let listen = if settings.lan_mode {
         ListenConfig::lan(settings.port)
     } else {
         ListenConfig::loopback(settings.port)
     };
-
+    let listener = proxy::bind(listen).await?;
+    // Called while the user's Activity is visible, before opening Telegram.
+    // A rejected foreground-service start must not leave a hidden proxy running.
+    set_foreground_service(&app, true)?;
+    state.stats.set_worker_domain(&settings.worker_domain);
+    *state.active_port.lock().unwrap() = settings.port;
+    *state.active_listen.lock().unwrap() = Some(listen);
+    *state.started_at.lock().unwrap() = Some(Instant::now());
     let stats = state.stats.clone();
     let logs = state.logs.clone();
-    std::thread::spawn(move || {
+    let worker_app = app.clone();
-        let runtime = match tokio::runtime::Runtime::new() {
+    let worker = tokio::spawn(async move {
-            Ok(runtime) => runtime,
+        if let Err(error) = proxy::serve(stats.clone(), listener, listen.allow_direct).await {
-            Err(error) => {
-                push_log(&logs, format!("Не удалось запустить сервис: {error}"), true);
-                return;
-            }
-        };
-        if let Err(error) = runtime.block_on(proxy::run(stats, listen)) {
             push_log(&logs, format!("Ошибка подключения: {error}"), true);
         }
-    });
+        stats.running.store(false, Ordering::SeqCst);
-
+        if let Err(error) = set_foreground_service(&worker_app, false) {
-    std::thread::sleep(std::time::Duration::from_millis(220));
+            push_log(&logs, error, true);
-    if !state.stats.running.load(Ordering::SeqCst) {
+        }
-        *state.started_at.lock().unwrap() = None;
+    });
-        return Err(state
+    while !state.stats.running.load(Ordering::SeqCst) && !worker.is_finished() {
-            .logs
+        tokio::task::yield_now().await;
-            .lock()
+    }
-            .unwrap()
+    *task = Some(worker);
-            .last()
+    if !state.stats.running.load(Ordering::SeqCst) {
-            .map(|line| line.message.clone())
+        *state.active_listen.lock().unwrap() = None;
-            .unwrap_or_else(|| "Не удалось запустить прокси".into()));
+        *state.started_at.lock().unwrap() = None;
+        return Err("Не удалось запустить прокси; подробности в диагностике".into());
     }
-
     state.log(format!("Прокси запущен на {}", listen.addr), false);
-    // The opener plugin works on desktop and on Android alike; the `open`
+    if let Err(error) = open_telegram_link(&app, &state) {
-    // crate has no Android implementation.
+        // The working proxy remains available through the copy-link control.
-    let _ = app.opener().open_url(
+        state.log(error, true);
-        listen.telegram_link(&state.stats.telegram_secret()),
+    }
-        None::<&str>,
-    );
-    state.log("Открываю подключение в Telegram…", false);
     Ok(state.snapshot())
 }
 
 #[tauri::command]
-fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
+async fn stop_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
+    let mut task = state.task.lock().await;
     state.stats.stop();
+    if let Some(worker) = task.take() {
+        let _ = worker.await;
+    }
+    *state.active_listen.lock().unwrap() = None;
     *state.started_at.lock().unwrap() = None;
     state.log("Защита выключена", false);
-    state.snapshot()
+    Ok(state.snapshot())
+}
+
+fn telegram_link(state: &AppState) -> Result<String, String> {
+    if !state.stats.running.load(Ordering::SeqCst) {
+        return Err("Сначала включите защиту".into());
+    }
+    state
+        .active_listen
+        .lock()
+        .unwrap()
+        .map(|listen| listen.telegram_link(&state.stats.telegram_secret()))
+        .ok_or_else(|| "Сначала включите защиту".into())
+}
+
+#[tauri::command]
+fn get_telegram_link(state: State<'_, AppState>) -> Result<String, String> {
+    telegram_link(&state)
+}
+
+fn open_telegram_link(app: &tauri::AppHandle, state: &AppState) -> Result<(), String> {
+    app.opener()
+        .open_url(telegram_link(state)?, None::<&str>)
+        .map_err(|error| {
+            format!("Не удалось открыть Telegram: {error}. Скопируйте ссылку подключения.")
+        })
+}
+
+#[tauri::command]
+async fn open_telegram(app: tauri::AppHandle, state: State<'_, AppState>) -> Result<(), String> {
+    open_telegram_link(&app, &state)
+}
+
+#[cfg(target_os = "android")]
+struct TunnelPlugin(tauri::plugin::PluginHandle<tauri::Wry>);
+
+#[cfg(target_os = "android")]
+fn set_foreground_service(app: &tauri::AppHandle, enabled: bool) -> Result<(), String> {
+    app.state::<TunnelPlugin>()
+        .0
+        .run_mobile_plugin::<serde_json::Value>(
+            "setEnabled",
+            serde_json::json!({ "enabled": enabled }),
+        )
+        .map(|_| ())
+        .map_err(|error| format!("Фоновый сервис Android: {error}"))
+}
+
+#[cfg(not(target_os = "android"))]
+fn set_foreground_service(_app: &tauri::AppHandle, _enabled: bool) -> Result<(), String> {
+    Ok(())
 }
 
 fn push_log(logs: &Arc<Mutex<Vec<LogLine>>>, message: String, error: bool) {
@@ -252,10 +358,12 @@ fn software_rendering_vars(
             "WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS",
             "--disable-gpu --disable-gpu-compositing",
         )]
-    } else if cfg!(target_os = "macos") || cfg!(target_os = "android") {
+    } else if cfg!(any(
-        // WebKit on macOS falls back to software rendering on its own, and on a
+        target_os = "macos",
-        // phone the WebView always has a GPU — forcing software rendering there
+        target_os = "android",
-        // would only make the interface slower.
+        target_os = "ios"
+    )) {
+        // WebKit on macOS falls back to software rendering on its own.
         &[]
     } else {
         &[
@@ -278,25 +386,44 @@ fn prefer_software_rendering() {
     }
 }
 
-/// Entry point of the graphical application.
-///
-/// On desktop this is called from `main`. On Android the platform loads the
-/// crate as a shared library and calls this through the JNI entry point that
-/// `tauri::mobile_entry_point` generates, which is why the app lives in the
-/// library rather than in `main.rs`.
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
     prefer_software_rendering();
 
-    tauri::Builder::default()
+    let builder = tauri::Builder::default().plugin(tauri_plugin_opener::init());
-        .plugin(tauri_plugin_opener::init())
+    #[cfg(target_os = "android")]
+    let builder = builder.plugin(
+        tauri::plugin::Builder::<tauri::Wry>::new("tunnel")
+            .setup(|app, api| {
+                let handle = api.register_android_plugin("com.bysonic.tglock", "TunnelPlugin")?;
+                app.manage(TunnelPlugin(handle));
+                Ok(())
+            })
+            .build(),
+    );
+    builder
         .setup(|app| {
             let settings_path = app
                 .path()
                 .app_config_dir()
                 .map_err(|error| error.to_string())?
                 .join("settings.json");
-            app.manage(AppState::new(settings_path));
+            let secret_path = settings_path.with_file_name("secret");
+            let stored = crate::mtproto::load_or_create_secret_at_with_migration(
+                &secret_path,
+                crate::mtproto::legacy_secret_path().as_deref(),
+            );
+            let state = AppState::new(settings_path, proxy::Stats::with_stored_secret(stored));
+            // Если секрет не удалось записать, ссылка tg://proxy изменится после
+            // перезапуска и Telegram откажется подключаться к сохранённой.
+            // Раньше это происходило молча (by-sonic/tglock#37).
+            if let Some(error) = state.stats.secret_write_error() {
+                state.log(
+                    format!("Секрет не записан ({error}). Проверьте ссылку после перезапуска"),
+                    true,
+                );
+            }
+            app.manage(state);
             Ok(())
         })
         .invoke_handler(tauri::generate_handler![
@@ -304,7 +431,9 @@ pub fn run() {
             get_settings,
             save_settings,
             start_proxy,
-            stop_proxy
+            stop_proxy,
+            get_telegram_link,
+            open_telegram
         ])
         .run(tauri::generate_context!())
         .expect("failed to run TGLock");
@@ -314,10 +443,42 @@ pub fn run() {
 mod tests {
     use super::*;
 
+    #[test]
+    fn nothing_to_share_when_the_proxy_is_off_or_local() {
+        assert_eq!(
+            share_address(None),
+            None,
+            "выключенный прокси нечего делить"
+        );
+        assert_eq!(
+            share_address(Some(ListenConfig::loopback(1080))),
+            None,
+            "на loopback снаружи никто не подключится"
+        );
+    }
+
+    #[test]
+    fn lan_mode_shares_a_reachable_address() {
+        let shown = share_address(Some(ListenConfig::lan(1443))).expect("в LAN-режиме адрес нужен");
+        assert!(shown.ends_with(":1443"), "порт должен быть виден: {shown}");
+        assert!(
+            !shown.starts_with("0.0.0.0"),
+            "0.0.0.0 нельзя вписать в Telegram: {shown}"
+        );
+        assert!(
+            !shown.starts_with("127.0.0.1"),
+            "127.0.0.1 на другом устройстве означает само устройство: {shown}"
+        );
+    }
+
     #[test]
     fn software_rendering_is_requested_by_default() {
         let vars = software_rendering_vars(false, |_| false);
-        if cfg!(target_os = "macos") {
+        if cfg!(any(
+            target_os = "macos",
+            target_os = "android",
+            target_os = "ios"
+        )) {
             assert!(vars.is_empty(), "macOS needs no override");
         } else {
             assert!(

src/lib.rs

@@ -1,17 +1,20 @@
 //! TGLock core: the MTProto/WebSocket transport shared by the desktop GUI and
 //! the headless CLI.
 //!
-//! Nothing in this crate depends on Tauri or on a windowing system, so the
+//! With the `gui` feature disabled this crate does not depend on Tauri, so the
 //! `tglock-cli` binary can be built with `--no-default-features` on a server
 //! that has neither a GPU nor a monitor.
 
 pub mod config;
 pub mod mtproto;
 pub mod proxy;
+pub mod telegram_net;
 pub mod transport;
 
-/// The graphical application, shared by the desktop binary and the Android
+/// Настройки headless-версии: файл конфигурации и сведение с флагами.
-/// package. Compiled only with the `gui` feature, so a headless build never
+#[cfg(feature = "cli")]
-/// pulls in Tauri or a WebView.
+pub mod cli_settings;
+
+/// Desktop and Android graphical application; absent from headless builds.
 #[cfg(feature = "gui")]
 pub mod gui;

src/main.rs

@@ -1,10 +1,5 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-// The application itself lives in `tglock_lib::gui` because Android loads the crate
-// as a shared library and enters through a JNI symbol rather than through
-// `main`. Keeping one implementation for both platforms means the desktop
-// binary is just this shim.
-
 fn main() {
-    tglock_lib::gui::run()
+    tglock_lib::gui::run();
 }

src/mtproto.rs

@@ -2,9 +2,7 @@ use aes::Aes256;
 use cipher::{KeyIvInit, StreamCipher};
 use rand::{rngs::OsRng, RngCore};
 use sha2::{Digest, Sha256};
-use std::path::Path;
+use std::path::{Path, PathBuf};
-#[cfg(not(test))]
-use std::path::PathBuf;
 
 type AesCtr = ctr::Ctr128BE<Aes256>;
 
@@ -43,6 +41,49 @@ impl CryptoContext {
         self.telegram_decrypt.apply_keystream(data);
         self.client_encrypt.apply_keystream(data);
     }
+
+    /// Разделить шифры по направлениям, чтобы туннель шёл в обе стороны сразу.
+    ///
+    /// Направления независимы: это два потока AES-CTR со своими ключами, и ни
+    /// один байт одного не влияет на другой.
+    pub fn split(self) -> (Upstream, Downstream) {
+        (
+            Upstream {
+                client_decrypt: self.client_decrypt,
+                telegram_encrypt: self.telegram_encrypt,
+            },
+            Downstream {
+                telegram_decrypt: self.telegram_decrypt,
+                client_encrypt: self.client_encrypt,
+            },
+        )
+    }
+}
+
+/// Шифры направления «клиент -> Telegram».
+pub struct Upstream {
+    client_decrypt: AesCtr,
+    telegram_encrypt: AesCtr,
+}
+
+impl Upstream {
+    pub fn apply(&mut self, data: &mut [u8]) {
+        self.client_decrypt.apply_keystream(data);
+        self.telegram_encrypt.apply_keystream(data);
+    }
+}
+
+/// Шифры направления «Telegram -> клиент».
+pub struct Downstream {
+    telegram_decrypt: AesCtr,
+    client_encrypt: AesCtr,
+}
+
+impl Downstream {
+    pub fn apply(&mut self, data: &mut [u8]) {
+        self.telegram_decrypt.apply_keystream(data);
+        self.client_encrypt.apply_keystream(data);
+    }
 }
 
 pub fn generate_secret() -> [u8; 16] {
@@ -51,36 +92,77 @@ pub fn generate_secret() -> [u8; 16] {
     secret
 }
 
-/// Reuse the secret stored at `path`, creating it if it is missing or unusable.
+/// Секрет прокси и то, лежит ли он на диске.
+pub struct StoredSecret {
+    pub value: [u8; 16],
+    /// Ошибка, из-за которой секрет не удалось сохранить.
     ///
-/// A daemon needs this: the secret is half of the `tg://proxy` link, so a
+    /// Если она есть, при следующем запуске секрет будет другим, ссылка
-/// service that invents a new one on every restart silently invalidates every
+    /// `tg://proxy` перестанет совпадать с сохранённой в Telegram, и Telegram
-/// client that was already configured.
+    /// скажет «прокси настроен неверно и будет отключён». Раньше запись
-pub fn load_or_create_secret_at(path: &Path) -> [u8; 16] {
+    /// провалившись молчала, и понять причину было невозможно
+    /// (by-sonic/tglock#37).
+    pub write_error: Option<String>,
+}
+
+impl StoredSecret {
+    /// Секрет действительно переживёт перезапуск.
+    pub fn is_persistent(&self) -> bool {
+        self.write_error.is_none()
+    }
+}
+
+/// Взять секрет из файла, создав его, если файла нет или он испорчен.
+///
+/// Секрет — половина ссылки `tg://proxy`, поэтому сервис, придумывающий новый
+/// при каждом старте, отключает всех уже настроенных клиентов.
+pub fn load_or_create_secret_at(path: &Path) -> StoredSecret {
+    load_or_create_secret_at_with_migration(path, None)
+}
+
+/// Preserve desktop proxy links when the GUI moves to Tauri's app directory.
+/// The legacy file remains intact, including when copying it fails.
+pub fn load_or_create_secret_at_with_migration(path: &Path, legacy: Option<&Path>) -> StoredSecret {
     if let Ok(value) = std::fs::read_to_string(path) {
-        if let Some(secret) = parse_secret_hex(value.trim()) {
+        if let Some(value) = parse_secret_hex(value.trim()) {
-            return secret;
+            return StoredSecret {
+                value,
+                write_error: None,
+            };
         }
     }
 
-    let secret = generate_secret();
+    let value = legacy
+        .and_then(|legacy| std::fs::read_to_string(legacy).ok())
+        .and_then(|value| parse_secret_hex(value.trim()))
+        .unwrap_or_else(generate_secret);
+    let write_error = store_secret(path, &secret_hex(&value))
+        .err()
+        .map(|error| format!("{}: {error}", path.display()));
+    StoredSecret { value, write_error }
+}
+
+fn store_secret(path: &Path, value: &str) -> std::io::Result<()> {
     if let Some(parent) = path.parent() {
-        let _ = std::fs::create_dir_all(parent);
+        if !parent.as_os_str().is_empty() {
+            std::fs::create_dir_all(parent)?;
         }
-    write_secret_file(path, &secret_hex(&secret));
+    }
-    secret
+    write_secret_file(path, value)
 }
 
 #[cfg(not(test))]
-pub fn load_or_create_secret() -> [u8; 16] {
+pub fn load_or_create_secret() -> StoredSecret {
-    match secret_path() {
+    match legacy_secret_path() {
         Some(path) => load_or_create_secret_at(&path),
-        None => generate_secret(),
+        None => StoredSecret {
+            value: generate_secret(),
+            write_error: Some("не удалось определить папку для секрета в этой системе".to_owned()),
+        },
     }
 }
 
-#[cfg(not(test))]
+pub fn legacy_secret_path() -> Option<PathBuf> {
-fn secret_path() -> Option<PathBuf> {
     #[cfg(target_os = "windows")]
     {
         std::env::var_os("APPDATA")
@@ -105,23 +187,21 @@ fn secret_path() -> Option<PathBuf> {
 }
 
 #[cfg(unix)]
-fn write_secret_file(path: &Path, value: &str) {
+fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
     use std::io::Write;
     use std::os::unix::fs::OpenOptionsExt;
-    if let Ok(mut file) = std::fs::OpenOptions::new()
+    let mut file = std::fs::OpenOptions::new()
         .create(true)
         .truncate(true)
         .write(true)
         .mode(0o600)
-        .open(path)
+        .open(path)?;
-    {
+    file.write_all(value.as_bytes())
-        let _ = file.write_all(value.as_bytes());
-    }
 }
 
 #[cfg(not(unix))]
-fn write_secret_file(path: &Path, value: &str) {
+fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
-    let _ = std::fs::write(path, value);
+    std::fs::write(path, value)
 }
 
 pub fn secret_hex(secret: &[u8; 16]) -> String {
@@ -133,8 +213,21 @@ pub fn secret_hex(secret: &[u8; 16]) -> String {
     output
 }
 
+/// Разобрать секрет, записанный человеком.
+///
+/// Принимает и 32 hex-символа, и форму с префиксом `dd` — именно так секрет
+/// выглядит в ссылке `tg://proxy`, откуда его и копируют.
+pub fn parse_secret(value: &str) -> Option<[u8; 16]> {
+    let trimmed = value.trim();
+    let hex = trimmed
+        .strip_prefix("dd")
+        .filter(|rest| rest.len() == 32)
+        .unwrap_or(trimmed);
+    parse_secret_hex(hex)
+}
+
 fn parse_secret_hex(value: &str) -> Option<[u8; 16]> {
-    if value.len() != 32 {
+    if value.len() != 32 || !value.is_ascii() {
         return None;
     }
     let mut secret = [0; 16];
@@ -213,6 +306,7 @@ fn is_reserved_init(init: &[u8; INIT_LEN]) -> bool {
         || &init[..4] == b"HEAD"
         || &init[..4] == b"POST"
         || &init[..4] == b"GET "
+        || &init[..4] == b"OPTI"
         || init[..4] == [0xee; 4]
         || init[..4] == [0xdd; 4]
         || init[..4] == [0x16, 0x03, 0x01, 0x02]
@@ -501,6 +595,144 @@ mod tests {
         }
     }
 
+    #[test]
+    fn a_failed_write_is_reported_instead_of_swallowed() {
+        // Раньше ошибка записи выбрасывалась, секрет генерировался заново при
+        // каждом запуске, и Telegram говорил «прокси настроен неверно» без
+        // единой подсказки почему (by-sonic/tglock#37).
+        let blocker = std::env::temp_dir().join(format!(
+            "tglock-not-a-dir-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        std::fs::write(&blocker, "я файл, а не папка").unwrap();
+
+        // Родитель пути — обычный файл, поэтому создать каталог невозможно.
+        let stored = load_or_create_secret_at(&blocker.join("secret"));
+
+        assert!(
+            !stored.is_persistent(),
+            "неудачная запись обязана быть видна"
+        );
+        let error = stored.write_error.expect("должно быть сообщение об ошибке");
+        assert!(
+            error.contains("secret"),
+            "в сообщении должен быть путь, получено: {error}"
+        );
+        // Секрет всё равно выдан: прокси работает, просто до перезапуска.
+        assert_ne!(stored.value, [0; 16]);
+
+        let _ = std::fs::remove_file(&blocker);
+    }
+
+    #[test]
+    fn a_successful_write_reports_no_error() {
+        let path = std::env::temp_dir().join(format!(
+            "tglock-secret-ok-{}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        ));
+        let _ = std::fs::remove_file(&path);
+
+        let first = load_or_create_secret_at(&path);
+        assert!(first.is_persistent(), "запись в temp должна удаваться");
+
+        // Второй запуск читает готовый файл и тоже не жалуется.
+        let second = load_or_create_secret_at(&path);
+        assert!(second.is_persistent());
+        assert_eq!(
+            first.value, second.value,
+            "секрет должен переживать перезапуск"
+        );
+
+        let _ = std::fs::remove_file(&path);
+    }
+
+    #[test]
+    fn accepts_a_secret_copied_from_a_tg_link() {
+        let expected = [
+            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+            0xee, 0xff,
+        ];
+        // Обе формы: как в файле и как в ссылке tg://proxy.
+        assert_eq!(
+            parse_secret("00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        assert_eq!(
+            parse_secret("dd00112233445566778899aabbccddeeff"),
+            Some(expected)
+        );
+        // Пробелы по краям — обычное дело при копировании.
+        assert_eq!(
+            parse_secret("  dd00112233445566778899aabbccddeeff\n"),
+            Some(expected)
+        );
+        // Секрет, который сам начинается с dd и уже имеет полную длину, не
+        // должен потерять первый байт: префикс снимается только если после него
+        // остаётся ровно 32 символа.
+        assert_eq!(
+            parse_secret("dd112233445566778899aabbccddeeff"),
+            Some([
+                0xdd, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
+                0xee, 0xff,
+            ])
+        );
+    }
+
+    #[test]
+    fn rejects_malformed_secrets() {
+        for bad in [
+            "",
+            "dd",
+            "слишком коротко",
+            "00112233445566778899aabbccddee",     // 30 символов
+            "00112233445566778899aabbccddeeffff", // 34 символа
+            "zz112233445566778899aabbccddeeff",   // не hex
+            "0я00000000000000000000000000000",    // 32 bytes, UTF-8 boundary at byte 2
+        ] {
+            assert!(parse_secret(bad).is_none(), "{bad:?} должен быть отвергнут");
+        }
+    }
+
+    #[test]
+    fn android_obfuscated2_vector_survives_fragmented_translation() {
+        // Independently generated with Node/OpenSSL AES-256-CTR and SHA-256,
+        // following Telegram Android Connection.cpp sendData/encryptKeyWithSecret.
+        // Fixed wire bytes avoid a symmetric mistake in the test peer helpers.
+        fn bytes(hex: &str) -> Vec<u8> {
+            hex.as_bytes()
+                .as_chunks::<2>()
+                .0
+                .iter()
+                .map(|pair| u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap())
+                .collect()
+        }
+        let init: [u8; 64] = bytes(concat!(
+            "0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20212223",
+            "2425262728292a2b2c2d2e2f303132333435363738043de6c25808afa3"
+        ))
+        .try_into()
+        .unwrap();
+        let parsed = parse_client_init(&init, &[42; 16]).unwrap();
+        assert_eq!(parsed.dc, 4);
+        assert!(parsed.media);
+        let mut relay = test_relay_peer(&parsed.relay_init);
+        let (mut upstream, mut downstream) = parsed.crypto.split();
+        let mut request = bytes("31fc48bfc21f9210a57fd63ac344ae50a3a23620");
+        for chunk in request.chunks_mut(3) {
+            upstream.apply(chunk);
+            relay.decrypt(chunk);
+        }
+        assert_eq!(request, bytes("10000000112233445566778899aabbccddeeff00"));
+        let mut reply = bytes("04000000ecfeffff");
+        relay.encrypt(&mut reply);
+        for chunk in reply.chunks_mut(1) {
+            downstream.apply(chunk);
+        }
+        assert_eq!(reply, bytes("d5a69e839ec08ebf"));
+    }
+
     #[test]
     fn parses_persisted_secret() {
         assert_eq!(
@@ -512,4 +744,70 @@ mod tests {
         );
         assert_eq!(parse_secret_hex("not-a-secret"), None);
     }
+
+    #[test]
+    fn secret_migration_keeps_legacy_links_and_prefers_existing_destination() {
+        let root = std::env::temp_dir().join(format!(
+            "tglock-migration-{}",
+            secret_hex(&generate_secret())
+        ));
+        std::fs::create_dir(&root).unwrap();
+        let legacy = root.join("legacy");
+        let destination = root.join("secret");
+        std::fs::write(&legacy, secret_hex(&[17; 16])).unwrap();
+        let first = load_or_create_secret_at_with_migration(&destination, Some(&legacy));
+        assert_eq!(first.value, [17; 16]);
+        assert!(first.is_persistent());
+        assert_eq!(
+            std::fs::read_to_string(&legacy).unwrap(),
+            secret_hex(&[17; 16])
+        );
+        #[cfg(unix)]
+        {
+            use std::os::unix::fs::PermissionsExt;
+            assert_eq!(
+                std::fs::metadata(&destination)
+                    .unwrap()
+                    .permissions()
+                    .mode()
+                    & 0o777,
+                0o600
+            );
+        }
+        std::fs::write(&legacy, secret_hex(&[23; 16])).unwrap();
+        let second = load_or_create_secret_at_with_migration(&destination, Some(&legacy));
+        assert_eq!(
+            second.value, [17; 16],
+            "an existing destination wins on restart"
+        );
+        std::fs::remove_file(destination).unwrap();
+        std::fs::remove_file(legacy).unwrap();
+        std::fs::remove_dir(root).unwrap();
+    }
+
+    #[test]
+    fn failed_migration_reports_error_but_does_not_rotate_the_legacy_secret() {
+        let root = std::env::temp_dir().join(format!(
+            "tglock-migration-fail-{}",
+            secret_hex(&generate_secret())
+        ));
+        std::fs::create_dir(&root).unwrap();
+        let legacy = root.join("legacy");
+        let blocker = root.join("blocker");
+        std::fs::write(&legacy, secret_hex(&[29; 16])).unwrap();
+        std::fs::write(&blocker, "not a directory").unwrap();
+        let destination = blocker.join("secret");
+        for _ in 0..2 {
+            let stored = load_or_create_secret_at_with_migration(&destination, Some(&legacy));
+            assert_eq!(stored.value, [29; 16]);
+            assert!(stored.write_error.is_some());
+        }
+        assert_eq!(
+            std::fs::read_to_string(&legacy).unwrap(),
+            secret_hex(&[29; 16])
+        );
+        std::fs::remove_file(blocker).unwrap();
+        std::fs::remove_file(legacy).unwrap();
+        std::fs::remove_dir(root).unwrap();
+    }
 }

src/telegram_net.rs

@@ -0,0 +1,271 @@
+//! Какие адреса и имена принадлежат Telegram.
+//!
+//! От этого ответа зависит поведение LAN-режима: слушатель на сетевом адресе
+//! пропускает только Telegram, всё остальное отклоняет. Значит ошибка в любую
+//! сторону видна пользователю.
+//!
+//! Раньше проверка сравнивала два первых октета, то есть считала «телеграмом»
+//! целиком `149.154.0.0/16`, `91.108.0.0/16`, `91.105.0.0/16` и `185.76.0.0/16`,
+//! а IPv6 не знала вовсе. Отсюда два разных дефекта: чужие адреса внутри этих
+//! сетей уходили в MTProto-туннель и умирали, а настоящие адреса Telegram по
+//! IPv6 отклонялись как посторонние. Второе и выглядит как «на компьютере
+//! работает, с телефона нет» (by-sonic/tglock#42): на loopback не-Telegram
+//! адреса всё равно релеятся напрямую, поэтому там ошибка не проявляется.
+//!
+//! Список сетей — официальный, <https://core.telegram.org/resources/cidr.txt>,
+//! сверен 19 августа 2026 года.
+
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+
+/// IPv4-сети Telegram: адрес сети и длина префикса.
+const V4: &[(Ipv4Addr, u32)] = &[
+    (Ipv4Addr::new(91, 105, 192, 0), 23),
+    (Ipv4Addr::new(91, 108, 4, 0), 22),
+    (Ipv4Addr::new(91, 108, 8, 0), 22),
+    (Ipv4Addr::new(91, 108, 12, 0), 22),
+    (Ipv4Addr::new(91, 108, 16, 0), 22),
+    (Ipv4Addr::new(91, 108, 20, 0), 22),
+    (Ipv4Addr::new(91, 108, 56, 0), 22),
+    (Ipv4Addr::new(149, 154, 160, 0), 20),
+    (Ipv4Addr::new(185, 76, 151, 0), 24),
+];
+
+/// IPv6-сети Telegram.
+const V6: &[(Ipv6Addr, u32)] = &[
+    (Ipv6Addr::new(0x2001, 0x67c, 0x4e8, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23c, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23d, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2001, 0xb28, 0xf23f, 0, 0, 0, 0, 0), 48),
+    (Ipv6Addr::new(0x2a0a, 0xf280, 0, 0, 0, 0, 0, 0), 32),
+];
+
+/// Домены Telegram, к которым SOCKS5-клиент может попроситься по имени.
+///
+/// Это веб-инфраструктура, а не дата-центры: обычный HTTPS, MTProto в нём нет.
+/// Telegram ходит сюда за конфигурацией, превью ссылок и файлами CDN, и на
+/// телефоне такие запросы идут через тот же прокси.
+const HOSTS: &[&str] = &[
+    "telegram.org",
+    "t.me",
+    "telegram.me",
+    "telesco.pe",
+    "cdn-telegram.org",
+];
+
+/// Принадлежит ли адрес Telegram.
+pub fn is_telegram(ip: IpAddr) -> bool {
+    match ip {
+        IpAddr::V4(ip) => in_v4(ip),
+        // Клиент может прислать `::ffff:149.154.167.51` вместо IPv4-формы, и
+        // это тот же самый адрес.
+        IpAddr::V6(ip) => match ip.to_ipv4_mapped() {
+            Some(ip) => in_v4(ip),
+            None => in_v6(ip),
+        },
+    }
+}
+
+/// Принадлежит ли имя Telegram.
+///
+/// Совпадение только по границе метки: `telegram.org.example.com` — чужой
+/// домен, и разрешать его нельзя.
+pub fn is_telegram_host(host: &str) -> bool {
+    let host = host.trim_end_matches('.').to_ascii_lowercase();
+    HOSTS.iter().any(|suffix| {
+        host == *suffix
+            || (host.len() > suffix.len()
+                && host.ends_with(suffix)
+                && host.as_bytes()[host.len() - suffix.len() - 1] == b'.')
+    })
+}
+
+/// Номер дата-центра по адресу — запасной вариант, когда его не удалось
+/// достать из init-пакета.
+///
+/// Это догадка, а не факт: одна и та же подсеть обслуживает несколько DC
+/// (`149.154.175.x` — и DC1, и DC3). Настоящий номер приходит из init, и сюда
+/// попадают только соединения, у которых init разобрать не вышло.
+pub fn dc_from_ip(ip: IpAddr) -> Option<u16> {
+    match ip {
+        IpAddr::V4(ip) => dc_from_ipv4(ip),
+        IpAddr::V6(ip) => match ip.to_ipv4_mapped() {
+            Some(ip) => dc_from_ipv4(ip),
+            None => dc_from_ipv6(ip),
+        },
+    }
+}
+
+fn dc_from_ipv4(ip: Ipv4Addr) -> Option<u16> {
+    if !in_v4(ip) {
+        return None;
+    }
+    let octets = ip.octets();
+    Some(match (octets[0], octets[1], octets[2]) {
+        (149, 154, 160..=163) => 1,
+        (149, 154, 164..=167) => 2,
+        (149, 154, 168..=171) => 3,
+        (149, 154, 172..=175) => 1,
+        (91, 108, 56..=59) => 5,
+        (91, 108, 8..=11) => 3,
+        (91, 108, 12..=15) => 4,
+        (91, 105, 192..=193) => 203,
+        _ => 2,
+    })
+}
+
+/// Адреса дата-центров имеют вид `2001:b28:f23d:f002::a`, где `f00N` —
+/// номер DC. Для `2a0a:f280::/32` такого правила нет, и выдумывать его не
+/// нужно: номер придёт из init.
+fn dc_from_ipv6(ip: Ipv6Addr) -> Option<u16> {
+    if !in_v6(ip) {
+        return None;
+    }
+    let dc = ip.segments()[3].checked_sub(0xf000)?;
+    matches!(dc, 1..=5).then_some(dc)
+}
+
+fn in_v4(ip: Ipv4Addr) -> bool {
+    let value = u32::from(ip);
+    V4.iter().any(|&(network, prefix)| {
+        let mask = u32::MAX.checked_shl(32 - prefix).unwrap_or(0);
+        value & mask == u32::from(network) & mask
+    })
+}
+
+fn in_v6(ip: Ipv6Addr) -> bool {
+    let value = u128::from(ip);
+    V6.iter().any(|&(network, prefix)| {
+        let mask = u128::MAX.checked_shl(128 - prefix).unwrap_or(0);
+        value & mask == u128::from(network) & mask
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn ip(value: &str) -> IpAddr {
+        value.parse().unwrap()
+    }
+
+    #[test]
+    fn known_data_centre_addresses_are_telegram() {
+        for address in [
+            "149.154.175.50", // DC1
+            "149.154.167.51", // DC2
+            "149.154.175.100",
+            "149.154.167.91",
+            "91.108.56.130", // DC5
+            "91.105.192.100",
+            "185.76.151.1",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} принадлежит Telegram");
+        }
+    }
+
+    /// Раньше сюда попадал весь `/16`, то есть десятки тысяч чужих адресов.
+    #[test]
+    fn neighbours_outside_the_published_blocks_are_not_telegram() {
+        for address in [
+            "149.154.159.255", // на один адрес ниже 149.154.160.0/20
+            "149.154.176.0",   // на один выше
+            "91.108.3.255",
+            "91.108.24.0",
+            "91.108.60.0",
+            "91.105.194.0",
+            "185.76.150.255",
+            "185.76.152.0",
+            "1.1.1.1",
+        ] {
+            assert!(!is_telegram(ip(address)), "{address} — не Telegram");
+        }
+    }
+
+    #[test]
+    fn block_edges_belong_to_the_block() {
+        for address in [
+            "149.154.160.0",
+            "149.154.175.255",
+            "91.108.4.0",
+            "91.108.7.255",
+            "185.76.151.0",
+            "185.76.151.255",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} — край блока Telegram");
+        }
+    }
+
+    /// Из-за этого LAN-режим отклонял живой Telegram (by-sonic/tglock#42).
+    #[test]
+    fn ipv6_data_centres_are_telegram_too() {
+        for address in [
+            "2001:b28:f23d:f001::a",
+            "2001:67c:4e8:f002::a",
+            "2001:b28:f23d:f003::a",
+            "2001:67c:4e8:f004::a",
+            "2001:b28:f23f:f005::a",
+            "2001:b28:f23c::1",
+            "2a0a:f280:203:a::b",
+        ] {
+            assert!(is_telegram(ip(address)), "{address} принадлежит Telegram");
+        }
+        assert!(!is_telegram(ip("2606:4700:4700::1111")), "это Cloudflare");
+        assert!(!is_telegram(ip("2001:b28:f23e::1")), "соседний префикс");
+    }
+
+    #[test]
+    fn ipv4_mapped_form_is_the_same_address() {
+        assert!(is_telegram(ip("::ffff:149.154.167.51")));
+        assert!(!is_telegram(ip("::ffff:1.1.1.1")));
+    }
+
+    /// Поведение, на которое опирался предыдущий тест `dc_from_ip`.
+    #[test]
+    fn data_centre_guess_survives_the_stricter_membership_check() {
+        assert_eq!(dc_from_ip(ip("149.154.160.1")), Some(1));
+        assert_eq!(dc_from_ip(ip("149.154.167.255")), Some(2));
+        assert_eq!(dc_from_ip(ip("91.108.58.1")), Some(5));
+        assert_eq!(dc_from_ip(ip("1.1.1.1")), None);
+    }
+
+    #[test]
+    fn data_centre_guess_reads_the_number_out_of_an_ipv6_address() {
+        assert_eq!(dc_from_ip(ip("2001:67c:4e8:f002::a")), Some(2));
+        assert_eq!(dc_from_ip(ip("2001:b28:f23f:f005::a")), Some(5));
+        assert_eq!(
+            dc_from_ip(ip("2a0a:f280:203:a::b")),
+            None,
+            "для этого префикса правила нет — лучше признаться, чем выдумать"
+        );
+    }
+
+    #[test]
+    fn telegram_hosts_are_matched_on_label_boundaries() {
+        for host in [
+            "telegram.org",
+            "web.telegram.org",
+            "core.telegram.org",
+            "venus.web.telegram.org",
+            "t.me",
+            "TELEGRAM.ORG",
+            "telegram.org.", // корневая точка в имени законна
+            "cdn4.cdn-telegram.org",
+        ] {
+            assert!(is_telegram_host(host), "{host} — Telegram");
+        }
+    }
+
+    #[test]
+    fn lookalike_hosts_are_rejected() {
+        for host in [
+            "telegram.org.example.com",
+            "nottelegram.org",
+            "fakecdn-telegram.org",
+            "t.me.evil.net",
+            "example.com",
+            "",
+        ] {
+            assert!(!is_telegram_host(host), "{host} — не Telegram");
+        }
+    }
+}

src/transport.rs

@@ -1,24 +1,38 @@
 use std::collections::HashMap;
-use std::sync::Mutex;
+use std::sync::atomic::{AtomicU32, Ordering};
-use std::time::{Duration, Instant};
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::Duration;
 
+use futures_util::stream::{FuturesUnordered, StreamExt};
 use tokio::net::TcpStream;
+use tokio::time::Instant;
 use tokio_tungstenite::tungstenite::client::IntoClientRequest;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
 
 const CONNECT_TIMEOUT: Duration = Duration::from_secs(4);
+const FALLBACK_DELAY: Duration = Duration::from_millis(250);
+const MAX_CONNECTING: usize = 3;
 const FAILURE_BACKOFF_INITIAL: Duration = Duration::from_secs(30);
 const FAILURE_BACKOFF_MAX: Duration = Duration::from_secs(30 * 60);
 const HTTPS_PORT: u16 = 443;
+const CDN203_IP: &str = "91.105.192.100";
 
 pub type TelegramWebSocket = WebSocketStream<MaybeTlsStream<TcpStream>>;
 
+#[derive(Debug)]
+pub enum TelegramConnection {
+    WebSocket(Box<TelegramWebSocket>),
+    /// Native obfuscated2 transport, currently restricted to the CDN203 IP.
+    Tcp(TcpStream),
+}
+
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum RouteKind {
     TelegramIp,
     AlternateTelegramIp,
     SystemDns,
     CloudflareWorker,
+    TelegramTcp,
 }
 
 impl RouteKind {
@@ -28,6 +42,7 @@ impl RouteKind {
             Self::AlternateTelegramIp => 2,
             Self::SystemDns => 3,
             Self::CloudflareWorker => 4,
+            Self::TelegramTcp => 5,
         }
     }
 
@@ -37,6 +52,7 @@ impl RouteKind {
             2 => Some(Self::AlternateTelegramIp),
             3 => Some(Self::SystemDns),
             4 => Some(Self::CloudflareWorker),
+            5 => Some(Self::TelegramTcp),
             _ => None,
         }
     }
@@ -48,6 +64,7 @@ impl RouteKind {
             Self::AlternateTelegramIp => "Запасной Telegram IP",
             Self::SystemDns => "Системный DNS",
             Self::CloudflareWorker => "Cloudflare Worker",
+            Self::TelegramTcp => "Telegram CDN TCP",
         }
     }
 }
@@ -68,11 +85,22 @@ pub struct Route {
     pub kind: RouteKind,
     /// TCP port to dial. Always 443 for Telegram and for Cloudflare Workers.
     pub port: u16,
-    /// Wrap the connection in TLS. Always true outside tests.
+    /// TLS for WebSocket routes; false for native obfuscated2 CDN TCP.
     pub secure: bool,
 }
 
 impl Route {
+    fn cdn_tcp() -> Self {
+        Self {
+            connect_host: CDN203_IP.to_owned(),
+            websocket_host: String::new(),
+            path: String::new(),
+            kind: RouteKind::TelegramTcp,
+            port: HTTPS_PORT,
+            secure: false,
+        }
+    }
+
     /// A production route: TLS on 443.
     fn https(connect_host: String, websocket_host: String, path: String, kind: RouteKind) -> Self {
         Self {
@@ -86,6 +114,15 @@ impl Route {
     }
 }
 
+/// Что случилось с доменами Worker'а, которые задал пользователь.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct WorkerDomains {
+    /// Домены, попавшие в список маршрутов.
+    pub accepted: Vec<String>,
+    /// Строки, не похожие на имя хоста, — маршрута из них не вышло.
+    pub rejected: Vec<String>,
+}
+
 #[derive(Clone, Debug)]
 pub struct ConnectedRoute {
     pub route: Route,
@@ -113,6 +150,14 @@ struct HealthState {
 pub struct TransportEngine {
     health: Mutex<HealthState>,
     worker_domains: Mutex<Vec<String>>,
+    /// Сколько раз отдельный маршрут не ответил.
+    ///
+    /// Считается отдельно от `Stats::ws_failures`, который растёт только когда
+    /// упали ВСЕ маршруты. Из-за этого диагностика показывала «сбоев 0», пока
+    /// закреплённый адрес был недоступен и каждое холодное соединение молча
+    /// откатывалось на следующий маршрут, тратя на это до восьми секунд
+    /// (by-sonic/tglock#32).
+    route_failures: AtomicU32,
     #[cfg(test)]
     forced_routes: Mutex<Vec<Route>>,
 }
@@ -142,50 +187,133 @@ impl TransportEngine {
         Self::default()
     }
 
-    pub fn set_worker_domains(&self, domains: &[String]) {
+    /// Задать домены Worker'ов, вернув принятые и отвергнутые по отдельности.
-        let mut normalized = Vec::new();
+    ///
+    /// Отвергнутые возвращаются, потому что раньше они отбрасывались молча:
+    /// вписанный со схемой или слэшем `https://name.workers.dev/` не проходил
+    /// проверку, маршрут не появлялся, и «воркер настроен» ничем не отличалось
+    /// от «воркера нет» (by-sonic/tglock#50).
+    pub fn set_worker_domains(&self, domains: &[String]) -> WorkerDomains {
+        let mut accepted = Vec::new();
+        let mut rejected = Vec::new();
         for domain in domains {
-            let domain = domain.trim().to_ascii_lowercase();
+            let trimmed = domain.trim();
-            if valid_domain(&domain) && !normalized.contains(&domain) {
+            if trimmed.is_empty() {
-                normalized.push(domain);
+                continue;
+            }
+            let normalized = trimmed.to_ascii_lowercase();
+            if !valid_domain(&normalized) {
+                rejected.push(trimmed.to_owned());
+            } else if !accepted.contains(&normalized) {
+                accepted.push(normalized);
             }
         }
-        *self.worker_domains.lock().unwrap() = normalized;
+        *self.worker_domains.lock().unwrap() = accepted.clone();
+        WorkerDomains { accepted, rejected }
     }
 
     pub async fn connect(
         &self,
         dc: u16,
         media: bool,
-    ) -> Result<(TelegramWebSocket, ConnectedRoute), String> {
+    ) -> Result<(TelegramConnection, ConnectedRoute), String> {
         let key = DcKey { dc, media };
-        let candidates = self.ordered_candidates(key);
+        self.race_connections(key, |route| async move { connect_route(&route).await })
+            .await
+    }
+
+    // A slow first IP must not hold every other route hostage. At most three
+    // handshakes run per client, staggered so a healthy preferred route wins
+    // without opening needless fallback sockets. Dropping this future or
+    // returning a winner cancels every losing connection attempt.
+    async fn race_connections<T, F, Fut>(
+        &self,
+        key: DcKey,
+        mut connect: F,
+    ) -> Result<(T, ConnectedRoute), String>
+    where
+        F: FnMut(Route) -> Fut,
+        Fut: std::future::Future<Output = Result<T, String>>,
+    {
+        let mut candidates = self.ordered_candidates(key).into_iter().peekable();
+        let mut pending = FuturesUnordered::new();
+        let mut next_start = Instant::now();
         let mut errors = Vec::new();
 
-        for route in candidates {
+        while candidates.peek().is_some() || !pending.is_empty() {
-            match connect_route(&route).await {
+            if candidates.peek().is_some()
-                Ok(websocket) => {
+                && pending.len() < MAX_CONNECTING
+                && (pending.is_empty() || Instant::now() >= next_start)
+            {
+                let route = candidates.next().unwrap();
+                // Another client may have failed this route since we took our
+                // snapshot. Never knowingly bypass its current cooldown.
+                if !self.route_available(&route) {
+                    continue;
+                }
+                let connection = connect(route.clone());
+                pending.push(async move { (route, connection.await) });
+                next_start = Instant::now() + FALLBACK_DELAY;
+                continue;
+            }
+            tokio::select! {
+                Some((route, result)) = pending.next(), if !pending.is_empty() => {
+                    match result {
+                        Ok(connection) => {
                             self.record_success(key, &route);
-                    return Ok((websocket, ConnectedRoute { route }));
+                            return Ok((connection, ConnectedRoute { route }));
                         }
                         Err(error) => {
                             self.record_failure(&route);
-                    errors.push(format!(
+                            let endpoint = if route.kind == RouteKind::TelegramTcp {
-                        "{} via {}: {}",
+                                format!("{}:{} (MTProto TCP)", route.connect_host, route.port)
-                        route.websocket_host, route.connect_host, error
+                            } else {
-                    ));
+                                format!("{} (TLS {})", route.connect_host, route.websocket_host)
+                            };
+                            errors.push(format!("{endpoint} — {error}"));
                         }
                     }
                 }
+                _ = tokio::time::sleep_until(next_start),
+                    if candidates.peek().is_some() && pending.len() < MAX_CONNECTING => {}
+            }
+        }
 
+        if errors.is_empty() {
+            let routes = self.routes_for_key(key);
+            let health = self.health.lock().unwrap();
+            let retry = routes
+                .iter()
+                .filter_map(|route| health.routes.get(route))
+                .map(|entry| entry.retry_at.saturating_duration_since(Instant::now()))
+                .min();
+            errors.push(match retry {
+                Some(delay) => format!(
+                    "маршруты на паузе после ошибок; повтор через {} с",
+                    delay
+                        .as_secs()
+                        .saturating_add(u64::from(delay.subsec_nanos() != 0))
+                ),
+                None => "для этого дата-центра нет маршрутов".to_owned(),
+            });
+        }
         Err(format!(
-            "all Telegram routes for DC{}{} failed: {}",
+            "Не поднялся туннель до DC{}{}: {}",
-            dc,
+            key.dc,
-            if media { " media" } else { "" },
+            if key.media { " (медиа)" } else { "" },
             errors.join("; ")
         ))
     }
 
+    fn route_available(&self, route: &Route) -> bool {
+        self.health
+            .lock()
+            .unwrap()
+            .routes
+            .get(route)
+            .is_none_or(|health| health.retry_at <= Instant::now())
+    }
+
     fn ordered_candidates(&self, key: DcKey) -> Vec<Route> {
         let now = Instant::now();
         let all_routes = self.routes_for_key(key);
@@ -205,25 +333,18 @@ impl TransportEngine {
         candidates.sort_by_key(|route| {
             let preferred_rank = u8::from(preferred != Some(route));
             let kind_rank = match route.kind {
-                RouteKind::TelegramIp => 0,
+                RouteKind::TelegramTcp => 0,
-                RouteKind::AlternateTelegramIp => 1,
+                RouteKind::TelegramIp if Some(route) == all_routes.first() => 0,
-                RouteKind::SystemDns => 2,
+                // The operator explicitly configured this independent path.
-                RouteKind::CloudflareWorker => 3,
+                // Start it after the primary IP, before more potentially
+                // blocked Telegram addresses consume the concurrency budget.
+                RouteKind::CloudflareWorker => 1,
+                RouteKind::TelegramIp | RouteKind::AlternateTelegramIp => 2,
+                RouteKind::SystemDns => 3,
             };
             (preferred_rank, kind_rank)
         });
 
-        // If every route is cooling down, retry the one that becomes available first.
-        if candidates.is_empty() {
-            if let Some((route, _)) = health
-                .routes
-                .iter()
-                .filter(|(route, _)| all_routes.contains(route))
-                .min_by_key(|(_, route_health)| route_health.retry_at)
-            {
-                candidates.push(route.clone());
-            }
-        }
         candidates
     }
 
@@ -258,8 +379,22 @@ impl TransportEngine {
         health.preferred.insert(key, route.clone());
     }
 
+    /// Сколько отдельных маршрутов не ответило за время работы.
+    pub fn route_failures(&self) -> u32 {
+        self.route_failures.load(Ordering::Relaxed)
+    }
+
+    /// A successful WebSocket upgrade is not proof that its upstream works.
+    /// Call this for upstream failures after the handshake, never merely for
+    /// a client disconnect or a canceled losing connection attempt.
+    pub fn report_route_failure(&self, connected: &ConnectedRoute) {
+        self.record_failure(&connected.route);
+    }
+
     fn record_failure(&self, route: &Route) {
+        self.route_failures.fetch_add(1, Ordering::Relaxed);
         let mut health = self.health.lock().unwrap();
+        health.preferred.retain(|_, preferred| preferred != route);
         let failures = health
             .routes
             .get(route)
@@ -315,12 +450,15 @@ fn telegram_ips(dc: u16) -> &'static [&'static str] {
         3 => &["149.154.175.100"],
         4 => &["149.154.167.91", "149.154.167.220"],
         5 => &["149.154.171.5"],
-        203 => &["91.105.192.100"],
+        203 => &[CDN203_IP],
         _ => &[],
     }
 }
 
 pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
+    if telegram_ips(dc).is_empty() {
+        return Vec::new();
+    }
     let websocket_dc = canonical_dc(dc);
     let primary = format!("kws{}.web.telegram.org", websocket_dc);
     let secondary = format!("kws{}-1.web.telegram.org", websocket_dc);
@@ -331,6 +469,13 @@ pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
     };
     let ips = telegram_ips(dc);
     let mut routes = Vec::new();
+    if dc == 203 {
+        // CDN203 speaks native obfuscated2 on this exact IP:443. A WebSocket
+        // handshake on the same address can time out even while MTProto is
+        // healthy. Keep the destination unchanged and use its native wire
+        // transport; never redirect CDN authorization to ordinary DC2.
+        routes.push(Route::cdn_tcp());
+    }
 
     for websocket_host in &websocket_hosts {
         for (index, ip) in ips.iter().enumerate() {
@@ -345,6 +490,10 @@ pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
                 },
             ));
         }
+        // DC203 uses the DC2 hostname only for TLS/HTTP virtual hosting.
+        // Resolving it would connect to DC2 itself and send CDN sessions to
+        // the wrong data centre. Its fallback must retain the CDN address.
+        if dc != 203 {
             routes.push(Route::https(
                 websocket_host.clone(),
                 websocket_host.clone(),
@@ -352,35 +501,60 @@ pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
                 RouteKind::SystemDns,
             ));
         }
+    }
     routes
 }
 
-/// Select the rustls cryptographic provider.
+async fn connect_route(route: &Route) -> Result<TelegramConnection, String> {
-///
+    connect_route_with_config(route, tls_config()).await
-/// rustls 0.23 refuses to guess when the enabled features do not name exactly
-/// one provider, and the failure is a panic on the first TLS handshake — not a
-/// compile error and not something the offline tests can reach, because they use
-/// a plaintext local route. Installing it at the point of use means both
-/// frontends are covered without a startup hook.
-fn ensure_crypto_provider() {
-    static ONCE: std::sync::Once = std::sync::Once::new();
-    ONCE.call_once(|| {
-        // An error here means a provider is already installed, which is fine.
-        let _ = rustls::crypto::ring::default_provider().install_default();
-    });
 }
 
-async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
+fn client_config(roots: rustls::RootCertStore) -> Arc<rustls::ClientConfig> {
+    Arc::new(
+        rustls::ClientConfig::builder_with_provider(Arc::new(
+            rustls::crypto::ring::default_provider(),
+        ))
+        .with_safe_default_protocol_versions()
+        .expect("ring supports the default TLS protocol versions")
+        .with_root_certificates(roots)
+        .with_no_client_auth(),
+    )
+}
+
+fn tls_config() -> Arc<rustls::ClientConfig> {
+    static CONFIG: OnceLock<Arc<rustls::ClientConfig>> = OnceLock::new();
+    CONFIG
+        .get_or_init(|| {
+            client_config(rustls::RootCertStore::from_iter(
+                webpki_roots::TLS_SERVER_ROOTS.iter().cloned(),
+            ))
+        })
+        .clone()
+}
+
+async fn connect_route_with_config(
+    route: &Route,
+    config: Arc<rustls::ClientConfig>,
+) -> Result<TelegramConnection, String> {
+    // Native TCP is a narrowly scoped CDN route, not a general proxy escape
+    // hatch. Reject malformed raw routes before dialing anything.
+    if route.kind == RouteKind::TelegramTcp && !allowed_tcp_route(route) {
+        return Err("native MTProto TCP разрешён только для закреплённого CDN203".to_owned());
+    }
     let tcp = tokio::time::timeout(
         CONNECT_TIMEOUT,
         TcpStream::connect((route.connect_host.as_str(), route.port)),
     )
     .await
-    .map_err(|_| "TCP connect timeout".to_owned())?
+    .map_err(|_| "не отвечает (таймаут TCP)".to_owned())?
-    .map_err(|error| format!("TCP connect: {}", error))?;
+    .map_err(|error| format!("соединение не открылось: {}", error))?;
     tcp.set_nodelay(true)
         .map_err(|error| format!("TCP_NODELAY: {}", error))?;
 
+    if route.kind == RouteKind::TelegramTcp {
+        return Ok(TelegramConnection::Tcp(tcp));
+    }
+
     let scheme = if route.secure { "wss" } else { "ws" };
     let url = format!("{}://{}{}", scheme, route.websocket_host, route.path);
     let mut request = url
@@ -395,35 +569,45 @@ async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
     );
 
     if !route.secure {
-        // Only reachable from tests, which run a local WebSocket server without
+        // Raw TCP has already returned above. Plain WebSocket is only used by
-        // a certificate. Production routes are always built by `Route::https`.
+        // local fixtures; production WebSocket routes are always HTTPS.
         return tokio::time::timeout(
             CONNECT_TIMEOUT,
             tokio_tungstenite::client_async(request, MaybeTlsStream::Plain(tcp)),
         )
         .await
-        .map_err(|_| "WebSocket timeout".to_owned())?
+        .map_err(|_| "таймаут WebSocket".to_owned())?
-        .map(|(websocket, _)| websocket)
+        .map(|(websocket, _)| TelegramConnection::WebSocket(Box::new(websocket)))
-        .map_err(|error| format!("WebSocket handshake: {}", error));
+        .map_err(|error| format!("рукопожатие WebSocket: {}", error));
     }
 
-    ensure_crypto_provider();
-
     // The URI host remains the real Telegram hostname even when the TCP socket
-    // is opened to a pinned IP, so TLS validates Telegram's certificate and
+    // is opened to a pinned IP. rustls validates that hostname and certificate
-    // sends the correct SNI. Passing no connector makes tokio-tungstenite build
+    // against the bundled roots, and sends that hostname in SNI. The explicit
-    // the default rustls one, with the bundled webpki root store; certificate
+    // ring provider avoids process-global provider selection and its panics.
-    // and hostname verification are never disabled.
+    let connector = tokio_tungstenite::Connector::Rustls(config);
     tokio::time::timeout(
         CONNECT_TIMEOUT,
-        tokio_tungstenite::client_async_tls_with_config(request, tcp, None, None),
+        tokio_tungstenite::client_async_tls_with_config(request, tcp, None, Some(connector)),
     )
     .await
-    .map_err(|_| "TLS/WebSocket timeout".to_owned())?
+    .map_err(|_| "таймаут TLS/WebSocket".to_owned())?
-    .map(|(websocket, _)| websocket)
+    .map(|(websocket, _)| TelegramConnection::WebSocket(Box::new(websocket)))
     .map_err(|error| format!("TLS/WebSocket handshake: {}", error))
 }
 
+fn allowed_tcp_route(route: &Route) -> bool {
+    #[cfg(test)]
+    if route.connect_host == "127.0.0.1" && !route.secure {
+        return true;
+    }
+    route.connect_host == CDN203_IP
+        && route.port == HTTPS_PORT
+        && route.websocket_host.is_empty()
+        && route.path.is_empty()
+        && !route.secure
+}
+
 fn valid_domain(domain: &str) -> bool {
     if domain.is_empty() || domain.len() > 253 || !domain.contains('.') {
         return false;
@@ -451,10 +635,35 @@ mod tests {
     }
 
     #[test]
-    fn dc203_uses_dc2_websocket_and_its_own_ip() {
+    fn dc203_prefers_native_tcp_and_never_changes_the_cdn_destination() {
         let routes = routes_for_dc(203, false);
-        assert_eq!(routes[0].websocket_host, "kws2.web.telegram.org");
+        assert_eq!(routes[0].kind, RouteKind::TelegramTcp);
+        assert!(routes[0].websocket_host.is_empty());
+        assert!(!routes[0].secure);
         assert_eq!(routes[0].connect_host, "91.105.192.100");
+        assert_eq!(routes[1].websocket_host, "kws2.web.telegram.org");
+        assert!(routes
+            .iter()
+            .all(|route| route.connect_host == "91.105.192.100"));
+        assert!(!routes
+            .iter()
+            .any(|route| route.kind == RouteKind::SystemDns));
+        let engine = TransportEngine::new();
+        engine.set_worker_domains(&["cdn.workers.dev".to_owned()]);
+        let routes = engine.routes_for_key(DcKey {
+            dc: 203,
+            media: true,
+        });
+        let ordered = engine.ordered_candidates(DcKey {
+            dc: 203,
+            media: true,
+        });
+        assert_eq!(ordered[0].kind, RouteKind::TelegramTcp);
+        assert_eq!(ordered[1].kind, RouteKind::CloudflareWorker);
+        assert!(routes
+            .iter()
+            .filter(|route| route.kind == RouteKind::CloudflareWorker)
+            .all(|route| route.path == "/apiws?dst=91.105.192.100&dc=203"));
     }
 
     #[test]
@@ -505,7 +714,7 @@ mod tests {
     }
 
     #[test]
-    fn every_production_route_is_tls_on_443() {
+    fn production_websockets_use_tls_and_native_tcp_is_restricted_to_cdn203() {
         let engine = TransportEngine::new();
         engine.set_worker_domains(&["fallback.workers.dev".to_owned()]);
         for dc in [1, 2, 3, 4, 5, 203] {
@@ -514,15 +723,21 @@ mod tests {
                 assert!(!routes.is_empty(), "DC{dc} must have at least one route");
                 for route in routes {
                     assert_eq!(route.port, 443, "{route:?}");
+                    if route.kind == RouteKind::TelegramTcp {
+                        assert_eq!(dc, 203);
+                        assert_eq!(route.connect_host, CDN203_IP);
+                        assert!(allowed_tcp_route(&route));
+                    } else {
                         assert!(route.secure, "{route:?}");
                     }
                 }
             }
         }
+    }
 
     #[test]
     fn every_data_center_offers_a_pinned_ip_and_a_dns_route() {
-        for dc in [1, 2, 3, 4, 5, 203] {
+        for dc in [1, 2, 3, 4, 5] {
             let routes = routes_for_dc(dc, false);
             assert!(
                 routes
@@ -586,7 +801,7 @@ mod tests {
     }
 
     #[test]
-    fn all_routes_cooling_down_still_yields_the_soonest_retry() {
+    fn all_routes_cooling_down_do_not_bypass_the_backoff() {
         let engine = TransportEngine::new();
         let key = DcKey {
             dc: 5,
@@ -602,19 +817,13 @@ mod tests {
             engine.record_failure(route);
         }
 
-        let candidates = engine.ordered_candidates(key);
+        assert!(engine.ordered_candidates(key).is_empty());
-        assert_eq!(
-            candidates.len(),
-            1,
-            "a fully cooling table must offer exactly one retry, not give up"
-        );
-        assert_eq!(candidates[0], routes[0]);
     }
 
     #[test]
     fn worker_domains_are_rejected_unless_they_are_plain_hostnames() {
         let engine = TransportEngine::new();
-        engine.set_worker_domains(&[
+        let result = engine.set_worker_domains(&[
             "https://scheme.workers.dev".to_owned(),
             "with.a/path".to_owned(),
             "no-dot".to_owned(),
@@ -635,6 +844,17 @@ mod tests {
             .filter(|route| route.kind == RouteKind::CloudflareWorker)
             .collect();
         assert_eq!(workers.len(), 1, "only the valid hostname may survive");
+        assert_eq!(result.accepted, vec!["good.workers.dev".to_owned()]);
+        assert!(
+            result.rejected.contains(&"https://scheme.workers.dev".to_owned()),
+            "отвергнутая строка обязана вернуться названной, иначе о ней некому              сообщить: {:?}",
+            result.rejected
+        );
+        assert!(
+            !result.rejected.iter().any(String::is_empty),
+            "пустая строка — не то, о чём стоит предупреждать: {:?}",
+            result.rejected
+        );
         assert_eq!(workers[0].websocket_host, "good.workers.dev");
     }
 
@@ -658,7 +878,7 @@ mod tests {
     }
 
     #[test]
-    fn worker_is_the_last_resort() {
+    fn explicit_worker_is_tried_before_redundant_telegram_fallbacks() {
         let engine = TransportEngine::new();
         engine.set_worker_domains(&["fallback.workers.dev".to_owned()]);
         let key = DcKey {
@@ -666,22 +886,52 @@ mod tests {
             media: false,
         };
         let candidates = engine.ordered_candidates(key);
-        assert_eq!(
+        assert_eq!(candidates[0].kind, RouteKind::TelegramIp);
-            candidates.last().unwrap().kind,
+        assert_eq!(candidates[1].kind, RouteKind::CloudflareWorker);
-            RouteKind::CloudflareWorker,
+        let worker = candidates
-            "third-party infrastructure must never be tried before Telegram itself"
+            .iter()
+            .position(|route| route.kind == RouteKind::CloudflareWorker)
+            .unwrap();
+        let dns = candidates
+            .iter()
+            .position(|route| route.kind == RouteKind::SystemDns)
+            .unwrap();
+        assert!(
+            worker < dns,
+            "an explicitly configured independent path must not wait for every blocked IP"
         );
     }
 
     #[test]
-    fn a_crypto_provider_is_available_for_tls() {
+    fn every_route_failure_is_counted() {
-        // Guards against the failure that compiles cleanly and passes every
+        // Диагностика показывала «сбоев 0», пока закреплённый адрес был мёртв и
-        // offline test, then panics on the first real connection to Telegram.
+        // соединения молча откатывались на запасной. Счётчик маршрутов должен
-        ensure_crypto_provider();
+        // видеть каждое такое падение.
-        assert!(
+        let engine = TransportEngine::new();
-            rustls::crypto::CryptoProvider::get_default().is_some(),
+        let routes = routes_for_dc(2, false);
-            "without an installed provider every TLS handshake panics"
+        assert_eq!(engine.route_failures(), 0);
+
+        engine.record_failure(&routes[0]);
+        assert_eq!(engine.route_failures(), 1);
+
+        engine.record_failure(&routes[0]);
+        engine.record_failure(&routes[1]);
+        assert_eq!(
+            engine.route_failures(),
+            3,
+            "считаются все падения, включая повторные по тому же маршруту"
         );
+
+        // Успех не обнуляет историю: она нужна, чтобы понять, что маршруты
+        // перебирались, даже когда в итоге всё соединилось.
+        engine.record_success(
+            DcKey {
+                dc: 2,
+                media: false,
+            },
+            &routes[1],
+        );
+        assert_eq!(engine.route_failures(), 3);
     }
 
     #[test]
@@ -724,6 +974,7 @@ mod tests {
             RouteKind::AlternateTelegramIp,
             RouteKind::SystemDns,
             RouteKind::CloudflareWorker,
+            RouteKind::TelegramTcp,
         ] {
             assert_eq!(RouteKind::from_ui_code(kind.ui_code()), Some(kind));
             assert_eq!(route_label(kind.ui_code()), kind.label());
@@ -739,19 +990,310 @@ mod tests {
             RouteKind::AlternateTelegramIp,
             RouteKind::SystemDns,
             RouteKind::CloudflareWorker,
+            RouteKind::TelegramTcp,
         ] {
             assert_ne!(route_label(0), kind.label());
         }
     }
 
+    fn local_routes(count: usize) -> Vec<Route> {
+        (0..count)
+            .map(|index| Route {
+                connect_host: "127.0.0.1".to_owned(),
+                websocket_host: "localhost".to_owned(),
+                path: format!("/{index}"),
+                kind: RouteKind::TelegramIp,
+                port: 443,
+                secure: false,
+            })
+            .collect()
+    }
+
+    struct ActiveAttempt(Arc<std::sync::atomic::AtomicUsize>);
+
+    impl Drop for ActiveAttempt {
+        fn drop(&mut self) {
+            self.0.fetch_sub(1, Ordering::SeqCst);
+        }
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn a_hanging_first_route_does_not_delay_a_working_fallback() {
+        let engine = TransportEngine::new();
+        *engine.forced_routes.lock().unwrap() = local_routes(3);
+        let active = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let started = Instant::now();
+        let (_, winner) = engine
+            .race_connections(
+                DcKey {
+                    dc: 2,
+                    media: false,
+                },
+                |route| {
+                    let active = active.clone();
+                    async move {
+                        active.fetch_add(1, Ordering::SeqCst);
+                        let _active = ActiveAttempt(active);
+                        if route.path == "/1" {
+                            tokio::time::sleep(Duration::from_millis(1)).await;
+                            Ok(())
+                        } else {
+                            std::future::pending::<Result<(), String>>().await
+                        }
+                    }
+                },
+            )
+            .await
+            .unwrap();
+        assert_eq!(winner.route.path, "/1");
+        assert_eq!(started.elapsed(), FALLBACK_DELAY + Duration::from_millis(1));
+        assert_eq!(
+            active.load(Ordering::SeqCst),
+            0,
+            "losing attempts must be canceled"
+        );
+        assert_eq!(
+            engine.route_failures(),
+            0,
+            "cancellation is not a route failure"
+        );
+    }
+
+    #[tokio::test(start_paused = true)]
+    async fn connection_races_are_bounded_and_cooldown_prevents_redialing() {
+        let engine = TransportEngine::new();
+        *engine.forced_routes.lock().unwrap() = local_routes(8);
+        let active = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let peak = Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        let error = engine
+            .race_connections(key, |_| {
+                let active = active.clone();
+                let peak = peak.clone();
+                async move {
+                    let current = active.fetch_add(1, Ordering::SeqCst) + 1;
+                    peak.fetch_max(current, Ordering::SeqCst);
+                    let _active = ActiveAttempt(active);
+                    tokio::time::sleep(Duration::from_secs(1)).await;
+                    Err::<(), _>("test handshake failure".to_owned())
+                }
+            })
+            .await
+            .unwrap_err();
+        assert!(error.contains("test handshake failure"));
+        assert_eq!(peak.load(Ordering::SeqCst), MAX_CONNECTING);
+        assert_eq!(engine.route_failures(), 8);
+        let error = engine
+            .race_connections(key, |_| {
+                panic!("a route in cooldown must never be dialed");
+                #[allow(unreachable_code)]
+                std::future::ready(Ok::<(), String>(()))
+            })
+            .await
+            .unwrap_err();
+        assert!(error.contains("повтор через"));
+        assert_eq!(engine.route_failures(), 8);
+        tokio::time::advance(FAILURE_BACKOFF_INITIAL).await;
+        assert_eq!(engine.ordered_candidates(key).len(), 8);
+    }
+
+    #[test]
+    fn an_upstream_failure_removes_preference_and_starts_cooldown() {
+        let engine = TransportEngine::new();
+        let key = DcKey {
+            dc: 2,
+            media: false,
+        };
+        let route = routes_for_dc(2, false)[0].clone();
+        engine.record_success(key, &route);
+        engine.report_route_failure(&ConnectedRoute {
+            route: route.clone(),
+        });
+        assert!(!engine.ordered_candidates(key).contains(&route));
+        assert!(!engine.health.lock().unwrap().preferred.contains_key(&key));
+        assert_eq!(engine.route_failures(), 1);
+    }
+
+    #[tokio::test]
+    async fn unsupported_dc_reports_missing_routes_without_dialing() {
+        let error = TransportEngine::new()
+            .connect(999, false)
+            .await
+            .unwrap_err();
+        assert!(error.contains("нет маршрутов"));
+    }
+
+    async fn local_tls_route(
+        hostname: &str,
+    ) -> (
+        Route,
+        Arc<rustls::ClientConfig>,
+        tokio::task::JoinHandle<Option<String>>,
+    ) {
+        let certificate = rcgen::generate_simple_self_signed(vec!["localhost".to_owned()]).unwrap();
+        let key = rustls::pki_types::PrivatePkcs8KeyDer::from(certificate.key_pair.serialize_der());
+        let cert = certificate.cert.der().clone();
+        let mut roots = rustls::RootCertStore::empty();
+        roots.add(cert.clone()).unwrap();
+        let server = rustls::ServerConfig::builder_with_provider(Arc::new(
+            rustls::crypto::ring::default_provider(),
+        ))
+        .with_safe_default_protocol_versions()
+        .unwrap()
+        .with_no_client_auth()
+        .with_single_cert(vec![cert], key.into())
+        .unwrap();
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let port = listener.local_addr().unwrap().port();
+        let task = tokio::spawn(async move {
+            let (socket, _) = listener.accept().await.unwrap();
+            let acceptor = tokio_rustls::TlsAcceptor::from(Arc::new(server));
+            let Ok(tls) = acceptor.accept(socket).await else {
+                return None;
+            };
+            let name = tls.get_ref().1.server_name().map(str::to_owned);
+            #[allow(clippy::result_large_err)]
+            let negotiate = |_: &tokio_tungstenite::tungstenite::handshake::server::Request,
+                             mut response: tokio_tungstenite::tungstenite::handshake::server::Response| {
+                response.headers_mut().insert("Sec-WebSocket-Protocol", "binary".parse().unwrap());
+                Ok(response)
+            };
+            let _ = tokio_tungstenite::accept_hdr_async(tls, negotiate).await;
+            name
+        });
+        (
+            Route {
+                connect_host: "127.0.0.1".to_owned(),
+                websocket_host: hostname.to_owned(),
+                path: "/apiws".to_owned(),
+                kind: RouteKind::TelegramIp,
+                port,
+                secure: true,
+            },
+            client_config(roots),
+            task,
+        )
+    }
+
+    #[tokio::test]
+    async fn pinned_ip_tls_uses_uri_hostname_for_sni_and_certificate_validation() {
+        let (route, config, server) = local_tls_route("localhost").await;
+        connect_route_with_config(&route, config).await.unwrap();
+        assert_eq!(server.await.unwrap().as_deref(), Some("localhost"));
+    }
+
+    #[tokio::test]
+    async fn tls_rejects_a_trusted_certificate_for_a_different_hostname() {
+        let (route, config, server) = local_tls_route("wrong.example").await;
+        let error = connect_route_with_config(&route, config).await.unwrap_err();
+        assert!(error.contains("TLS/WebSocket handshake"), "{error}");
+        assert!(server.await.unwrap().is_none());
+    }
+
+    #[tokio::test]
+    async fn production_roots_reject_an_untrusted_certificate() {
+        let (route, _, server) = local_tls_route("localhost").await;
+        let error = connect_route(&route).await.unwrap_err();
+        assert!(error.contains("TLS/WebSocket handshake"), "{error}");
+        assert!(server.await.unwrap().is_none());
+        assert!(
+            Arc::ptr_eq(&tls_config(), &tls_config()),
+            "reuse the TLS configuration"
+        );
+    }
+
+    #[tokio::test]
+    async fn native_tcp_connects_without_sending_a_tls_or_websocket_handshake() {
+        use tokio::io::{AsyncReadExt, AsyncWriteExt};
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let engine = TransportEngine::new();
+        engine.force_local_route_with(
+            listener.local_addr().unwrap().port(),
+            RouteKind::TelegramTcp,
+            String::new(),
+        );
+        let server = tokio::spawn(async move {
+            let (mut socket, _) = listener.accept().await.unwrap();
+            let mut bytes = [0; 4];
+            socket.read_exact(&mut bytes).await.unwrap();
+            assert_eq!(
+                &bytes, b"init",
+                "first bytes must be native transport bytes"
+            );
+            socket.write_all(b"pong").await.unwrap();
+        });
+        let (connection, connected) =
+            tokio::time::timeout(Duration::from_secs(1), engine.connect(203, true))
+                .await
+                .unwrap()
+                .unwrap();
+        assert_eq!(connected.route.kind, RouteKind::TelegramTcp);
+        let TelegramConnection::Tcp(mut socket) = connection else {
+            panic!("native CDN route must return a TCP stream");
+        };
+        assert!(socket.nodelay().unwrap());
+        socket.write_all(b"init").await.unwrap();
+        let mut reply = [0; 4];
+        tokio::time::timeout(Duration::from_secs(1), socket.read_exact(&mut reply))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(&reply, b"pong");
+        server.await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn raw_tcp_failure_is_named_and_enters_cooldown() {
+        let engine = TransportEngine::new();
+        // Port zero cannot accept a TCP connection; no external traffic.
+        engine.force_local_route_with(0, RouteKind::TelegramTcp, String::new());
+        let error = engine.connect(203, false).await.unwrap_err();
+        assert!(error.contains("MTProto TCP"), "{error}");
+        assert!(
+            !error.contains("TLS"),
+            "native transport must not be called TLS"
+        );
+        assert_eq!(engine.route_failures(), 1);
+        assert!(engine
+            .ordered_candidates(DcKey {
+                dc: 203,
+                media: false
+            })
+            .is_empty());
+    }
+
+    #[tokio::test]
+    async fn raw_tcp_guard_rejects_a_different_destination_before_dialing() {
+        let mut route = Route::cdn_tcp();
+        route.connect_host = "127.0.0.2".to_owned();
+        let error = connect_route(&route).await.unwrap_err();
+        assert!(error.contains("только для закреплённого CDN203"), "{error}");
+        for dc in [1, 2, 3, 4, 5, 999] {
+            assert!(routes_for_dc(dc, false)
+                .iter()
+                .all(|route| route.kind != RouteKind::TelegramTcp));
+        }
+    }
+
     #[tokio::test]
     #[ignore = "requires live Telegram network access"]
     async fn connects_to_all_production_data_centers() {
         let engine = TransportEngine::new();
         for dc in [1, 2, 3, 4, 5, 203] {
-            let (mut websocket, connected) = engine.connect(dc, false).await.unwrap();
+            let (connection, connected) = engine.connect(dc, false).await.unwrap();
-            assert!(!connected.route.websocket_host.is_empty());
+            assert!(!connected.route.connect_host.is_empty());
-            websocket.close(None).await.unwrap();
+            match connection {
+                TelegramConnection::WebSocket(mut websocket) => {
+                    websocket.close(None).await.unwrap()
+                }
+                TelegramConnection::Tcp(mut socket) => {
+                    use tokio::io::AsyncWriteExt;
+                    socket.shutdown().await.unwrap();
+                }
+            }
         }
     }
 }

tauri.android.conf.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "app": {
+    "windows": [{ "label": "main", "title": "TGLock", "backgroundColor": "#070A10" }]
+  },
+  "bundle": { "android": { "minSdkVersion": 24 } }
+}

tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "TGLock",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.0-beta.15",
   "identifier": "com.bysonic.tglock",
   "mainBinaryName": "tglock",
   "build": {

tglock.example.toml

@@ -0,0 +1,42 @@
+# Настройки tglock-cli.
+#
+# Положите этот файл рядом с бинарём под именем tglock.toml — он подхватится
+# сам. Либо укажите путь явно: tglock-cli --config /etc/tglock.toml
+#
+# Все поля необязательны. Флаги командной строки перекрывают то, что здесь.
+
+# Адрес и порт локального прокси.
+# По умолчанию 127.0.0.1:1080 — доступ только с этого компьютера.
+# bind = "127.0.0.1"
+# port = 1080
+
+# Слушать 0.0.0.0, чтобы подключались другие устройства в сети.
+# Нельзя задавать одновременно с bind.
+# lan = true
+
+# Секрет прокси — вторая половина ссылки tg://proxy.
+#
+# Для сервиса его нужно закрепить, иначе после перезапуска секрет будет новым и
+# все настроенные клиенты перестанут подключаться. Достаточно один раз
+# запустить tglock-cli, скопировать секрет из напечатанной ссылки и вписать
+# сюда. Принимается и с префиксом dd, и без него.
+#
+# Файл с секретом внутри держите с правами 600: это доступ к вашему прокси.
+# secret = "dd00112233445566778899aabbccddeeff"
+
+# Либо хранить секрет в отдельном файле — он создастся при первом запуске.
+# Игнорируется, если задан secret выше.
+# secret_file = "secret"
+
+# Свои Cloudflare Worker'ы как резервный маршрут — на случай, когда у
+# провайдера легли все обычные маршруты. Установка описана в
+# docs/CLOUDFLARE_WORKER.md
+# worker = ["my-name.workers.dev"]
+
+# Пропускать и не-Telegram адреса.
+# На loopback это включено само. На сетевом адресе означает открытый
+# SOCKS5-прокси для всего интернета — включайте осознанно.
+# allow_direct = false
+
+# Печатать только ошибки.
+# quiet = false

ui/main.ts

@@ -10,8 +10,17 @@ type Status = {
   dataCenter: number | null;
   route: string;
   failures: number;
+  routeFailures: number;
+  /// Отклонено политикой «в LAN-режиме только Telegram».
+  blocked: number;
+  /// Клиенты, которые дошли, но не сумели договориться о рукопожатии.
+  unknownClients: number;
+  /// Соединения, которые открылись и ничего не прислали до таймаута.
+  silentClients: number;
   uptimeSeconds: number;
   port: number;
+  /// Адрес для других устройств. Приходит только в LAN-режиме.
+  shareAddress: string | null;
   logs: LogLine[];
 };
 
@@ -37,13 +46,20 @@ let status: Status = {
   dataCenter: null,
   route: "Маршрут ещё не выбран",
   failures: 0,
+  routeFailures: 0,
+  blocked: 0,
+  unknownClients: 0,
+  silentClients: 0,
   uptimeSeconds: 0,
   port: 1080,
+  shareAddress: null,
   logs: [],
 };
 let settings: Settings = { lanMode: false, port: 1080, workerDomain: "" };
 let busy = false;
 let toastTimer: number | undefined;
+let toastMessage = "";
+let toastError = false;
 
 const icons = {
   arrowLeft: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="m15 18-6-6 6-6"/></svg>`,
@@ -101,7 +117,7 @@ function shell(content: string, pageClass = ""): string {
     <main class="app-shell ${pageClass}">
       <div class="drag-region" data-tauri-drag-region></div>
       ${content}
-      <div id="toast" class="toast" role="status"></div>
+      <div id="toast" class="toast${toastMessage ? " visible" : ""}${toastError ? " error" : ""}" role="status">${escapeHtml(toastMessage)}</div>
     </main>
   `;
 }
@@ -138,6 +154,11 @@ function renderHome(): void {
         <span class="button-arrow">→</span>
       </button>
 
+      ${status.running ? `<div class="connection-actions">
+        <button id="open-telegram" class="nav-button">Открыть Telegram</button>
+        <button id="copy-link" class="nav-button">Скопировать ссылку</button>
+      </div>` : ""}
+
       <div class="route-pill">
         <span class="route-pulse"></span>
         <span>${escapeHtml(status.route)}</span>
@@ -145,6 +166,18 @@ function renderHome(): void {
         <span>порт ${status.port}</span>
       </div>
 
+      ${status.shareAddress ? `
+      <div class="share-card">
+        <div class="share-label">Адрес для других устройств</div>
+        <button id="copy-address" class="share-address" title="Нажмите, чтобы скопировать">
+          ${escapeHtml(status.shareAddress)}
+        </button>
+        <div class="share-hint">
+          Впишите его в Telegram на телефоне. Не <code>127.0.0.1</code> — на другом
+          устройстве это означает само устройство.
+        </div>
+      </div>` : ""}
+
       <nav class="bottom-nav" aria-label="Разделы">
         <button id="settings-nav" class="nav-button">
           <span class="nav-icon">${icons.settings}</span>
@@ -160,6 +193,9 @@ function renderHome(): void {
   `, "home-page");
 
   document.querySelector("#power")?.addEventListener("click", toggleProtection);
+  document.querySelector("#open-telegram")?.addEventListener("click", openTelegram);
+  document.querySelector("#copy-link")?.addEventListener("click", copyTelegramLink);
+  document.querySelector("#copy-address")?.addEventListener("click", copyShareAddress);
   document.querySelector("#settings-nav")?.addEventListener("click", () => navigate("settings"));
   document.querySelector("#diagnostics-nav")?.addEventListener("click", () => navigate("diagnostics"));
 }
@@ -261,8 +297,46 @@ function renderDiagnostics(): void {
           <span>Время работы</span>
           <strong class="time">${formatUptime(status.uptimeSeconds)}</strong>
         </article>
+        <article class="metric-card">
+          <span>Падений маршрутов</span>
+          <strong>${status.routeFailures}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Отклонено</span>
+          <strong>${status.blocked}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Не опознаны</span>
+          <strong>${status.unknownClients}</strong>
+        </article>
+        <article class="metric-card">
+          <span>Промолчали</span>
+          <strong>${status.silentClients}</strong>
+        </article>
       </div>
 
+      <p class="field-hint">
+        «Падений маршрутов» больше нуля при работающем Telegram — это норма:
+        значит закреплённый адрес недоступен и подключение идёт через запасной.
+        Число в багрепорте помогает понять, что именно перебиралось.
+      </p>
+
+      <p class="field-hint">
+        «Отклонено» — запросы, которые LAN-режим не пропустил: он ходит только
+        по адресам Telegram. Если с телефона ничего не работает, а здесь ноль и
+        соединений тоже ноль, значит телефон до этого компьютера не дошёл —
+        дело в сети или брандмауэре. Какие именно адреса отклонены, видно ниже.
+      </p>
+
+      <p class="field-hint">
+        «Не опознаны» — клиенты, которые дошли до прокси, но договориться с ними
+        не удалось. Почти всегда это старая ссылка: секрет в Telegram остался от
+        прошлого запуска и больше не совпадает. Тогда Telegram пишет «прокси
+        настроен неверно», а адрес такого клиента появится в журнале ниже.
+      </p>
+
+      <button id="copy-diagnostics" class="save-button">Скопировать диагностику</button>
+
       <div class="log-panel">
         <div class="log-heading">
           <span>Последние события</span>
@@ -285,6 +359,7 @@ function renderDiagnostics(): void {
     </section>
   `, "subpage-shell");
 
+  document.querySelector("#copy-diagnostics")?.addEventListener("click", copyDiagnostics);
   document.querySelector("#back")?.addEventListener("click", () => navigate("home"));
 }
 
@@ -356,14 +431,71 @@ async function saveSettings(event: Event): Promise<void> {
   }
 }
 
+async function openTelegram(): Promise<void> {
+  try { await invoke("open_telegram"); }
+  catch (error) { showToast(String(error), true); }
+}
+
+async function copyTelegramLink(): Promise<void> {
+  try {
+    const link = await invoke<string>("get_telegram_link");
+    await navigator.clipboard.writeText(link);
+    showToast("Ссылка скопирована; она содержит секрет прокси");
+  } catch (error) {
+    showToast(`Не удалось скопировать ссылку: ${String(error)}`, true);
+  }
+}
+
+async function copyDiagnostics(): Promise<void> {
+  try {
+    // Public reports exclude proxy links, worker domains and free-form logs.
+    const report = {
+      application: "TGLock",
+      version: "2.0.0-beta.15",
+      running: status.running,
+      activeConnections: status.activeConnections,
+      tunnels: status.tunnels,
+      dataCenter: status.dataCenter,
+      route: status.route,
+      failures: status.failures,
+      routeFailures: status.routeFailures,
+      blocked: status.blocked,
+      unknownClients: status.unknownClients,
+      silentClients: status.silentClients,
+      uptimeSeconds: status.uptimeSeconds,
+      port: status.port,
+      lanMode: settings.lanMode,
+    };
+    await navigator.clipboard.writeText(JSON.stringify(report, null, 2));
+    showToast("Диагностика скопирована без адресов и секретов");
+  } catch { showToast("Буфер обмена недоступен", true); }
+}
+
+async function copyShareAddress(): Promise<void> {
+  const address = status.shareAddress;
+  if (!address) return;
+  try {
+    await navigator.clipboard.writeText(address);
+    showToast("Адрес скопирован");
+  } catch {
+    // Буфер обмена может быть недоступен — адрес и так виден на экране.
+    showToast("Скопируйте адрес вручную", true);
+  }
+}
+
 function showToast(message: string, error = false): void {
   window.clearTimeout(toastTimer);
+  toastMessage = message.replace(/^["']|["']$/g, "");
+  toastError = error;
   window.requestAnimationFrame(() => {
     const toast = document.querySelector<HTMLDivElement>("#toast");
     if (!toast) return;
     toast.textContent = message.replace(/^["']|["']$/g, "");
     toast.className = `toast visible${error ? " error" : ""}`;
-    toastTimer = window.setTimeout(() => toast.classList.remove("visible"), 2800);
+    toastTimer = window.setTimeout(() => {
+      toastMessage = "";
+      document.querySelector("#toast")?.classList.remove("visible");
+    }, 4500);
   });
 }
 

ui/styles.css

@@ -847,3 +847,71 @@ input:disabled {
       0 19px 52px rgba(9, 182, 133, 0.4);
   }
 }
+
+/* Адрес для подключения других устройств. Показывается только в LAN-режиме:
+   люди искали его в интерфейсе, не находили и вписывали 127.0.0.1, который на
+   телефоне означает сам телефон (by-sonic/tglock#36). */
+.share-card {
+  margin-top: 14px;
+  padding: 14px 16px;
+  border-radius: 14px;
+  background: rgba(42, 171, 238, 0.08);
+  border: 1px solid rgba(42, 171, 238, 0.24);
+  text-align: center;
+}
+
+.share-label {
+  font-size: 12px;
+  letter-spacing: 0.02em;
+  color: var(--text-muted, #8b949e);
+}
+
+.share-address {
+  display: block;
+  width: 100%;
+  margin: 6px 0 8px;
+  padding: 6px 8px;
+  border: 0;
+  border-radius: 10px;
+  background: transparent;
+  color: var(--accent, #2aabee);
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 20px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: background 150ms ease;
+}
+
+.share-address:hover,
+.share-address:focus-visible {
+  background: rgba(42, 171, 238, 0.14);
+}
+
+.share-hint {
+  font-size: 11px;
+  line-height: 1.45;
+  color: var(--text-muted, #8b949e);
+}
+
+.share-hint code {
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 11px;
+}
+
+/* Keep actions reachable with mobile safe areas and accessibility text scaling. */
+.app-shell { overflow-y: auto; }
+.home, .subpage { height: auto; min-height: 100%; }
+.connection-actions {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  gap: 8px;
+  margin-top: 12px;
+}
+.connection-actions .nav-button { min-height: 44px; padding: 8px 12px; }
+@media (max-width: 500px) {
+  .home { padding: max(32px, env(safe-area-inset-top)) 20px max(24px, env(safe-area-inset-bottom)); }
+  .subpage { padding-left: 20px; padding-right: 20px; padding-top: max(28px, env(safe-area-inset-top)); }
+  .drag-region { display: none; }
+  .share-address { overflow-wrap: anywhere; }
+}

worker/tglock-worker.js

@@ -28,9 +28,14 @@ const ALLOWED_DESTINATIONS = new Set([
 ]);
 
 const TELEGRAM_PORT = 443;
+const CONNECT_TIMEOUT_MS = 3000;
+// WebSocket events cannot be paused. Bound the outstanding writes instead of
+// retaining an unlimited chain of promises when Telegram stops reading.
+const MAX_PENDING_BYTES = 1024 * 1024;
+const MAX_PENDING_MESSAGES = 256;
 
 export default {
-  async fetch(request, env) {
+  async fetch(request, env = {}) {
     const url = new URL(request.url);
 
     if (url.pathname !== "/apiws") {
@@ -50,33 +55,95 @@ export default {
       return new Response("destination not allowed", { status: 403 });
     }
 
+    if (!request.headers.get("Sec-WebSocket-Protocol")?.split(",").some((p) => p.trim() === "binary")) {
+      return new Response("binary websocket subprotocol required", { status: 400 });
+    }
+
+    let upstream;
+    let timer;
+    let timedOut = false;
+    try {
+      upstream = connect({ hostname: destination, port: TELEGRAM_PORT });
+      // Both promises can reject on connect failure; observe closed immediately.
+      upstream.closed.catch(() => {});
+      await Promise.race([
+        upstream.opened,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            timedOut = true;
+            reject(new Error("connect timeout"));
+          }, CONNECT_TIMEOUT_MS);
+        }),
+      ]);
+    } catch {
+      if (upstream) await upstream.close().catch(() => {});
+      return new Response(timedOut ? "Telegram TCP connect timeout" : "Telegram TCP connect failed", {
+        status: timedOut ? 504 : 502,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+
     const [client, server] = Object.values(new WebSocketPair());
     server.accept();
 
-    const upstream = connect({ hostname: destination, port: TELEGRAM_PORT });
     const writer = upstream.writable.getWriter();
     let closed = false;
 
-    const shutdown = () => {
+    const shutdown = (code = 1000, reason = "") => {
       if (closed) return;
       closed = true;
-      writer.close().catch(() => {});
+      // close() cancels both directions, including a blocked write/read.
+      upstream.close().catch(() => {});
       try {
-        server.close();
+        server.close(code, reason);
       } catch {
         // соединение уже закрыто
       }
     };
 
+    // Запись сериализуется: следующий чанк уходит только после того, как
+    // записан предыдущий, и только когда писатель к этому готов.
+    //
+    // Раньше `write()` вызывался поверх незавершённого, а `writer.ready` не
+    // спрашивался вовсе — backpressure не применялся. Пока в клиенте отправка
+    // голодала, поверх воркера настоящего потока вверх не бывало и это не
+    // проявлялось. Как только голодание починили, в воркер пошёл настоящий
+    // поток (by-sonic/tglock#42).
+    let pending = Promise.resolve();
+    let pendingBytes = 0;
+    let pendingMessages = 0;
+
     server.addEventListener("message", (event) => {
-      const chunk =
+      if (closed) return;
-        event.data instanceof ArrayBuffer
+      if (!(event.data instanceof ArrayBuffer) && !ArrayBuffer.isView(event.data)) {
+        shutdown(1003, "binary messages required");
+        return;
+      }
+      const chunk = event.data instanceof ArrayBuffer
         ? new Uint8Array(event.data)
-          : event.data;
+        : new Uint8Array(event.data.buffer, event.data.byteOffset, event.data.byteLength);
-      writer.write(chunk).catch(shutdown);
+      if (pendingBytes + chunk.byteLength > MAX_PENDING_BYTES || pendingMessages >= MAX_PENDING_MESSAGES) {
+        shutdown(1009, "Telegram write queue full");
+        return;
+      }
+      pendingBytes += chunk.byteLength;
+      pendingMessages += 1;
+      pending = pending
+        .then(async () => {
+          if (closed) return;
+          await writer.ready;
+          if (!closed) await writer.write(chunk);
+        })
+        .catch(() => shutdown(1011, "Telegram write failed"))
+        .finally(() => {
+          pendingBytes -= chunk.byteLength;
+          pendingMessages -= 1;
         });
-    server.addEventListener("close", shutdown);
+    });
-    server.addEventListener("error", shutdown);
+    server.addEventListener("close", () => shutdown());
+    server.addEventListener("error", () => shutdown(1011, "WebSocket failed"));
+    upstream.closed.catch(() => shutdown(1011, "Telegram socket failed"));
 
     // Обратное направление: всё, что приходит от Telegram, уходит клиенту.
     (async () => {
@@ -88,7 +155,9 @@ export default {
           server.send(value);
         }
       } catch {
-        // разрыв соединения — обычная ситуация, не ошибка
+        shutdown(1011, "Telegram read failed");
+      } finally {
+        reader.releaseLock();
       }
       shutdown();
     })();

worker/tglock-worker.test.js

@@ -0,0 +1,196 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import test from "node:test";
+import vm from "node:vm";
+
+const source = await readFile(new URL("./tglock-worker.js", import.meta.url), "utf8");
+const tick = () => new Promise((resolve) => setImmediate(resolve));
+function deferred() {
+  let resolve, reject;
+  const promise = new Promise((a, b) => { resolve = a; reject = b; });
+  return { promise, resolve, reject };
+}
+
+// Execute the actual standalone deployment file, replacing only Cloudflare's
+// platform primitives. No test-only implementation of the relay is used.
+async function fixture({ opened = Promise.resolve(), write, timeout = false } = {}) {
+  let readController;
+  const readable = new ReadableStream({ start(controller) { readController = controller; } });
+  const reads = { reject(error) { readController.error(error); } };
+  const closed = deferred();
+  const writes = [];
+  const events = new Map();
+  const state = { connects: 0, accepted: false, socketCloses: 0, sent: [], closes: [] };
+  const server = {
+    accept() { state.accepted = true; },
+    addEventListener(name, callback) { events.set(name, callback); },
+    close(code, reason) { state.closes.push({ code, reason }); },
+    send(chunk) { state.sent.push(Array.from(chunk)); },
+  };
+  const socket = {
+    opened, closed: closed.promise,
+    writable: { getWriter: () => ({
+      ready: Promise.resolve(),
+      async write(chunk) { writes.push(Array.from(chunk)); if (write) await write(chunk); },
+    }) },
+    readable,
+    async close() {
+      state.socketCloses++;
+      try { readController.close(); } catch { /* already closed or errored */ }
+      closed.resolve();
+    },
+  };
+  const context = vm.createContext({
+    URL, Uint8Array, ArrayBuffer, setTimeout: timeout ? (fn) => setTimeout(fn, 0) : setTimeout, clearTimeout,
+    Response: class {
+      constructor(body, options) { this.body = body; Object.assign(this, options); }
+    },
+    WebSocketPair: class { constructor() { this[0] = {}; this[1] = server; } },
+  });
+  const sockets = new vm.SyntheticModule(["connect"], function () {
+    this.setExport("connect", (address) => {
+      state.connects++;
+      state.address = address;
+      return socket;
+    });
+  }, { context });
+  const module = new vm.SourceTextModule(source, { context });
+  await module.link((name) => {
+    assert.equal(name, "cloudflare:sockets");
+    return sockets;
+  });
+  await module.evaluate();
+  return {
+    ...state,
+    state, writes, reads, closed, socket,
+    download(chunk) { readController.enqueue(chunk); },
+    eof() { readController.close(); },
+    message(data) { events.get("message")({ data }); },
+    event(name) { events.get(name)({}); },
+    fetch(path = "/apiws?dst=149.154.167.51&dc=2", headers = {}, env = {}) {
+      return module.namespace.default.fetch(new Request(`https://example.workers.dev${path}`, {
+        headers: { Upgrade: "websocket", "Sec-WebSocket-Protocol": "binary", ...headers },
+      }), env);
+    },
+  };
+}
+
+test("HTTP deployment check does not claim Telegram connectivity", async () => {
+  const f = await fixture();
+  assert.equal((await f.fetch("/apiws", { Upgrade: "" })).status, 426);
+  assert.equal(f.state.connects, 0);
+});
+
+test("reject unauthorized destinations, token and subprotocol before opening TCP", async () => {
+  const f = await fixture();
+  assert.equal((await f.fetch("/wrong")).status, 404);
+  assert.equal((await f.fetch("/apiws?dst=127.0.0.1")).status, 403);
+  assert.equal((await f.fetch(undefined, {}, { TGLOCK_TOKEN: "test-token" })).status, 403);
+  assert.equal((await f.fetch(undefined, { "Sec-WebSocket-Protocol": "chat" })).status, 400);
+  assert.equal(f.state.connects, 0);
+});
+
+test("wait for upstream TCP before accepting WebSocket", async () => {
+  const opened = deferred();
+  const f = await fixture({ opened: opened.promise });
+  const response = f.fetch();
+  await tick();
+  assert.equal(f.state.accepted, false);
+  opened.resolve();
+  const result = await response;
+  assert.equal(result.status, 101);
+  assert.equal(result.headers["Sec-WebSocket-Protocol"], "binary");
+  assert.equal(f.state.accepted, true);
+  f.event("close");
+});
+
+test("failed upstream returns HTTP 502, never a successful tunnel", async () => {
+  const f = await fixture({ opened: Promise.reject(new Error("unreachable")) });
+  assert.equal((await f.fetch()).status, 502);
+  assert.equal(f.state.accepted, false);
+  assert.equal(f.state.socketCloses, 1);
+});
+
+test("upstream timeout returns 504 and cancels socket", async () => {
+  const f = await fixture({ opened: new Promise(() => {}), timeout: true });
+  assert.equal((await f.fetch()).status, 504);
+  assert.equal(f.state.accepted, false);
+  assert.equal(f.state.socketCloses, 1);
+});
+
+test("serialize binary writes, preserve bytes and view offsets", async () => {
+  const firstWrite = deferred();
+  let calls = 0;
+  const f = await fixture({ write: async () => { if (++calls === 1) await firstWrite.promise; } });
+  await f.fetch();
+  f.message(new Uint8Array([1, 2]).buffer);
+  f.message(new Uint8Array([99, 3, 4, 88]).subarray(1, 3));
+  await tick();
+  assert.deepEqual(f.writes, [[1, 2]]);
+  firstWrite.resolve();
+  await tick();
+  assert.deepEqual(f.writes, [[1, 2], [3, 4]]);
+  f.event("close");
+});
+
+test("overflow closes socket and discards queued writes", async () => {
+  const f = await fixture();
+  await f.fetch();
+  f.message(new Uint8Array(1024 * 1024).buffer);
+  f.message(new Uint8Array([1]).buffer);
+  await tick();
+  assert.equal(f.state.closes[0].code, 1009);
+  assert.equal(f.state.socketCloses, 1);
+  assert.equal(f.writes.length, 0);
+});
+
+test("empty-message floods have a bounded queue too", async () => {
+  const f = await fixture();
+  await f.fetch();
+  for (let i = 0; i < 257; i++) f.message(new ArrayBuffer(0));
+  await tick();
+  assert.equal(f.state.closes[0].code, 1009);
+  assert.equal(f.state.socketCloses, 1);
+});
+
+test("text and write failures get diagnostic close codes", async () => {
+  const f = await fixture();
+  await f.fetch();
+  f.message("not binary");
+  assert.equal(f.state.closes[0].code, 1003);
+  const failing = await fixture({ write: async () => { throw new Error("reset"); } });
+  await failing.fetch();
+  failing.message(new Uint8Array([1]).buffer);
+  await tick();
+  assert.equal(failing.state.closes[0].code, 1011);
+  assert.equal(failing.state.socketCloses, 1);
+});
+
+test("read errors propagate and close both socket directions", async () => {
+  const f = await fixture();
+  await f.fetch();
+  f.reads.reject(new Error("reset"));
+  await tick();
+  assert.equal(f.state.closes[0].code, 1011);
+  assert.equal(f.state.socketCloses, 1);
+});
+
+test("Telegram bytes reach WebSocket unchanged and EOF closes both directions", async () => {
+  const f = await fixture();
+  await f.fetch();
+  f.download(new Uint8Array([0, 255, 128]));
+  f.download(new Uint8Array([1, 2]));
+  f.eof();
+  await tick();
+  assert.deepEqual(f.state.sent, [[0, 255, 128], [1, 2]]);
+  assert.equal(f.state.closes[0].code, 1000);
+  assert.equal(f.state.socketCloses, 1);
+});
+
+test("CDN worker keeps the requested DC203 destination", async () => {
+  const f = await fixture();
+  await f.fetch("/apiws?dst=91.105.192.100&dc=203");
+  assert.equal(f.state.address.hostname, "91.105.192.100");
+  assert.equal(f.state.address.port, 443);
+  f.event("close");
+});

worker/wrangler.toml

@@ -0,0 +1,3 @@
+name = "tglock"
+main = "tglock-worker.js"
+compatibility_date = "2026-09-19"