mirror of
https://github.com/by-sonic/tglock.git
synced 2026-09-20 09:28:26 +03:00
Compare commits
2 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 by-sonic
|
f0bfed6091 | ||
|
by-sonic
|
a87e26c581 |
@@ -1,110 +0,0 @@
|
||||
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
|
||||
@@ -1,59 +0,0 @@
|
||||
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
|
||||
+4
-102
@@ -9,27 +9,6 @@ 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
|
||||
@@ -79,40 +58,6 @@ 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
|
||||
@@ -128,13 +73,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 --features cli --all-targets -- -D warnings
|
||||
run: cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
|
||||
|
||||
- name: Test
|
||||
run: cargo test --no-default-features --features cli --lib --bins
|
||||
run: cargo test --no-default-features --lib --bins
|
||||
|
||||
- name: Build
|
||||
run: cargo build --release --no-default-features --features cli --bin tglock-cli
|
||||
run: cargo build --release --no-default-features --bin tglock-cli
|
||||
|
||||
- name: Start, advertise a proxy link and stop on SIGTERM
|
||||
run: |
|
||||
@@ -156,43 +101,6 @@ 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
|
||||
@@ -215,7 +123,7 @@ jobs:
|
||||
run: cargo check --locked
|
||||
|
||||
- name: Check the headless dependency graph too
|
||||
run: cargo check --locked --no-default-features --features cli --lib --bins
|
||||
run: cargo check --locked --no-default-features --lib --bins
|
||||
|
||||
frontend:
|
||||
name: Frontend
|
||||
@@ -231,9 +139,3 @@ 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
|
||||
|
||||
@@ -9,40 +9,7 @@ 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
|
||||
@@ -97,74 +64,39 @@ jobs:
|
||||
with:
|
||||
tagName: v__VERSION__
|
||||
releaseName: TGLock v__VERSION__
|
||||
# Только инструкция по скачиванию: она одна и та же для любой версии.
|
||||
# Список изменений дописывается в release notes при выпуске — иначе
|
||||
# выходит как в бетах 1-7, где каждая несла один и тот же текст «новый
|
||||
# TGLock, полностью обновлённый интерфейс» и понять, что поменялось,
|
||||
# было невозможно.
|
||||
releaseBody: |
|
||||
## Что скачивать
|
||||
Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
|
||||
|
||||
- **Windows** — `.exe`, установщик
|
||||
- **macOS** — универсальный `.dmg` (или `.app.tar.gz`)
|
||||
- **Linux** — `.AppImage` или `.deb`
|
||||
- **Сервер, контейнер, машина без монитора** — `tglock-cli-*`: то же самое, но без графического интерфейса
|
||||
|
||||
Если Windows ругается на файл — [почему так и что с этим делать](https://github.com/by-sonic/tglock#-антивирус-ругается-smartscreen-предупреждает-virustotal-показывает-детекты).
|
||||
# Publish only after every platform, CLI and exact-commit APK is verified.
|
||||
releaseDraft: true
|
||||
- macOS: скачайте универсальный `.dmg` или `.app.tar.gz`
|
||||
- Windows: скачайте `.exe` установщик
|
||||
- Linux: скачайте `.AppImage` или `.deb`
|
||||
- Сервер или машина без монитора: скачайте `tglock-cli-*` — там нет графического интерфейса
|
||||
releaseDraft: false
|
||||
prerelease: false
|
||||
args: ${{ matrix.args }}
|
||||
|
||||
# Проверяет СОДЕРЖИМОЕ упакованного бинаря, а не его имя.
|
||||
#
|
||||
# v2.0.0-beta.2 и v2.0.0-beta.3 опубликовались с зелёным CI, хотя в бандле
|
||||
# лежал headless CLI вместо приложения. В beta.3 имя файла было уже
|
||||
# правильным — переименованным — поэтому проверка имени прошла. Отличить
|
||||
# можно только по содержимому: `wry`/`ipc.localhost` есть исключительно в
|
||||
# GUI, а `allow-direct` — исключительно в CLI.
|
||||
- name: The bundled binary must actually be the GUI one
|
||||
# Смотрит внутрь собранного бандла. v2.0.0-beta.2 опубликовался с зелёным
|
||||
# CI, хотя .app и .deb содержали headless CLI вместо приложения: сборка
|
||||
# была успешной, просто никто не проверял, что внутри.
|
||||
- name: The bundle must contain the GUI binary
|
||||
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="$app/Contents/MacOS/tglock"
|
||||
test -f "$exe" || { echo "нет $exe:"; ls -la "$app/Contents/MacOS/"; exit 1; }
|
||||
python3 scripts/verify_bundle_binary.py "$exe"
|
||||
exe=$(/usr/libexec/PlistBuddy -c 'Print :CFBundleExecutable' "$app/Contents/Info.plist")
|
||||
echo "CFBundleExecutable = $exe"
|
||||
test "$exe" = "tglock" || { echo "в бандле не GUI-бинарь"; exit 1; }
|
||||
test -x "$app/Contents/MacOS/tglock" || { echo "исполняемый файл отсутствует"; exit 1; }
|
||||
|
||||
- name: The bundled binary must actually be the GUI one
|
||||
- name: The bundle must contain the GUI binary
|
||||
if: runner.os == 'Linux'
|
||||
shell: bash
|
||||
run: |
|
||||
deb=$(find target -maxdepth 6 -name '*.deb' | head -1)
|
||||
test -n "$deb" || { echo ".deb не найден"; exit 1; }
|
||||
root=$(mktemp -d)
|
||||
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/*
|
||||
dpkg-deb -c "$deb" | grep -E ' \./usr/bin/tglock$' \
|
||||
|| { echo "в .deb нет /usr/bin/tglock:"; dpkg-deb -c "$deb" | grep '/bin/'; exit 1; }
|
||||
|
||||
cli:
|
||||
name: Headless CLI ${{ matrix.platform }}
|
||||
@@ -204,7 +136,7 @@ jobs:
|
||||
IFS=',' read -ra targets <<< "${{ matrix.rust-targets }}"
|
||||
binaries=()
|
||||
for target in "${targets[@]}"; do
|
||||
cargo build --release --locked --no-default-features --features cli \
|
||||
cargo build --release --locked --no-default-features \
|
||||
--bin tglock-cli --target "$target"
|
||||
binaries+=("target/$target/release/tglock-cli")
|
||||
done
|
||||
@@ -220,7 +152,7 @@ jobs:
|
||||
if: runner.os == 'Windows'
|
||||
shell: bash
|
||||
run: |
|
||||
cargo build --release --locked --no-default-features --features cli \
|
||||
cargo build --release --locked --no-default-features \
|
||||
--bin tglock-cli --target ${{ matrix.rust-targets }}
|
||||
cp "target/${{ matrix.rust-targets }}/release/tglock-cli.exe" "${{ matrix.asset }}"
|
||||
./"${{ matrix.asset }}" --version
|
||||
@@ -231,6 +163,5 @@ jobs:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
tag_name: ${{ github.ref_name }}
|
||||
draft: true
|
||||
prerelease: false
|
||||
files: ${{ matrix.asset }}
|
||||
|
||||
+20
-2
@@ -2,8 +2,26 @@
|
||||
/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
|
||||
|
||||
Generated
+30
-76
@@ -230,9 +230,9 @@ checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
|
||||
|
||||
[[package]]
|
||||
name = "async-trait"
|
||||
version = "0.1.92"
|
||||
version = "0.1.91"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667"
|
||||
checksum = "ae36dc4177970ef04fde5178d3e2429882def40e57a451f919c098f72baa6cec"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
@@ -336,9 +336,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "blocking"
|
||||
version = "1.7.0"
|
||||
version = "1.6.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a70e4329df6cb94385eed412ec92375c3cdd8a6e502493d1229b6414e4036dfa"
|
||||
checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
|
||||
dependencies = [
|
||||
"async-channel",
|
||||
"async-task",
|
||||
@@ -1550,9 +1550,9 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.5.3"
|
||||
version = "0.5.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e17592d60ebacc7d5e169f4663c5f84f9161cc90328abcfe8456f41e4dfcb284"
|
||||
checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
|
||||
|
||||
[[package]]
|
||||
name = "hex"
|
||||
@@ -2498,16 +2498,6 @@ 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"
|
||||
@@ -2801,19 +2791,6 @@ 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"
|
||||
@@ -2961,9 +2938,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "rustls"
|
||||
version = "0.23.45"
|
||||
version = "0.23.42"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
|
||||
checksum = "3c54fcab019b409d04215d3a17cb438fd7fbf192ee61461f20f4fe18704bc138"
|
||||
dependencies = [
|
||||
"once_cell",
|
||||
"ring",
|
||||
@@ -2975,18 +2952,18 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "rustls-pki-types"
|
||||
version = "1.15.1"
|
||||
version = "1.15.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96"
|
||||
checksum = "764899a24af3980067ee14bc143654f297b22eaebfe3c7b6b211920a5a59b046"
|
||||
dependencies = [
|
||||
"zeroize",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rustls-webpki"
|
||||
version = "0.103.15"
|
||||
version = "0.103.13"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
|
||||
checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
|
||||
dependencies = [
|
||||
"ring",
|
||||
"rustls-pki-types",
|
||||
@@ -3678,9 +3655,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "tauri-plugin-opener"
|
||||
version = "2.5.5"
|
||||
version = "2.5.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "60d60366174b745b4ef5824b8bbc1c457fd08f0ce101ff643c0a49181a9f4e91"
|
||||
checksum = "17e1bea14edce6b793a04e2417e3fd924b9bc4faae83cdee7d714156cceeed29"
|
||||
dependencies = [
|
||||
"dunce",
|
||||
"glob",
|
||||
@@ -3822,7 +3799,7 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "tglock"
|
||||
version = "2.0.0-beta.15"
|
||||
version = "2.0.0-beta.3"
|
||||
dependencies = [
|
||||
"aes",
|
||||
"cipher",
|
||||
@@ -3830,7 +3807,6 @@ dependencies = [
|
||||
"ctr",
|
||||
"futures-util",
|
||||
"rand",
|
||||
"rcgen",
|
||||
"rustls",
|
||||
"serde",
|
||||
"serde_json",
|
||||
@@ -3839,10 +3815,7 @@ dependencies = [
|
||||
"tauri-build",
|
||||
"tauri-plugin-opener",
|
||||
"tokio",
|
||||
"tokio-rustls",
|
||||
"tokio-tungstenite",
|
||||
"toml 0.8.2",
|
||||
"webpki-roots 0.26.11",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3969,9 +3942,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "tokio-rustls"
|
||||
version = "0.26.5"
|
||||
version = "0.26.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b0c85f2c3ef0b1cd58b36682f4b17aaa995f0e5db534d85692b4903abce21f67"
|
||||
checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
|
||||
dependencies = [
|
||||
"rustls",
|
||||
"tokio",
|
||||
@@ -5081,15 +5054,6 @@ 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"
|
||||
@@ -5115,9 +5079,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "zbus"
|
||||
version = "5.19.0"
|
||||
version = "5.18.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5db4be7c075cb421e4b7ee645541604239bd243ba7c357511f4ff3a74b555907"
|
||||
checksum = "fe18fb60dc696039e738717b76eaea21e7a4489bbb1885020b43c94236d7e98a"
|
||||
dependencies = [
|
||||
"async-broadcast",
|
||||
"async-executor",
|
||||
@@ -5150,14 +5114,14 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "zbus_macros"
|
||||
version = "5.19.0"
|
||||
version = "5.18.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2990635d09ade6df1868f72f8cac69a876a90981e8bd3c40b1be413f8dc88f40"
|
||||
checksum = "fe96480bed92df2b442a1a30df364e12d08eed03aeb061f2b8dc6afb2be91119"
|
||||
dependencies = [
|
||||
"proc-macro-crate 3.5.0",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.3",
|
||||
"syn 2.0.119",
|
||||
"zbus_names",
|
||||
"zvariant",
|
||||
"zvariant_utils",
|
||||
@@ -5174,15 +5138,6 @@ 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"
|
||||
@@ -5271,41 +5226,40 @@ checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"
|
||||
|
||||
[[package]]
|
||||
name = "zvariant"
|
||||
version = "5.15.0"
|
||||
version = "5.13.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c1d34c27cc6cdd1f458427519dd6b8612f7b7e3f7b9a0b2355d041dda9869147"
|
||||
checksum = "bee2a0bcd2a907786a456fff45aaaaf54c9ba5f50b71ae9ec1a4edd200c94911"
|
||||
dependencies = [
|
||||
"endi",
|
||||
"enumflags2",
|
||||
"serde",
|
||||
"winnow 1.0.4",
|
||||
"zcheapstr",
|
||||
"zvariant_derive",
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zvariant_derive"
|
||||
version = "5.15.0"
|
||||
version = "5.13.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "864155e69b4352db0c7f374917bf45d1e0c8d17659c8b3dbf9795f3673f8c497"
|
||||
checksum = "38a708216a18780796770bfe3f4739c7c83a3e8f789b755534bbbc06e4e23e12"
|
||||
dependencies = [
|
||||
"proc-macro-crate 3.5.0",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 3.0.3",
|
||||
"syn 2.0.119",
|
||||
"zvariant_utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "zvariant_utils"
|
||||
version = "4.2.0"
|
||||
version = "3.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "bad0294361a320b694a328460dc73add56c306150f5cb6bfafc44446120008a3"
|
||||
checksum = "90cb9383f9b45290407a1258b202d3f8f01db719eb60b4e4055c6375af4fc7c7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"serde",
|
||||
"syn 3.0.3",
|
||||
"syn 2.0.119",
|
||||
"winnow 1.0.4",
|
||||
]
|
||||
|
||||
+23
-28
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "tglock"
|
||||
version = "2.0.0-beta.15"
|
||||
version = "2.0.0-beta.3"
|
||||
edition = "2021"
|
||||
rust-version = "1.88"
|
||||
description = "Telegram unblock via local WebSocket tunnel"
|
||||
@@ -9,22 +9,19 @@ autobins = false
|
||||
|
||||
[features]
|
||||
default = ["gui"]
|
||||
# The desktop GUI. Turning it off drops Tauri, the system WebView and the
|
||||
# frontend bundle from the build, which is what makes headless servers and
|
||||
# machines without a GPU or monitor able to build and run TGLock at all.
|
||||
# The graphical application, on desktop and on Android. Turning it off drops
|
||||
# Tauri, the system WebView and the frontend bundle from the build, which is
|
||||
# what makes headless servers and machines without a GPU or monitor able to
|
||||
# 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]]
|
||||
@@ -35,15 +32,12 @@ 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"], optional = true }
|
||||
# Файл конфигурации CLI. TOML, а не JSON, потому что файл правят руками и в нём
|
||||
# нужны комментарии.
|
||||
toml = { version = "0.8", optional = true }
|
||||
clap = { version = "4", features = ["derive"] }
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
tokio = { version = "1", features = [
|
||||
@@ -55,10 +49,19 @@ 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"] }
|
||||
# Explicit ring provider supports Android and static musl without OpenSSL.
|
||||
rustls = { version = "0.23", default-features = false, features = ["ring", "std", "tls12"] }
|
||||
webpki-roots = "0.26"
|
||||
# Провайдер выбирается явно: rustls 0.23 не определяет его сам, если фичи не
|
||||
# включают ровно один, и падает паникой при первом TLS-соединении. ring выбран
|
||||
# потому что кросскомпилируется под Android без внешнего тулчейна.
|
||||
rustls = { version = "0.23", default-features = false, features = [
|
||||
"ring",
|
||||
"std",
|
||||
"tls12",
|
||||
] }
|
||||
futures-util = "0.3"
|
||||
aes = "0.8"
|
||||
ctr = "0.9"
|
||||
@@ -68,11 +71,3 @@ 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"] }
|
||||
|
||||
@@ -58,10 +58,6 @@
|
||||
|
||||
TGLock — это **локальный прокси** на твоём компьютере: принимает и MTProto, и SOCKS5. Он перехватывает соединения Telegram, заворачивает их в WebSocket и отправляет на веб-инфраструктуру Telegram — по нескольким маршрутам сразу, переключаясь на следующий, если текущий перестал отвечать. Провайдер видит обычный HTTPS.
|
||||
|
||||
Для CDN DC203 есть отдельный маршрут MTProto TCP к его закреплённому адресу:
|
||||
этот CDN может не принимать WebSocket. Если его IP блокируется, остаётся
|
||||
настроенный пользователем Worker. Диагностика показывает выбранный транспорт.
|
||||
|
||||
**Кому подойдёт:**
|
||||
|
||||
- 📱 Telegram открывается через раз, сообщения уходят с задержкой, фото и видео не грузятся
|
||||
@@ -74,7 +70,7 @@ TGLock — это **локальный прокси** на твоём компь
|
||||
|
||||
- ❌ **Голосовые и видеозвонки.** Они идут по UDP, а TGLock проксирует только TCP. Со звонками ничего не изменится
|
||||
- ❌ **Всё, кроме Telegram.** YouTube, Discord, Instagram, ChatGPT работать не начнут: TGLock разворачивает только MTProto — протокол, который больше нигде не используется
|
||||
- **Android:** экспериментальный APK и инструкция проверки — [docs/ANDROID.md](docs/ANDROID.md). Работа в фоне на физических устройствах требует проверки. **iOS:** отдельного приложения нет; доступен [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру).
|
||||
- ❌ **Android и iOS.** Своего приложения нет. Телефон можно подключить к TGLock на компьютере через [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру)
|
||||
|
||||
**Чем отличается от VPN:** TGLock работает **только с Telegram**. Остальной трафик идёт напрямую — ничего не замедляется, мобильный трафик не расходуется впустую.
|
||||
|
||||
@@ -94,11 +90,7 @@ TGLock — это **локальный прокси** на твоём компь
|
||||
|
||||
Все сборки весят единицы мегабайт. Исключение — `.AppImage`: он несёт своё окружение и поэтому крупный.
|
||||
|
||||
Дополнительные проверочные сборки доступны в артефактах 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).
|
||||
> **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно не создаётся: сервер, контейнер, виртуалка, машина без монитора. Доступен начиная с `v2.0.0-beta.2`. Подробности — [ниже](#-без-графического-интерфейса-tglock-cli).
|
||||
|
||||
### 🛡 Антивирус ругается, SmartScreen предупреждает, VirusTotal показывает детекты
|
||||
|
||||
@@ -115,7 +107,7 @@ TGLock — это **локальный прокси** на твоём компь
|
||||
1. **Сверить контрольную сумму.** GitHub публикует `sha256` каждого файла прямо на [странице релиза](https://github.com/by-sonic/tglock/releases/latest) — разверни `Assets` и увидишь digest рядом с именем. Сравни с тем, что скачалось:
|
||||
|
||||
```powershell
|
||||
Get-FileHash .\TGLock_<версия>_x64-setup.exe -Algorithm SHA256
|
||||
Get-FileHash .\TGLock_2.0.0-beta.2_x64-setup.exe -Algorithm SHA256
|
||||
```
|
||||
|
||||
```bash
|
||||
@@ -125,12 +117,12 @@ TGLock — это **локальный прокси** на твоём компь
|
||||
|
||||
Это доказывает, что файл не подменили по пути к тебе.
|
||||
|
||||
2. **Посмотреть, как файл собирался.** Бинарники собирает GitHub Actions из публичного коммита, лог открыт и его никто не может отредактировать задним числом. У каждого релиза на странице Actions есть свой запуск: видно, какой коммит взят и какими командами собран. Ссылка на него — в описании релиза.
|
||||
2. **Посмотреть, как файл собирался.** Бинарники собирает GitHub Actions из публичного коммита, лог открыт и его никто не может отредактировать задним числом. Сборка релиза `v2.0.0-beta.2` — [run 30535555083](https://github.com/by-sonic/tglock/actions/runs/30535555083), коммит `b062724`. Видно, какой исходник взят и какими командами собран.
|
||||
|
||||
3. **Собрать самому.** Для CLI это одна команда и никаких зависимостей кроме Rust:
|
||||
|
||||
```bash
|
||||
cargo build --release --locked --no-default-features --features cli --bin tglock-cli
|
||||
cargo build --release --locked --no-default-features --bin tglock-cli
|
||||
```
|
||||
|
||||
Полная сборка с интерфейсом — [ниже](#-сборка-из-исходников).
|
||||
@@ -163,23 +155,12 @@ Telegram → Настройки → **Продвинутые** → Тип сое
|
||||
|
||||
В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
|
||||
|
||||
Когда 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.
|
||||
Ссылку `tg://proxy` с уже подставленным адресом TGLock открывает сам при включении — её достаточно переслать себе в Telegram и открыть на телефоне. Если нужен адрес руками: `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 работает.
|
||||
@@ -192,31 +173,7 @@ tglock-cli --worker my-name.workers.dev # резервный маршрут,
|
||||
tglock-cli --help # все флаги
|
||||
```
|
||||
|
||||
#### Файл настроек
|
||||
|
||||
Чтобы не собирать батник с ключами при каждом запуске ([#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» и сколько клиентов не опознано. Отдельными строками отмечаются подключившиеся устройства, адреса, из-за которых был отказ, и клиенты, с которыми не удалось договориться, — по ним видно, дошёл ли телефон до сервиса вообще и не вписан ли в нём устаревший секрет.
|
||||
При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
|
||||
|
||||
Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
|
||||
|
||||
@@ -232,7 +189,7 @@ Wants=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=exec
|
||||
ExecStart=/usr/local/bin/tglock-cli --config /etc/tglock.toml
|
||||
ExecStart=/usr/local/bin/tglock-cli --lan --secret-file /var/lib/tglock/secret
|
||||
Restart=on-failure
|
||||
RestartSec=5s
|
||||
StateDirectory=tglock
|
||||
@@ -249,14 +206,11 @@ 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
|
||||
```
|
||||
|
||||
**Закреплённый секрет здесь обязателен**, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без него он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. Задайте `secret` в `/etc/tglock.toml` (файл с правами `600`) либо `secret_file = "/var/lib/tglock/secret"` — тогда `StateDirectory=tglock` создаст каталог с нужными правами, а файл запишется с режимом `600`.
|
||||
|
||||
При старте без закреплённого секрета CLI печатает предупреждение — молча уйти в такое состояние он не даст.
|
||||
`--secret-file` здесь обязателен, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без файла он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. `StateDirectory=tglock` создаёт `/var/lib/tglock` с нужными правами, а сам файл пишется с режимом `600`.
|
||||
|
||||
Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.
|
||||
|
||||
@@ -266,11 +220,9 @@ journalctl -u tglock -f
|
||||
FROM rust:1.88 AS build
|
||||
WORKDIR /src
|
||||
COPY . .
|
||||
RUN cargo build --release --locked --no-default-features --features cli --bin tglock-cli
|
||||
RUN cargo build --release --locked --no-default-features --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"]
|
||||
@@ -280,7 +232,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` для проверки сертификата Telegram.
|
||||
Образу не нужно вообще ничего: ни Node.js, ни `libwebkit2gtk`, ни даже `ca-certificates` — TLS работает на rustls, а корневые сертификаты вшиты в бинарь.
|
||||
|
||||
---
|
||||
|
||||
@@ -304,12 +256,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 в браузере. Для CDN DC203 сначала используется обычный обфусцированный MTProto TCP к закреплённому CDN IP; его WebSocket endpoint может быть недоступен.
|
||||
4. **Маршруты проверяются с ограниченным параллелизмом:** сначала запомненный или основной Telegram-маршрут, затем настроенный Worker и резервные адреса. Зависший IP не задерживает все остальные попытки. Упавший маршрут уходит в cooldown с удвоением задержки; при отказе всех маршрутов новые подключения соблюдают эту паузу. Для CDN DC203 сохраняется его собственный адрес. Системный DNS и файл `hosts` **не изменяются**: TCP-соединение идёт на выбранный IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
|
||||
5. На прямых WebSocket-маршрутах провайдер видит **TLS-handshake к `web.telegram.org`**; на Worker-маршруте — домен Worker. Прямой CDN TCP не использует TLS и остаётся доступным для блокировки по IP.
|
||||
3. Трафик заворачивается в **WebSocket** к `kws{dc}.web.telegram.org` — это тот же домен, через который работает Telegram Web в браузере.
|
||||
4. **Маршрут выбирается каскадом**, и это главное отличие 2.0 от первой версии. Один домен может резолвиться в недоступный адрес, поэтому по очереди пробуются: закреплённые IP Telegram, их дублёры `kwsN-1`, системный DNS и — если ты его настроил — твой собственный Cloudflare Worker. Упавший маршрут уходит в cooldown с удвоением задержки, удачный запоминается для этого DC. Системный DNS и файл `hosts` при этом **не изменяются**: TCP-соединение идёт на закреплённый IP, а TLS SNI и заголовок `Host` остаются настоящими, поэтому сертификат Telegram проверяется как обычно.
|
||||
5. Провайдер видит **TLS-handshake к `web.telegram.org`** — легитимный HTTPS, MTProto в нём не виден.
|
||||
6. Весь остальной трафик (не-Telegram) проходит **напрямую** — без замедления.
|
||||
|
||||
> Интерфейс различает три состояния: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«Telegram на связи»** — есть установленный транспорт: WebSocket после upgrade либо открытое TCP-соединение с CDN. Само это состояние ещё не подтверждает ответ MTProto, авторизацию аккаунта или передачу сообщений.
|
||||
> Интерфейс различает три состояния и не выдаёт одно за другое: **«Защита включена»** — локальный порт открыт, туннеля пока нет; **«Ищем новый маршрут»** — попытки были неудачными, идёт перебор; **«Telegram на связи»** — есть установленный туннель, то есть WebSocket-рукопожатие уже прошло. Смешивание первого и третьего состояния и было основной причиной жалоб «прокси подключён, а Telegram не работает».
|
||||
|
||||
📖 **Архитектура 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) — цифры там описывают код на момент написания, документацией он не является.
|
||||
|
||||
@@ -364,16 +316,12 @@ TGLock же отправляет трафик на **`web.telegram.org`** — о
|
||||
<details>
|
||||
<summary><b>Работает ли на iPhone или Android?</b></summary>
|
||||
|
||||
Для Android есть [экспериментальный APK](docs/ANDROID.md): локальный MTProto-прокси
|
||||
на телефоне, без VpnService. Для iOS отдельного приложения нет. Для обеих платформ
|
||||
также доступны два варианта:
|
||||
Своего приложения под Android и iOS нет — TGLock только для desktop. Есть два обходных пути:
|
||||
|
||||
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).
|
||||
Особенно важна работа после сворачивания на HyperOS и других прошивках с
|
||||
ограничениями фоновых процессов; сборка APK сама по себе этого не проверяет.
|
||||
Поддержка Android обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9), сроков нет: Tauri 2 умеет собирать под Android, но перехват трафика там делается через `VpnService` — это другая архитектура, а не пересборка того же кода.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
@@ -461,7 +409,7 @@ TGLock определяет Telegram по IP получателя и завор
|
||||
| **Tauri 2** | Нативная оболочка для GUI. Опциональна: за фичей `gui`, в CLI не входит |
|
||||
| **TypeScript + Vite** | Интерфейс, внутренняя навигация и строгая типизация |
|
||||
| **tokio** | Async I/O, обработка сигналов для корректной остановки сервиса |
|
||||
| **tokio-tungstenite** | WebSocket-клиент с rustls, ring и встроенными WebPKI roots |
|
||||
| **tokio-tungstenite** + **rustls** | WebSocket-клиент с TLS на чистом Rust: без системного OpenSSL, кросскомпилируется под Android, корневые сертификаты вшиты |
|
||||
| **aes** + **ctr** | Расшифровка MTProto `obfuscated2` init-пакета |
|
||||
| **clap** | Разбор аргументов `tglock-cli` |
|
||||
|
||||
@@ -485,7 +433,7 @@ npm run tauri build
|
||||
### Только CLI, без графики
|
||||
|
||||
```bash
|
||||
cargo build --release --locked --no-default-features --features cli --bin tglock-cli
|
||||
cargo build --release --locked --no-default-features --bin tglock-cli
|
||||
```
|
||||
|
||||
Ни Node.js, ни фронтенда, ни `libwebkit2gtk` для этого не нужно — при выключенной фиче `gui` Tauri и системный WebView в сборку не попадают вообще. Именно так CLI собирается на голом сервере.
|
||||
@@ -495,12 +443,12 @@ cargo build --release --locked --no-default-features --features cli --bin tglock
|
||||
```bash
|
||||
cargo fmt --check
|
||||
cargo clippy --all-targets -- -D warnings
|
||||
cargo clippy --no-default-features --features cli --all-targets -- -D warnings
|
||||
cargo clippy --no-default-features --lib --bins --all-targets -- -D warnings
|
||||
cargo test --all-targets
|
||||
cargo test --no-default-features --features cli --lib --bins
|
||||
cargo test --no-default-features --lib --bins
|
||||
```
|
||||
|
||||
Проверяются `obfuscated2`, выбор маршрутов и cooldown, отказы SOCKS5, сохранение и миграция секрета, двунаправленный туннель, TLS-сертификаты и SNI. `npm run test:worker` проверяет скрипт Cloudflare. Android и ARM64 CLI собираются отдельными заданиями; результаты и ограничения проверки перечислены в [аудите issues](docs/ISSUES_2026-09-19.md). Тесты с `#[ignore]` требуют живой сети.
|
||||
Тестов 59: разбор `obfuscated2`, каскад маршрутов и его cooldown, протокольные отказы SOCKS5, устойчивость секрета к перезапуску, плюс сквозной тест туннеля против мок-сервера, который реализует сторону Telegram и проверяет, что до неё доходит ровно тот открытый текст, который отправил клиент. Единственный тест с пометкой `#[ignore]` — тот, что требует живой сети.
|
||||
|
||||
### Свой релиз через GitHub Actions
|
||||
|
||||
@@ -517,9 +465,7 @@ cargo test --no-default-features --features cli --lib --bins
|
||||
- **Присылаешь PR** — перед отправкой прогони проверки выше, они те же, что в CI. Небольшие PR ревьюятся быстрее.
|
||||
- **Не работает после релиза** — это регрессия, пиши сразу, такие вещи в приоритете.
|
||||
|
||||
Известные ограничения: звонки (UDP), сервисы кроме Telegram (только MTProto),
|
||||
отсутствие отдельного приложения iOS. Android пока экспериментальный;
|
||||
результаты проверки устройств собираются в [#9](https://github.com/by-sonic/tglock/issues/9).
|
||||
Известные ограничения, о которых не нужно открывать issue: звонки (UDP), сервисы кроме Telegram (только MTProto), Android и iOS (обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9)).
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"$schema": "../gen/schemas/desktop-schema.json",
|
||||
"identifier": "default",
|
||||
"description": "TGLock application window",
|
||||
"description": "TGLock desktop window",
|
||||
"windows": ["main"],
|
||||
"permissions": ["core:default"]
|
||||
}
|
||||
|
||||
@@ -1,76 +0,0 @@
|
||||
# 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.
|
||||
+22
-166
@@ -55,125 +55,6 @@ 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` считает **установленные** туннели: счётчик поднимается после
|
||||
@@ -182,14 +63,6 @@ Ping приходит в читающую половину, а отвечает
|
||||
несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
|
||||
«туннель установлен» различимы и в GUI, и в выводе CLI.
|
||||
|
||||
Дата-центр и маршрут пишутся **одним значением**, в момент, когда туннель
|
||||
поднялся. Пока это были два независимых поля, номер писало соединение при
|
||||
разборе init, а маршрут — другое соединение после рукопожатия, и при десятках
|
||||
одновременных соединений в строку статуса попадала пара из разных из них.
|
||||
Читалась она как «до этого DC шли этим маршрутом», хотя означала другое: в
|
||||
диагностике #42 встречались строки `DC5 · Запасной Telegram IP`, а у DC5
|
||||
закреплённый адрес всего один и запасного у него не бывает вовсе.
|
||||
|
||||
Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
|
||||
файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
|
||||
путь по умолчанию не определяется, и секрет генерировался бы заново при каждом
|
||||
@@ -201,38 +74,35 @@ Ping приходит в читающую половину, а отвечает
|
||||
|
||||
1. сохранённый успешный маршрут;
|
||||
2. точный Telegram IP с `kwsN` или `kwsN-1` в TLS SNI и WebSocket Host;
|
||||
3. явно настроенный пользователем Cloudflare Worker;
|
||||
4. дополнительные Telegram IP и варианты хоста;
|
||||
5. системный DNS (кроме CDN DC203).
|
||||
3. дополнительный Telegram IP, если он определён;
|
||||
4. системный DNS;
|
||||
5. явно настроенный пользователем Cloudflare Worker.
|
||||
|
||||
Поддерживаются DC1–5 и CDN DC203. Для DC203 первым используется обычный MTProto
|
||||
TCP к закреплённому `91.105.192.100:443`; этот сервер может принимать MTProto,
|
||||
не принимая TLS/WebSocket. Резерв через Worker соединяется с тем же IP.
|
||||
WebSocket-попытки также сохраняют закреплённый адрес. DNS fallback на DC2 для DC203 запрещён:
|
||||
успешный WebSocket handshake с другим DC не доставляет CDN-запрос в нужный
|
||||
датацентр. Worker также получает именно IP DC203.
|
||||
Поддерживаются DC1–5 и media/CDN DC203. DC203 использует WebSocket-host DC2,
|
||||
но подключается к собственному IP.
|
||||
|
||||
После ошибки маршрут получает exponential cooldown от 30 секунд до 30 минут.
|
||||
Успешный маршрут становится первым для следующего соединения того же DC и
|
||||
типа трафика. Попытки запускаются с интервалом 250 мс, не больше трёх
|
||||
одновременно на соединение; остальные отменяются после первого успеха.
|
||||
Если все маршруты на паузе, возвращается причина и время до повторной
|
||||
попытки. Новое подключение клиента не обходит cooldown. Ошибка upstream
|
||||
после handshake также снимает предпочтение маршрута и добавляет cooldown.
|
||||
типа трафика.
|
||||
|
||||
## TLS policy
|
||||
|
||||
Проверка сертификатов и hostname никогда не отключается. При подключении к
|
||||
заданному Telegram IP TCP destination отделён от URI host: TLS продолжает
|
||||
проверять сертификат настоящего `kws*.web.telegram.org`. Используется rustls
|
||||
с провайдером ring и встроенными WebPKI roots; системный OpenSSL для ядра
|
||||
и CLI не нужен. Собственные корневые сертификаты ОС автоматически не
|
||||
подхватываются. Тесты проверяют доверенный сертификат, SNI, неверное имя
|
||||
хоста и недоверенного издателя.
|
||||
проверять сертификат настоящего `kws*.web.telegram.org`.
|
||||
|
||||
Это относится к TLS-маршрутам. Прямой CDN TCP — отдельный транспорт MTProto,
|
||||
а не TLS с отключённой проверкой. Он доступен только для точного назначения
|
||||
DC203. Для произвольных адресов такой обход политики не добавляется.
|
||||
Стек — **rustls** с корневыми сертификатами webpki, вшитыми в бинарь. Выбран не
|
||||
из вкуса: `native-tls` на Linux и Android тянет OpenSSL, а `openssl-sys` не
|
||||
кросскомпилируется под `aarch64-linux-android` без сборки OpenSSL вручную.
|
||||
Побочные выгоды: на 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
|
||||
не загружает и не скрывает публичные списки чужих доменов.
|
||||
@@ -245,19 +115,9 @@ Worker должен принимать WebSocket на:
|
||||
/apiws?dst=<telegram-ip>&dc=<dc-id>
|
||||
```
|
||||
|
||||
и проксировать бинарные frames в TCP `<telegram-ip>:443`. Ответ 101 отправляется
|
||||
после открытия upstream TCP; таймаут/отказ — HTTP 504/502. Список назначений
|
||||
фиксирован, текстовые сообщения отклоняются. Очередь входящих записей ограничена
|
||||
1 МиБ и 256 сообщениями. Авторизация токеном требует собственного клиента:
|
||||
штатный TGLock токен Worker пока не передаёт.
|
||||
|
||||
Запись в сокет Telegram обязана быть последовательной: следующий чанк уходит
|
||||
после того, как записан предыдущий, и только когда писатель к этому готов
|
||||
(`writer.ready`). В `worker/tglock-worker.js` этого не было — `write()`
|
||||
вызывался поверх незавершённого, без backpressure. Пока в клиенте голодала
|
||||
отправка, настоящего потока вверх через воркер не возникало и это не
|
||||
проявлялось; после того как голодание починили, поток появился. Кто разворачивал
|
||||
воркер раньше — обновите скрипт.
|
||||
и проксировать бинарные frames в TCP `<telegram-ip>:443`. Рекомендуется
|
||||
добавить собственную авторизацию до стабильного релиза; поэтому Worker
|
||||
остаётся расширенной опцией alpha-версии.
|
||||
|
||||
## Current limitations
|
||||
|
||||
@@ -281,9 +141,5 @@ Worker должен принимать WebSocket на:
|
||||
CLI собирается одной командой. Подробно — в разделе README про антивирус.
|
||||
- Работоспособность медиа зависит от конкретного DC аккаунта и доступности
|
||||
Telegram/Cloudflare у провайдера.
|
||||
- Соединение, открытое клиентом и молчащее дольше `IO_TIMEOUT` (10 секунд),
|
||||
закрывается. Для клиента, открывающего соединения про запас, это норма; счётчик
|
||||
«промолчали» показывает, как часто это происходит, — раньше такие соединения
|
||||
не попадали никуда.
|
||||
- Пулы заранее открытых WebSocket-соединений будут добавлены после измерения,
|
||||
что они не создают лишнюю нагрузку и не ухудшают стабильность.
|
||||
|
||||
@@ -37,14 +37,10 @@
|
||||
|
||||
### Проверка, что воркер жив
|
||||
|
||||
Открой в браузере `https://tglock.имя.workers.dev/apiws`. Должно вернуться `expected a websocket upgrade` (HTTP 426). Это проверяет только публикацию скрипта. Соединение Worker → Telegram обычный GET **не проверяет**.
|
||||
Открой в браузере `https://tglock.имя.workers.dev/apiws`. Должно вернуться `expected a websocket upgrade` — это правильный ответ: значит код развёрнут и работает, просто браузер пришёл обычным запросом.
|
||||
|
||||
Если вернулось `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` → Сохранить. Настройки меняются только при выключенной защите.
|
||||
@@ -56,13 +52,13 @@ tglock-cli --worker tglock.имя.workers.dev
|
||||
tglock-cli --worker первый.workers.dev --worker второй.workers.dev
|
||||
```
|
||||
|
||||
Настроенный Worker участвует в ограниченном параллельном переборе маршрутов: его проверка начинается вслед за первым Telegram-маршрутом, без ожидания всех таймаутов. Успешный маршрут запоминается. При быстром ответе Telegram Worker не нужен; при медленном прямом маршруте может победить Worker. Поэтому добавляй только свой домен или домен доверенного оператора.
|
||||
Worker всегда пробуется **последним**, после всех маршрутов Telegram. Пока обычные маршруты живы, трафик через него не пойдёт, и это осознанно: чужая инфраструктура в цепочке — это лишнее звено, а не улучшение.
|
||||
|
||||
## Ограничение доступа
|
||||
|
||||
Адрес Worker не является механизмом авторизации. Для своего клиента можно задать секрет `TGLOCK_TOKEN` в настройках Cloudflare и передавать его параметром `token`.
|
||||
Адрес воркера сам по себе секрет, но лучше поставить токен: **Settings → Variables → Add variable**, имя `TGLOCK_TOKEN`, значение — любая длинная строка.
|
||||
|
||||
Штатный клиент TGLock параметр `token` пока не отправляет. **Не задавай TGLOCK_TOKEN для штатного клиента:** это приведёт к HTTP 403. При отсутствии переменной любой, кто знает домен, может использовать Worker для разрешённых адресов Telegram и расходовать лимиты твоего аккаунта.
|
||||
Пока переменная не задана, проверка токена выключена. Когда задана — воркер начнёт отвечать `403` без параметра `?token=`. Клиент TGLock этот параметр пока не отправляет, так что включать токен есть смысл, если ты правишь и сам скрипт, и адрес.
|
||||
|
||||
Независимо от токена воркер соединяется **только** с семью адресами Telegram, которые запрашивает TGLock. Любой другой `dst` получает `403`, так что открытым TCP-прокси он не станет.
|
||||
|
||||
@@ -78,7 +74,6 @@ Sec-WebSocket-Protocol: binary
|
||||
- `dst` — адрес Telegram, к которому нужно подключиться по TCP на порт 443;
|
||||
- `dc` — номер датацентра, для логов;
|
||||
- **подпротокол `binary` обязательно нужно подтвердить в ответе** — без этого клиент разорвёт рукопожатие;
|
||||
- ответ 101 означает, что TCP к разрешённому Telegram IP уже открыт; HTTP 502/504 означает отказ/таймаут этого подключения;
|
||||
- дальше бинарные frames пересылаются в обе стороны без изменений;
|
||||
- TLS до самого воркера обеспечивает Cloudflare.
|
||||
|
||||
@@ -88,6 +83,4 @@ Sec-WebSocket-Protocol: binary
|
||||
|
||||
Скрипт написан по контракту, вычитанному из исходников клиента, и путь с параметрами закреплён тестом `connects_through_the_documented_worker_contract` — он поднимает локальный сервер, который ведёт себя ровно так, как описано выше, и проверяет, что туннель через него поднимается и данные доходят в обе стороны.
|
||||
|
||||
`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 перед публикацией убери.
|
||||
Чего этот тест не проверяет: развёрнутый воркер в самом Cloudflare. Если что-то не сойдётся с их API — [открой issue](https://github.com/by-sonic/tglock/issues/new), поправлю.
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
# Открытые 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 о пользовательских симптомах остаются открыты до этой проверки.
|
||||
Наличие исправленного дефекта и зелёных регрессий не доказывает, что в конкретной
|
||||
сети отсутствует дополнительная блокировка.
|
||||
@@ -1,8 +1,5 @@
|
||||
# TGLock 2.0 issue audit
|
||||
|
||||
Актуальный разбор семи открытых issues и границ проверки:
|
||||
[19 сентября 2026](ISSUES_2026-09-19.md). Ниже сохранены исторические записи.
|
||||
|
||||
Проверено 29 июля 2026 года: все 15 issues и 5 pull requests, существовавшие
|
||||
в репозитории на момент аудита.
|
||||
|
||||
@@ -44,44 +41,6 @@
|
||||
> кодом, 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 не работает» — приложение
|
||||
|
||||
@@ -1,61 +0,0 @@
|
||||
# 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).
|
||||
@@ -1,93 +0,0 @@
|
||||
# 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). Статическая сборка сама по себе не
|
||||
устраняет блокировку всех внешних маршрутов.
|
||||
@@ -1,100 +0,0 @@
|
||||
# Как выпускать релиз
|
||||
|
||||
## Подготовка через 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 и выберите новую версию для
|
||||
нового тега. Опубликованные теги и бинарные артефакты не заменяйте: пользователи
|
||||
должны иметь возможность воспроизвести уже выпущенную версию.
|
||||
@@ -15,7 +15,6 @@ val tauriProperties = Properties().apply {
|
||||
|
||||
android {
|
||||
compileSdk = 36
|
||||
ndkVersion = "28.0.13004108"
|
||||
namespace = "com.bysonic.tglock"
|
||||
defaultConfig {
|
||||
manifestPlaceholders["usesCleartextTraffic"] = "false"
|
||||
@@ -31,8 +30,7 @@ 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")
|
||||
@@ -47,10 +45,6 @@ android {
|
||||
)
|
||||
}
|
||||
}
|
||||
compileOptions {
|
||||
sourceCompatibility = JavaVersion.VERSION_1_8
|
||||
targetCompatibility = JavaVersion.VERSION_1_8
|
||||
}
|
||||
kotlinOptions {
|
||||
jvmTarget = "1.8"
|
||||
}
|
||||
@@ -68,6 +62,7 @@ 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")
|
||||
|
||||
Vendored
+1
-4
@@ -18,7 +18,4 @@
|
||||
|
||||
# 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 { *; }
|
||||
#-renamesourcefileattribute SourceFile
|
||||
@@ -20,6 +20,14 @@ 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() {
|
||||
|
||||
@@ -1,28 +0,0 @@
|
||||
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")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -13,11 +13,12 @@ import android.os.IBinder
|
||||
import androidx.core.app.NotificationCompat
|
||||
|
||||
/**
|
||||
* Gives the running proxy Android foreground-service priority.
|
||||
* Keeps the application process alive while the tunnel is in use.
|
||||
*
|
||||
* The proxy itself runs on a Rust thread inside this process, so nothing here
|
||||
* touches networking. This reduces background eviction while Telegram is in
|
||||
* use; force-stop and vendor battery management can still end the process.
|
||||
* touches networking. The only job is to stop Android from killing the process
|
||||
* as soon as the user switches away from the app — without this, Telegram loses
|
||||
* its proxy within minutes of the app going to the background.
|
||||
*/
|
||||
class TunnelService : Service() {
|
||||
override fun onBind(intent: Intent?): IBinder? = null
|
||||
@@ -28,10 +29,6 @@ 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(
|
||||
@@ -42,10 +39,9 @@ class TunnelService : Service() {
|
||||
} else {
|
||||
startForeground(NOTIFICATION_ID, notification)
|
||||
}
|
||||
// The Rust engine belongs to this process. A sticky service restart
|
||||
// would display a working notification without restarting the engine.
|
||||
// After process death the user explicitly starts protection again.
|
||||
return START_NOT_STICKY
|
||||
// The process must come back if the system reclaims it while the user
|
||||
// still has the app open.
|
||||
return START_STICKY
|
||||
}
|
||||
|
||||
private fun createChannel() {
|
||||
|
||||
@@ -5,7 +5,7 @@ buildscript {
|
||||
}
|
||||
dependencies {
|
||||
classpath("com.android.tools.build:gradle:8.11.0")
|
||||
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:2.1.21")
|
||||
classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.25")
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@
|
||||
<html lang="ru">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<meta name="theme-color" content="#070a10" />
|
||||
<title>TGLock</title>
|
||||
</head>
|
||||
|
||||
Generated
+5
-5
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "tglock-ui",
|
||||
"version": "2.0.0-beta.15",
|
||||
"version": "2.0.0-beta.1",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "tglock-ui",
|
||||
"version": "2.0.0-beta.15",
|
||||
"version": "2.0.0-beta.1",
|
||||
"dependencies": {
|
||||
"@tauri-apps/api": "^2.8.0"
|
||||
},
|
||||
@@ -1118,9 +1118,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/nanoid": {
|
||||
"version": "3.3.19",
|
||||
"resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz",
|
||||
"integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==",
|
||||
"version": "3.3.16",
|
||||
"resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz",
|
||||
"integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==",
|
||||
"dev": true,
|
||||
"funding": [
|
||||
{
|
||||
|
||||
+1
-2
@@ -1,10 +1,9 @@
|
||||
{
|
||||
"name": "tglock-ui",
|
||||
"private": true,
|
||||
"version": "2.0.0-beta.15",
|
||||
"version": "2.0.0-beta.3",
|
||||
"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",
|
||||
|
||||
@@ -1,171 +0,0 @@
|
||||
#!/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))
|
||||
@@ -1,191 +0,0 @@
|
||||
#!/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;
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
#!/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))
|
||||
+65
-134
@@ -12,22 +12,11 @@ use std::process::ExitCode;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tglock_lib::cli_settings as config;
|
||||
use tglock_lib::{proxy, transport};
|
||||
use tglock_lib::config::ListenConfig;
|
||||
use tglock_lib::{mtproto, 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",
|
||||
@@ -35,17 +24,13 @@ fn say(text: &str) -> bool {
|
||||
about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
|
||||
)]
|
||||
struct Args {
|
||||
/// Файл настроек. Если не задан, ищется tglock.toml рядом с бинарём
|
||||
#[arg(short, long, value_name = "PATH")]
|
||||
config: Option<PathBuf>,
|
||||
/// Адрес для прослушивания. 127.0.0.1 — только этот компьютер
|
||||
#[arg(short, long, value_name = "IP", default_value = "127.0.0.1")]
|
||||
bind: IpAddr,
|
||||
|
||||
/// Адрес для прослушивания. По умолчанию 127.0.0.1 — только этот компьютер
|
||||
#[arg(short, long, value_name = "IP")]
|
||||
bind: Option<IpAddr>,
|
||||
|
||||
/// Порт локального прокси. По умолчанию 1080
|
||||
#[arg(short, long, value_name = "PORT")]
|
||||
port: Option<u16>,
|
||||
/// Порт локального прокси
|
||||
#[arg(short, long, value_name = "PORT", default_value_t = proxy::DEFAULT_PORT)]
|
||||
port: u16,
|
||||
|
||||
/// То же, что --bind 0.0.0.0: доступ с других устройств в локальной сети
|
||||
#[arg(long, conflicts_with = "bind")]
|
||||
@@ -59,8 +44,8 @@ struct Args {
|
||||
#[arg(long)]
|
||||
allow_direct: bool,
|
||||
|
||||
/// Файл с секретом прокси. Для сервиса нужен он или secret в настройках:
|
||||
/// иначе после перезапуска секрет будет новым и настроенные клиенты отвалятся
|
||||
/// Файл с секретом прокси. Обязателен для сервиса: иначе после перезапуска
|
||||
/// секрет будет новым и уже настроенные клиенты перестанут подключаться
|
||||
#[arg(long, value_name = "PATH")]
|
||||
secret_file: Option<PathBuf>,
|
||||
|
||||
@@ -70,32 +55,29 @@ struct Args {
|
||||
}
|
||||
|
||||
impl Args {
|
||||
fn overrides(&self) -> config::Overrides {
|
||||
config::Overrides {
|
||||
bind: self.bind,
|
||||
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 stats(&self) -> Arc<proxy::Stats> {
|
||||
match &self.secret_file {
|
||||
Some(path) => proxy::Stats::with_secret(mtproto::load_or_create_secret_at(path)),
|
||||
None => proxy::Stats::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Файл настроек и путь, по которому он найден.
|
||||
///
|
||||
/// Явный `--config` обязателен к существованию: если человек указал путь и
|
||||
/// опечатался, молча стартовать с настройками по умолчанию — худшее из
|
||||
/// возможных поведений.
|
||||
fn load_file(&self) -> Result<(config::FileConfig, Option<PathBuf>), String> {
|
||||
if let Some(path) = &self.config {
|
||||
return Ok((config::FileConfig::load(path)?, Some(path.clone())));
|
||||
}
|
||||
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 listen(&self) -> ListenConfig {
|
||||
let base = if self.lan {
|
||||
ListenConfig::lan(self.port)
|
||||
} else {
|
||||
ListenConfig::new(self.bind, self.port)
|
||||
};
|
||||
if self.allow_direct {
|
||||
base.with_allow_direct(true)
|
||||
} else {
|
||||
base
|
||||
}
|
||||
}
|
||||
|
||||
fn worker_domains(&self) -> String {
|
||||
self.worker.join(",")
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> ExitCode {
|
||||
@@ -118,55 +100,30 @@ fn main() -> ExitCode {
|
||||
}
|
||||
|
||||
async fn serve(args: Args) -> Result<(), String> {
|
||||
let (file, file_path) = args.load_file()?;
|
||||
let settings = config::resolve(file, args.overrides())?;
|
||||
let listen = settings.listen;
|
||||
let stats = settings.stats();
|
||||
let quiet = settings.quiet;
|
||||
let listen = args.listen();
|
||||
let stats = args.stats();
|
||||
stats.set_worker_domain(&args.worker_domains());
|
||||
|
||||
// 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 !quiet {
|
||||
let intro = match &file_path {
|
||||
Some(path) => format!("Настройки: {}", path.display()),
|
||||
None => format!(
|
||||
"Настройки: только флаги ({} рядом с бинарём не найден)",
|
||||
config::DEFAULT_FILE_NAME
|
||||
),
|
||||
};
|
||||
say(&intro);
|
||||
say(&format!("Слушаю {}", listen.addr));
|
||||
say(&format!(
|
||||
if !args.quiet {
|
||||
println!("Слушаю {}", listen.addr);
|
||||
println!(
|
||||
"Ссылка для Telegram: {}",
|
||||
listen.telegram_link(&stats.telegram_secret())
|
||||
));
|
||||
// Запись секрета могла провалиться — тогда после перезапуска ссылка
|
||||
// изменится и Telegram скажет «прокси настроен неверно». Раньше это
|
||||
// происходило молча (by-sonic/tglock#37).
|
||||
if let Some(error) = stats.secret_write_error() {
|
||||
say(&format!(
|
||||
"Внимание: секрет НЕ сохранён ({error}). После перезапуска ссылка \
|
||||
изменится, и Telegram откажется подключаться к старой"
|
||||
));
|
||||
}
|
||||
if matches!(settings.secret, config::SecretSource::Ephemeral) {
|
||||
say(
|
||||
"Внимание: секрет не закреплён и будет новым после перезапуска — \
|
||||
задайте secret в настройках или --secret-file",
|
||||
);
|
||||
}
|
||||
);
|
||||
if listen.allow_direct && !listen.addr.ip().is_loopback() {
|
||||
say(&format!(
|
||||
"Внимание: allow_direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
|
||||
println!(
|
||||
"Внимание: --allow-direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
|
||||
listen.addr.ip()
|
||||
));
|
||||
);
|
||||
} else if !listen.allow_direct {
|
||||
say("Пропускаю только адреса Telegram");
|
||||
println!("Пропускаю только адреса Telegram");
|
||||
}
|
||||
if !settings.workers.is_empty() {
|
||||
say(&format!("Резервные Worker-домены: {}", settings.workers));
|
||||
if !args.worker.is_empty() {
|
||||
println!("Резервные Worker-домены: {}", args.worker_domains());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -175,14 +132,14 @@ async fn serve(args: Args) -> Result<(), String> {
|
||||
tokio::spawn(
|
||||
async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
|
||||
);
|
||||
let watcher = (!quiet).then(|| tokio::spawn(watch_status(stats.clone())));
|
||||
let watcher = (!args.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 !quiet {
|
||||
say("Получен сигнал остановки, закрываю соединения…");
|
||||
if !args.quiet {
|
||||
println!("Получен сигнал остановки, закрываю соединения…");
|
||||
}
|
||||
stats.stop();
|
||||
server
|
||||
@@ -205,35 +162,19 @@ 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(),
|
||||
stats.last_route(),
|
||||
stats.last_dc.load(Ordering::Relaxed),
|
||||
stats.last_route.load(Ordering::Relaxed),
|
||||
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(¤t) {
|
||||
continue;
|
||||
}
|
||||
let (active, tunnels, dc, route, failures, route_failures, blocked, unknown, silent) =
|
||||
current;
|
||||
let line = format!(
|
||||
"соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures} · \
|
||||
падений маршрутов {route_failures} · отклонено {blocked} · не опознано {unknown} · промолчали {silent}",
|
||||
let (active, tunnels, dc, route, failures) = current;
|
||||
println!(
|
||||
"соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
|
||||
if dc > 0 {
|
||||
format!("DC{dc}")
|
||||
} else {
|
||||
@@ -241,11 +182,6 @@ async fn watch_status(stats: Arc<proxy::Stats>) {
|
||||
},
|
||||
transport::route_label(route)
|
||||
);
|
||||
// Закрытый stdout — не ошибка: печатать больше некому, туннель работает
|
||||
// дальше без наблюдателя.
|
||||
if !say(&line) {
|
||||
return;
|
||||
}
|
||||
previous = Some(current);
|
||||
}
|
||||
}
|
||||
@@ -277,11 +213,6 @@ 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();
|
||||
@@ -289,7 +220,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn defaults_to_loopback_on_the_default_port() {
|
||||
let listen = from_flags(&[]).listen;
|
||||
let listen = parse(&[]).listen();
|
||||
assert_eq!(listen.addr.to_string(), "127.0.0.1:1080");
|
||||
assert!(listen.allow_direct);
|
||||
}
|
||||
@@ -297,50 +228,50 @@ mod tests {
|
||||
#[test]
|
||||
fn lan_flag_matches_explicit_wildcard_bind() {
|
||||
assert_eq!(
|
||||
from_flags(&["--lan"]).listen,
|
||||
from_flags(&["-b", "0.0.0.0"]).listen
|
||||
parse(&["--lan"]).listen(),
|
||||
parse(&["-b", "0.0.0.0"]).listen()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lan_does_not_relay_non_telegram_traffic() {
|
||||
let listen = from_flags(&["--lan"]).listen;
|
||||
let listen = parse(&["--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!(!from_flags(&["-b", "192.168.1.10"]).listen.allow_direct);
|
||||
assert!(!parse(&["-b", "192.168.1.10"]).listen().allow_direct);
|
||||
assert!(
|
||||
from_flags(&["-b", "192.168.1.10", "--allow-direct"])
|
||||
.listen
|
||||
parse(&["-b", "192.168.1.10", "--allow-direct"])
|
||||
.listen()
|
||||
.allow_direct
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bind_and_port_are_honoured() {
|
||||
let listen = from_flags(&["--bind", "10.0.0.7", "--port", "1443"]).listen;
|
||||
let listen = parse(&["--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 = from_flags(&["-b", "::1", "-p", "2080"]).listen;
|
||||
let listen = parse(&["-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 settings = from_flags(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
|
||||
assert_eq!(settings.workers, "a.workers.dev,b.workers.dev");
|
||||
let args = parse(&["--worker", "a.workers.dev", "--worker", "b.workers.dev"]);
|
||||
assert_eq!(args.worker_domains(), "a.workers.dev,b.workers.dev");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn no_worker_flag_means_no_domains() {
|
||||
assert!(from_flags(&[]).workers.is_empty());
|
||||
assert!(parse(&[]).worker_domains().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -357,10 +288,10 @@ mod tests {
|
||||
));
|
||||
let _ = std::fs::remove_file(&path);
|
||||
|
||||
let first = from_flags(&["--secret-file", path.to_str().unwrap()])
|
||||
let first = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
let second = from_flags(&["--secret-file", path.to_str().unwrap()])
|
||||
let second = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
|
||||
@@ -372,11 +303,11 @@ mod tests {
|
||||
|
||||
// A corrupted file must not wedge the daemon: it is replaced.
|
||||
std::fs::write(&path, "garbage").unwrap();
|
||||
let third = from_flags(&["--secret-file", path.to_str().unwrap()])
|
||||
let third = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
assert_ne!(third, first);
|
||||
let fourth = from_flags(&["--secret-file", path.to_str().unwrap()])
|
||||
let fourth = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
assert_eq!(third, fourth, "the replacement must be persisted in turn");
|
||||
|
||||
@@ -1,360 +0,0 @@
|
||||
//! Файл конфигурации для `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()][..])
|
||||
);
|
||||
}
|
||||
}
|
||||
+55
-216
@@ -43,32 +43,8 @@ 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>,
|
||||
}
|
||||
|
||||
@@ -76,31 +52,24 @@ 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, stats: Arc<proxy::Stats>) -> Self {
|
||||
fn new(settings_path: PathBuf) -> Self {
|
||||
let settings = std::fs::read(&settings_path)
|
||||
.ok()
|
||||
.and_then(|contents| serde_json::from_slice(&contents).ok())
|
||||
.unwrap_or_default();
|
||||
Self {
|
||||
stats,
|
||||
stats: proxy::Stats::new(),
|
||||
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),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -117,13 +86,8 @@ impl AppState {
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> StatusSnapshot {
|
||||
// События прокси доходят до журнала только здесь: у ядра нет своего
|
||||
// способа что-то показать, а интерфейс и так опрашивает состояние.
|
||||
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());
|
||||
let data_center = self.stats.last_dc.load(Ordering::Relaxed);
|
||||
let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
|
||||
StatusSnapshot {
|
||||
running: self.stats.running.load(Ordering::SeqCst),
|
||||
active_connections: self.stats.active.load(Ordering::Relaxed),
|
||||
@@ -131,17 +95,12 @@ 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(),
|
||||
}
|
||||
}
|
||||
@@ -158,18 +117,6 @@ 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)
|
||||
@@ -208,123 +155,70 @@ fn save_settings(settings: Settings, state: State<'_, AppState>) -> Result<Setti
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn start_proxy(
|
||||
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();
|
||||
let worker_app = app.clone();
|
||||
let worker = tokio::spawn(async move {
|
||||
if let Err(error) = proxy::serve(stats.clone(), listener, listen.allow_direct).await {
|
||||
std::thread::spawn(move || {
|
||||
let runtime = match tokio::runtime::Runtime::new() {
|
||||
Ok(runtime) => runtime,
|
||||
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) {
|
||||
push_log(&logs, error, true);
|
||||
}
|
||||
});
|
||||
while !state.stats.running.load(Ordering::SeqCst) && !worker.is_finished() {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
*task = Some(worker);
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(220));
|
||||
if !state.stats.running.load(Ordering::SeqCst) {
|
||||
*state.active_listen.lock().unwrap() = None;
|
||||
*state.started_at.lock().unwrap() = None;
|
||||
return Err("Не удалось запустить прокси; подробности в диагностике".into());
|
||||
return Err(state
|
||||
.logs
|
||||
.lock()
|
||||
.unwrap()
|
||||
.last()
|
||||
.map(|line| line.message.clone())
|
||||
.unwrap_or_else(|| "Не удалось запустить прокси".into()));
|
||||
}
|
||||
|
||||
state.log(format!("Прокси запущен на {}", listen.addr), false);
|
||||
if let Err(error) = open_telegram_link(&app, &state) {
|
||||
// The working proxy remains available through the copy-link control.
|
||||
state.log(error, true);
|
||||
}
|
||||
// The opener plugin works on desktop and on Android alike; the `open`
|
||||
// crate has no Android implementation.
|
||||
let _ = app.opener().open_url(
|
||||
listen.telegram_link(&state.stats.telegram_secret()),
|
||||
None::<&str>,
|
||||
);
|
||||
state.log("Открываю подключение в Telegram…", false);
|
||||
Ok(state.snapshot())
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
async fn stop_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
|
||||
let mut task = state.task.lock().await;
|
||||
fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
|
||||
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);
|
||||
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(())
|
||||
state.snapshot()
|
||||
}
|
||||
|
||||
fn push_log(logs: &Arc<Mutex<Vec<LogLine>>>, message: String, error: bool) {
|
||||
@@ -358,12 +252,10 @@ fn software_rendering_vars(
|
||||
"WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS",
|
||||
"--disable-gpu --disable-gpu-compositing",
|
||||
)]
|
||||
} else if cfg!(any(
|
||||
target_os = "macos",
|
||||
target_os = "android",
|
||||
target_os = "ios"
|
||||
)) {
|
||||
// WebKit on macOS falls back to software rendering on its own.
|
||||
} else if cfg!(target_os = "macos") || cfg!(target_os = "android") {
|
||||
// WebKit on macOS falls back to software rendering on its own, and on a
|
||||
// phone the WebView always has a GPU — forcing software rendering there
|
||||
// would only make the interface slower.
|
||||
&[]
|
||||
} else {
|
||||
&[
|
||||
@@ -386,44 +278,25 @@ 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();
|
||||
|
||||
let builder = tauri::Builder::default().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
|
||||
tauri::Builder::default()
|
||||
.plugin(tauri_plugin_opener::init())
|
||||
.setup(|app| {
|
||||
let settings_path = app
|
||||
.path()
|
||||
.app_config_dir()
|
||||
.map_err(|error| error.to_string())?
|
||||
.join("settings.json");
|
||||
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);
|
||||
app.manage(AppState::new(settings_path));
|
||||
Ok(())
|
||||
})
|
||||
.invoke_handler(tauri::generate_handler![
|
||||
@@ -431,9 +304,7 @@ pub fn run() {
|
||||
get_settings,
|
||||
save_settings,
|
||||
start_proxy,
|
||||
stop_proxy,
|
||||
get_telegram_link,
|
||||
open_telegram
|
||||
stop_proxy
|
||||
])
|
||||
.run(tauri::generate_context!())
|
||||
.expect("failed to run TGLock");
|
||||
@@ -443,42 +314,10 @@ 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!(any(
|
||||
target_os = "macos",
|
||||
target_os = "android",
|
||||
target_os = "ios"
|
||||
)) {
|
||||
if cfg!(target_os = "macos") {
|
||||
assert!(vars.is_empty(), "macOS needs no override");
|
||||
} else {
|
||||
assert!(
|
||||
|
||||
+4
-7
@@ -1,20 +1,17 @@
|
||||
//! TGLock core: the MTProto/WebSocket transport shared by the desktop GUI and
|
||||
//! the headless CLI.
|
||||
//!
|
||||
//! With the `gui` feature disabled this crate does not depend on Tauri, so the
|
||||
//! Nothing in this crate depends on Tauri or on a windowing system, 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;
|
||||
|
||||
/// Настройки headless-версии: файл конфигурации и сведение с флагами.
|
||||
#[cfg(feature = "cli")]
|
||||
pub mod cli_settings;
|
||||
|
||||
/// Desktop and Android graphical application; absent from headless builds.
|
||||
/// The graphical application, shared by the desktop binary and the Android
|
||||
/// package. Compiled only with the `gui` feature, so a headless build never
|
||||
/// pulls in Tauri or a WebView.
|
||||
#[cfg(feature = "gui")]
|
||||
pub mod gui;
|
||||
|
||||
+6
-1
@@ -1,5 +1,10 @@
|
||||
#![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()
|
||||
}
|
||||
|
||||
+28
-326
@@ -2,7 +2,9 @@ use aes::Aes256;
|
||||
use cipher::{KeyIvInit, StreamCipher};
|
||||
use rand::{rngs::OsRng, RngCore};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::path::Path;
|
||||
#[cfg(not(test))]
|
||||
use std::path::PathBuf;
|
||||
|
||||
type AesCtr = ctr::Ctr128BE<Aes256>;
|
||||
|
||||
@@ -41,49 +43,6 @@ 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] {
|
||||
@@ -92,77 +51,36 @@ pub fn generate_secret() -> [u8; 16] {
|
||||
secret
|
||||
}
|
||||
|
||||
/// Секрет прокси и то, лежит ли он на диске.
|
||||
pub struct StoredSecret {
|
||||
pub value: [u8; 16],
|
||||
/// Ошибка, из-за которой секрет не удалось сохранить.
|
||||
///
|
||||
/// Если она есть, при следующем запуске секрет будет другим, ссылка
|
||||
/// `tg://proxy` перестанет совпадать с сохранённой в Telegram, и Telegram
|
||||
/// скажет «прокси настроен неверно и будет отключён». Раньше запись
|
||||
/// провалившись молчала, и понять причину было невозможно
|
||||
/// (by-sonic/tglock#37).
|
||||
pub write_error: Option<String>,
|
||||
}
|
||||
|
||||
impl StoredSecret {
|
||||
/// Секрет действительно переживёт перезапуск.
|
||||
pub fn is_persistent(&self) -> bool {
|
||||
self.write_error.is_none()
|
||||
}
|
||||
}
|
||||
|
||||
/// Взять секрет из файла, создав его, если файла нет или он испорчен.
|
||||
/// Reuse the secret stored at `path`, creating it if it is missing or unusable.
|
||||
///
|
||||
/// Секрет — половина ссылки `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 {
|
||||
/// 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
|
||||
/// client that was already configured.
|
||||
pub fn load_or_create_secret_at(path: &Path) -> [u8; 16] {
|
||||
if let Ok(value) = std::fs::read_to_string(path) {
|
||||
if let Some(value) = parse_secret_hex(value.trim()) {
|
||||
return StoredSecret {
|
||||
value,
|
||||
write_error: None,
|
||||
};
|
||||
if let Some(secret) = parse_secret_hex(value.trim()) {
|
||||
return 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<()> {
|
||||
let secret = generate_secret();
|
||||
if let Some(parent) = path.parent() {
|
||||
if !parent.as_os_str().is_empty() {
|
||||
std::fs::create_dir_all(parent)?;
|
||||
}
|
||||
let _ = std::fs::create_dir_all(parent);
|
||||
}
|
||||
write_secret_file(path, value)
|
||||
write_secret_file(path, &secret_hex(&secret));
|
||||
secret
|
||||
}
|
||||
|
||||
#[cfg(not(test))]
|
||||
pub fn load_or_create_secret() -> StoredSecret {
|
||||
match legacy_secret_path() {
|
||||
pub fn load_or_create_secret() -> [u8; 16] {
|
||||
match secret_path() {
|
||||
Some(path) => load_or_create_secret_at(&path),
|
||||
None => StoredSecret {
|
||||
value: generate_secret(),
|
||||
write_error: Some("не удалось определить папку для секрета в этой системе".to_owned()),
|
||||
},
|
||||
None => generate_secret(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn legacy_secret_path() -> Option<PathBuf> {
|
||||
#[cfg(not(test))]
|
||||
fn secret_path() -> Option<PathBuf> {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
std::env::var_os("APPDATA")
|
||||
@@ -187,21 +105,23 @@ pub fn legacy_secret_path() -> Option<PathBuf> {
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
|
||||
fn write_secret_file(path: &Path, value: &str) {
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let mut file = std::fs::OpenOptions::new()
|
||||
if let Ok(mut file) = std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(path)?;
|
||||
file.write_all(value.as_bytes())
|
||||
.open(path)
|
||||
{
|
||||
let _ = file.write_all(value.as_bytes());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn write_secret_file(path: &Path, value: &str) -> std::io::Result<()> {
|
||||
std::fs::write(path, value)
|
||||
fn write_secret_file(path: &Path, value: &str) {
|
||||
let _ = std::fs::write(path, value);
|
||||
}
|
||||
|
||||
pub fn secret_hex(secret: &[u8; 16]) -> String {
|
||||
@@ -213,21 +133,8 @@ 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 || !value.is_ascii() {
|
||||
if value.len() != 32 {
|
||||
return None;
|
||||
}
|
||||
let mut secret = [0; 16];
|
||||
@@ -306,7 +213,6 @@ 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]
|
||||
@@ -595,144 +501,6 @@ 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!(
|
||||
@@ -744,70 +512,4 @@ 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();
|
||||
}
|
||||
}
|
||||
|
||||
+111
-1408
File diff suppressed because it is too large
Load Diff
@@ -1,271 +0,0 @@
|
||||
//! Какие адреса и имена принадлежат 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");
|
||||
}
|
||||
}
|
||||
}
|
||||
+106
-648
File diff suppressed because it is too large
Load Diff
@@ -1,7 +0,0 @@
|
||||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"app": {
|
||||
"windows": [{ "label": "main", "title": "TGLock", "backgroundColor": "#070A10" }]
|
||||
},
|
||||
"bundle": { "android": { "minSdkVersion": 24 } }
|
||||
}
|
||||
+1
-1
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"productName": "TGLock",
|
||||
"version": "2.0.0-beta.15",
|
||||
"version": "2.0.0-beta.3",
|
||||
"identifier": "com.bysonic.tglock",
|
||||
"mainBinaryName": "tglock",
|
||||
"build": {
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
# Настройки 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
|
||||
+2
-134
@@ -10,17 +10,8 @@ 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[];
|
||||
};
|
||||
|
||||
@@ -46,20 +37,13 @@ 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>`,
|
||||
@@ -117,7 +101,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${toastMessage ? " visible" : ""}${toastError ? " error" : ""}" role="status">${escapeHtml(toastMessage)}</div>
|
||||
<div id="toast" class="toast" role="status"></div>
|
||||
</main>
|
||||
`;
|
||||
}
|
||||
@@ -154,11 +138,6 @@ 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>
|
||||
@@ -166,18 +145,6 @@ 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>
|
||||
@@ -193,9 +160,6 @@ 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"));
|
||||
}
|
||||
@@ -297,46 +261,8 @@ 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>
|
||||
@@ -359,7 +285,6 @@ function renderDiagnostics(): void {
|
||||
</section>
|
||||
`, "subpage-shell");
|
||||
|
||||
document.querySelector("#copy-diagnostics")?.addEventListener("click", copyDiagnostics);
|
||||
document.querySelector("#back")?.addEventListener("click", () => navigate("home"));
|
||||
}
|
||||
|
||||
@@ -431,71 +356,14 @@ 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(() => {
|
||||
toastMessage = "";
|
||||
document.querySelector("#toast")?.classList.remove("visible");
|
||||
}, 4500);
|
||||
toastTimer = window.setTimeout(() => toast.classList.remove("visible"), 2800);
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -847,71 +847,3 @@ 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; }
|
||||
}
|
||||
|
||||
+13
-82
@@ -28,14 +28,9 @@ 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") {
|
||||
@@ -55,95 +50,33 @@ 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 = (code = 1000, reason = "") => {
|
||||
const shutdown = () => {
|
||||
if (closed) return;
|
||||
closed = true;
|
||||
// close() cancels both directions, including a blocked write/read.
|
||||
upstream.close().catch(() => {});
|
||||
writer.close().catch(() => {});
|
||||
try {
|
||||
server.close(code, reason);
|
||||
server.close();
|
||||
} catch {
|
||||
// соединение уже закрыто
|
||||
}
|
||||
};
|
||||
|
||||
// Запись сериализуется: следующий чанк уходит только после того, как
|
||||
// записан предыдущий, и только когда писатель к этому готов.
|
||||
//
|
||||
// Раньше `write()` вызывался поверх незавершённого, а `writer.ready` не
|
||||
// спрашивался вовсе — backpressure не применялся. Пока в клиенте отправка
|
||||
// голодала, поверх воркера настоящего потока вверх не бывало и это не
|
||||
// проявлялось. Как только голодание починили, в воркер пошёл настоящий
|
||||
// поток (by-sonic/tglock#42).
|
||||
let pending = Promise.resolve();
|
||||
let pendingBytes = 0;
|
||||
let pendingMessages = 0;
|
||||
|
||||
server.addEventListener("message", (event) => {
|
||||
if (closed) return;
|
||||
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)
|
||||
: new Uint8Array(event.data.buffer, event.data.byteOffset, event.data.byteLength);
|
||||
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;
|
||||
});
|
||||
const chunk =
|
||||
event.data instanceof ArrayBuffer
|
||||
? new Uint8Array(event.data)
|
||||
: event.data;
|
||||
writer.write(chunk).catch(shutdown);
|
||||
});
|
||||
server.addEventListener("close", () => shutdown());
|
||||
server.addEventListener("error", () => shutdown(1011, "WebSocket failed"));
|
||||
upstream.closed.catch(() => shutdown(1011, "Telegram socket failed"));
|
||||
server.addEventListener("close", shutdown);
|
||||
server.addEventListener("error", shutdown);
|
||||
|
||||
// Обратное направление: всё, что приходит от Telegram, уходит клиенту.
|
||||
(async () => {
|
||||
@@ -155,9 +88,7 @@ export default {
|
||||
server.send(value);
|
||||
}
|
||||
} catch {
|
||||
shutdown(1011, "Telegram read failed");
|
||||
} finally {
|
||||
reader.releaseLock();
|
||||
// разрыв соединения — обычная ситуация, не ошибка
|
||||
}
|
||||
shutdown();
|
||||
})();
|
||||
|
||||
@@ -1,196 +0,0 @@
|
||||
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");
|
||||
});
|
||||
@@ -1,3 +0,0 @@
|
||||
name = "tglock"
|
||||
main = "tglock-worker.js"
|
||||
compatibility_date = "2026-09-19"
|
||||
Reference in New Issue
Block a user