mirror of
https://github.com/by-sonic/tglock.git
synced 2026-07-30 17:36:10 +03:00
Compare commits
23 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 by-sonic
|
ef81d91ad1 | ||
|
Никита Sonic
|
ed121d0968 | ||
|
by-sonic
|
2d2a9e9302 | ||
|
Никита Sonic
|
af3b14395f | ||
|
Никита Sonic
|
59b9cdd68c | ||
|
Никита Sonic
|
f03e9106ee | ||
|
Никита Sonic
|
b06272437c | ||
|
Никита Sonic
|
9bacc488a5 | ||
|
Никита Sonic
|
95059f5449 | ||
|
Никита Sonic
|
55653ed0bc | ||
|
Никита Митусов
|
e622c57a0a | ||
|
Никита Митусов
|
8df24391da | ||
|
Никита Митусов
|
cd75429188 | ||
|
Никита Митусов
|
d0ec1d4a8c | ||
|
Никита Митусов
|
c25bea1d92 | ||
|
Никита Sonic
|
39a7772151 | ||
|
by-sonic
|
ccf3e3150c | ||
|
by-sonic
|
cfa50d66f3 | ||
|
by-sonic
|
1c1ecbc071 | ||
|
by-sonic
|
6795c6177a | ||
|
by-sonic
|
70c61e1330 | ||
|
by-sonic
|
09b7a03a0a | ||
|
by-sonic
|
c40ad94e11 |
@@ -0,0 +1,182 @@
|
||||
name: CI
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [main]
|
||||
pull_request:
|
||||
|
||||
permissions:
|
||||
contents: read
|
||||
|
||||
jobs:
|
||||
rust:
|
||||
name: Rust checks
|
||||
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: Build frontend
|
||||
run: npm ci && npm run build
|
||||
|
||||
- name: Install Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
with:
|
||||
components: rustfmt, clippy
|
||||
|
||||
# Оба бинаря лежат в одном крейте, и бандлер Tauri без явного указания
|
||||
# может взять headless CLI как главный исполняемый файл приложения.
|
||||
# Именно это уехало в v2.0.0-beta.2: .app и .deb содержали tglock-cli, и
|
||||
# приложение не открывалось ни на одной платформе.
|
||||
- name: Main binary of the bundle must be the GUI one
|
||||
run: |
|
||||
node -e "
|
||||
const fs = require('fs');
|
||||
const conf = JSON.parse(fs.readFileSync('tauri.conf.json', 'utf8'));
|
||||
const toml = fs.readFileSync('Cargo.toml', 'utf8');
|
||||
const gui = toml.split('[[bin]]').slice(1)
|
||||
.find(b => /required-features\s*=\s*\[\s*\"gui\"\s*\]/.test(b));
|
||||
if (!gui) throw new Error('не найден [[bin]] с required-features = [\"gui\"]');
|
||||
const name = (gui.match(/name\s*=\s*\"([^\"]+)\"/) || [])[1];
|
||||
if (conf.mainBinaryName !== name) {
|
||||
throw new Error('mainBinaryName=' + conf.mainBinaryName + ', а GUI-бинарь называется ' + name);
|
||||
}
|
||||
console.log('mainBinaryName указывает на GUI-бинарь:', name);
|
||||
"
|
||||
|
||||
- name: Check formatting
|
||||
run: cargo fmt --check
|
||||
|
||||
- name: Lint
|
||||
run: cargo clippy --all-targets -- -D warnings
|
||||
|
||||
- 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 -name 'TGLock.app' -maxdepth 6; exit 1; }
|
||||
ls -la "$exe"
|
||||
if ! grep -qa 'ipc\.localhost' "$exe"; then
|
||||
echo "в бандле не GUI: отсутствует признак ipc.localhost"; exit 1
|
||||
fi
|
||||
if grep -qa 'allow-direct' "$exe"; then
|
||||
echo "в бандле оказался headless CLI: найден признак allow-direct"; exit 1
|
||||
fi
|
||||
echo "OK: в бандле GUI-бинарь"
|
||||
|
||||
headless:
|
||||
name: Headless CLI (no WebView, no Node)
|
||||
runs-on: ubuntu-22.04
|
||||
steps:
|
||||
- uses: actions/checkout@v6
|
||||
|
||||
- name: Install Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
with:
|
||||
components: clippy
|
||||
|
||||
# This job deliberately installs no Node.js, no frontend and no
|
||||
# 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
|
||||
|
||||
- name: Test
|
||||
run: cargo test --no-default-features --features cli --lib --bins
|
||||
|
||||
- name: Build
|
||||
run: cargo build --release --no-default-features --features cli --bin tglock-cli
|
||||
|
||||
- name: Start, advertise a proxy link and stop on SIGTERM
|
||||
run: |
|
||||
./target/release/tglock-cli --help
|
||||
./target/release/tglock-cli --version
|
||||
# --preserve-status makes this assert the shutdown path: a handled
|
||||
# SIGTERM exits 0, an unhandled one would surface as 143 and fail.
|
||||
timeout --preserve-status --signal=TERM 5 \
|
||||
./target/release/tglock-cli --port 18080 --secret-file "$PWD/secret" > cli.log 2>&1
|
||||
cat cli.log
|
||||
grep -q 'tg://proxy' cli.log
|
||||
grep -q '127.0.0.1:18080' cli.log
|
||||
test "$(stat -c '%a' "$PWD/secret")" = 600
|
||||
|
||||
- name: Keep the same proxy link across a restart
|
||||
run: |
|
||||
first=$(grep -o 'secret=[0-9a-f]*' cli.log)
|
||||
timeout --preserve-status --signal=TERM 5 \
|
||||
./target/release/tglock-cli --port 18080 --secret-file "$PWD/secret" > restart.log 2>&1
|
||||
test "$first" = "$(grep -o 'secret=[0-9a-f]*' restart.log)"
|
||||
|
||||
msrv:
|
||||
name: Rust 1.88 compatibility
|
||||
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: Build frontend
|
||||
run: npm ci && npm run build
|
||||
|
||||
- name: Install minimum supported Rust
|
||||
uses: dtolnay/rust-toolchain@1.88.0
|
||||
|
||||
- name: Check locked dependency graph
|
||||
run: cargo check --locked
|
||||
|
||||
- name: Check the headless dependency graph too
|
||||
run: cargo check --locked --no-default-features --features cli --lib --bins
|
||||
|
||||
frontend:
|
||||
name: Frontend
|
||||
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: Type-check and build
|
||||
run: npm ci && npm run build
|
||||
+166
-43
@@ -1,64 +1,187 @@
|
||||
name: Build & Release
|
||||
name: Release
|
||||
|
||||
on:
|
||||
workflow_dispatch:
|
||||
push:
|
||||
tags:
|
||||
- 'v*'
|
||||
tags: ["v*"]
|
||||
|
||||
permissions:
|
||||
contents: write
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: windows-latest
|
||||
publish:
|
||||
name: Build ${{ matrix.platform }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- platform: macOS universal
|
||||
os: macos-14
|
||||
args: --bundles app,dmg --target universal-apple-darwin
|
||||
rust-targets: aarch64-apple-darwin,x86_64-apple-darwin
|
||||
- platform: Windows x64
|
||||
os: windows-latest
|
||||
args: --bundles nsis --target x86_64-pc-windows-msvc
|
||||
rust-targets: x86_64-pc-windows-msvc
|
||||
- platform: Linux x64
|
||||
os: ubuntu-22.04
|
||||
args: --bundles appimage,deb --target x86_64-unknown-linux-gnu
|
||||
rust-targets: x86_64-unknown-linux-gnu
|
||||
|
||||
runs-on: ${{ matrix.os }}
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: actions/checkout@v6
|
||||
|
||||
- name: Install Linux desktop dependencies
|
||||
if: runner.os == 'Linux'
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y \
|
||||
libwebkit2gtk-4.1-dev \
|
||||
libappindicator3-dev \
|
||||
librsvg2-dev \
|
||||
patchelf
|
||||
|
||||
- name: Install Node.js
|
||||
uses: actions/setup-node@v6
|
||||
with:
|
||||
node-version: 22
|
||||
cache: npm
|
||||
|
||||
- name: Install Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
|
||||
- name: Cache cargo
|
||||
uses: actions/cache@v4
|
||||
with:
|
||||
path: |
|
||||
~/.cargo/registry
|
||||
~/.cargo/git
|
||||
target
|
||||
key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
|
||||
targets: ${{ matrix.rust-targets }}
|
||||
|
||||
- name: Build release
|
||||
run: cargo build --release
|
||||
- name: Install frontend dependencies
|
||||
run: npm ci
|
||||
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
- name: Build and publish release
|
||||
uses: tauri-apps/tauri-action@v0
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
name: tg_unblock-windows-x64
|
||||
path: target/release/tg_unblock.exe
|
||||
tagName: v__VERSION__
|
||||
releaseName: TGLock v__VERSION__
|
||||
releaseBody: |
|
||||
Новый TGLock: адаптивный MTProto/WebSocket-транспорт и полностью обновлённый интерфейс на Tauri 2.
|
||||
|
||||
- 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
|
||||
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; }
|
||||
ls -la "$exe"
|
||||
if ! grep -qa 'ipc\.localhost' "$exe"; then
|
||||
echo "в бандле не GUI: отсутствует признак ipc.localhost"; exit 1
|
||||
fi
|
||||
if grep -qa 'allow-direct' "$exe"; then
|
||||
echo "в бандле оказался headless CLI: найден признак allow-direct"; exit 1
|
||||
fi
|
||||
echo "OK: в бандле GUI-бинарь"
|
||||
|
||||
- name: The bundled binary must actually be the GUI one
|
||||
if: runner.os == 'Linux'
|
||||
shell: bash
|
||||
run: |
|
||||
deb=$(find target -maxdepth 6 -name '*.deb' | head -1)
|
||||
test -n "$deb" || { echo ".deb не найден"; exit 1; }
|
||||
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; }
|
||||
ls -la "$exe"
|
||||
if ! grep -qa 'ipc\.localhost' "$exe"; then
|
||||
echo "в .deb не GUI: отсутствует признак ipc.localhost"; exit 1
|
||||
fi
|
||||
if grep -qa 'allow-direct' "$exe"; then
|
||||
echo "в .deb оказался headless CLI: найден признак allow-direct"; exit 1
|
||||
fi
|
||||
echo "OK: в .deb GUI-бинарь"
|
||||
|
||||
cli:
|
||||
name: Headless CLI ${{ matrix.platform }}
|
||||
needs: publish
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
- platform: macOS universal
|
||||
os: macos-14
|
||||
rust-targets: aarch64-apple-darwin,x86_64-apple-darwin
|
||||
asset: tglock-cli-universal-apple-darwin
|
||||
- platform: Windows x64
|
||||
os: windows-latest
|
||||
rust-targets: x86_64-pc-windows-msvc
|
||||
asset: tglock-cli-x86_64-pc-windows-msvc.exe
|
||||
- platform: Linux x64
|
||||
os: ubuntu-22.04
|
||||
rust-targets: x86_64-unknown-linux-gnu
|
||||
asset: tglock-cli-x86_64-unknown-linux-gnu
|
||||
|
||||
runs-on: ${{ matrix.os }}
|
||||
|
||||
release:
|
||||
needs: build
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Download artifact
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: tg_unblock-windows-x64
|
||||
- uses: actions/checkout@v6
|
||||
|
||||
- name: Create Release
|
||||
# No Node.js and no desktop libraries: the CLI must build without them.
|
||||
- name: Install Rust
|
||||
uses: dtolnay/rust-toolchain@stable
|
||||
with:
|
||||
targets: ${{ matrix.rust-targets }}
|
||||
|
||||
- name: Build (unix)
|
||||
if: runner.os != 'Windows'
|
||||
shell: bash
|
||||
run: |
|
||||
IFS=',' read -ra targets <<< "${{ matrix.rust-targets }}"
|
||||
binaries=()
|
||||
for target in "${targets[@]}"; do
|
||||
cargo build --release --locked --no-default-features --features cli \
|
||||
--bin tglock-cli --target "$target"
|
||||
binaries+=("target/$target/release/tglock-cli")
|
||||
done
|
||||
if [ "${#binaries[@]}" -gt 1 ]; then
|
||||
lipo -create -output "${{ matrix.asset }}" "${binaries[@]}"
|
||||
else
|
||||
cp "${binaries[0]}" "${{ matrix.asset }}"
|
||||
fi
|
||||
chmod +x "${{ matrix.asset }}"
|
||||
./"${{ matrix.asset }}" --version
|
||||
|
||||
- name: Build (windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: bash
|
||||
run: |
|
||||
cargo build --release --locked --no-default-features --features cli \
|
||||
--bin tglock-cli --target ${{ matrix.rust-targets }}
|
||||
cp "target/${{ matrix.rust-targets }}/release/tglock-cli.exe" "${{ matrix.asset }}"
|
||||
./"${{ matrix.asset }}" --version
|
||||
|
||||
- name: Attach to the release
|
||||
uses: softprops/action-gh-release@v2
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
with:
|
||||
files: tg_unblock.exe
|
||||
generate_release_notes: true
|
||||
body: |
|
||||
## TG Unblock ${{ github.ref_name }}
|
||||
|
||||
Обход блокировки Telegram через WebSocket-туннель.
|
||||
|
||||
### Установка
|
||||
1. Скачайте `tg_unblock.exe`
|
||||
2. Запустите
|
||||
3. Нажмите "Запустить обход"
|
||||
4. Нажмите "Настроить автоматически"
|
||||
|
||||
---
|
||||
**[by sonic VPN](https://t.me/bysonicvpn_bot)** — полный обход блокировок для всех приложений
|
||||
tag_name: ${{ github.ref_name }}
|
||||
prerelease: false
|
||||
files: ${{ matrix.asset }}
|
||||
|
||||
+5
-3
@@ -1,6 +1,8 @@
|
||||
/target
|
||||
/dist
|
||||
/dist-ui
|
||||
/node_modules
|
||||
/gen
|
||||
/tools
|
||||
*.zip
|
||||
*.exe
|
||||
!*.rs
|
||||
Cargo.lock
|
||||
.claude/
|
||||
|
||||
Generated
+4859
File diff suppressed because it is too large
Load Diff
+51
-13
@@ -1,26 +1,64 @@
|
||||
[package]
|
||||
name = "tg_unblock"
|
||||
version = "0.3.0"
|
||||
name = "tglock"
|
||||
version = "2.0.0-beta.4"
|
||||
edition = "2021"
|
||||
rust-version = "1.88"
|
||||
description = "Telegram unblock via local WebSocket tunnel"
|
||||
license = "MIT"
|
||||
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.
|
||||
gui = ["dep:tauri", "dep:tauri-build", "dep:open"]
|
||||
# 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"]
|
||||
|
||||
[lib]
|
||||
name = "tglock"
|
||||
path = "src/lib.rs"
|
||||
|
||||
[[bin]]
|
||||
name = "tglock"
|
||||
path = "src/main.rs"
|
||||
required-features = ["gui"]
|
||||
|
||||
[[bin]]
|
||||
name = "tglock-cli"
|
||||
path = "src/bin/cli.rs"
|
||||
required-features = ["cli"]
|
||||
|
||||
[dependencies]
|
||||
eframe = "0.31"
|
||||
egui = "0.31"
|
||||
tokio = { version = "1", features = ["full"] }
|
||||
reqwest = { version = "0.12", features = ["blocking"] }
|
||||
tauri = { version = "2", features = [], optional = true }
|
||||
open = { version = "5", optional = true }
|
||||
clap = { version = "4", features = ["derive"], optional = true }
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
open = "5"
|
||||
tokio = { version = "1", features = [
|
||||
"rt-multi-thread",
|
||||
"net",
|
||||
"io-util",
|
||||
"time",
|
||||
"macros",
|
||||
"sync",
|
||||
"signal",
|
||||
] }
|
||||
tokio-tungstenite = { version = "0.24", features = ["native-tls"] }
|
||||
native-tls = "0.2"
|
||||
futures-util = "0.3"
|
||||
aes = "0.8"
|
||||
ctr = "0.9"
|
||||
cipher = "0.4"
|
||||
sha2 = "0.10"
|
||||
rand = "0.8"
|
||||
|
||||
[target.'cfg(windows)'.dependencies]
|
||||
winapi = { version = "0.3", features = ["winuser"] }
|
||||
|
||||
[[bin]]
|
||||
name = "tg_unblock"
|
||||
path = "src/main.rs"
|
||||
[build-dependencies]
|
||||
tauri-build = { version = "2", features = [], optional = true }
|
||||
|
||||
@@ -0,0 +1,295 @@
|
||||
# TGLock v2: переписал обход Telegram с нуля — теперь работает на маке, и один прокси на всю квартиру
|
||||
|
||||
> **Это черновик статьи, а не документация.** Цифры в нём описывают код на
|
||||
> момент написания: «два файла, 350 строк, четыре платформы». Сейчас это 2872
|
||||
> строки Rust (из них около 1140 — тесты), семь файлов и три платформы плюс
|
||||
> headless-бинарь. Актуальное описание — [README](README.md) и
|
||||
> [docs/ARCHITECTURE_V2.md](docs/ARCHITECTURE_V2.md).
|
||||
|
||||
**Простой · 7 мин · Rust · Open source · macOS · Сетевые технологии**
|
||||
|
||||
**TL;DR:** Полмесяца назад я выложил TGLock — обход блокировки Telegram через WebSocket-туннель. Статья залетела на 183K просмотров. А потом всё сломалось. Соединения рвались через 2 минуты, DC определялся неправильно, маководы плакали в комментах. Переписал с нуля. 350 строк. Работает на macOS, Windows, Linux. Один прокси — все устройства в квартире. Код: [github.com/by-sonic/tglock](https://github.com/by-sonic/tglock).
|
||||
|
||||
---
|
||||
|
||||
## Что случилось после первой статьи
|
||||
|
||||
Первая версия TGLock делала простую вещь: SOCKS5-прокси заворачивал MTProto в WebSocket через `web.telegram.org`. Провайдер видит HTTPS — Telegram работает. Концепция правильная. Реализация — нет.
|
||||
|
||||
Через неделю после релиза прилетело:
|
||||
|
||||
> «Работает 2 минуты, потом Telegram пишет ошибку прокси»
|
||||
|
||||
> «По умолчанию выбирает неправильное сетевое подключение, вешается на VMware-адаптер»
|
||||
|
||||
> «Порт 1080 занят, как поменять?»
|
||||
|
||||
> «А на маке будет?»
|
||||
|
||||
Последний вопрос задавали чаще всего. GoodbyeDPI — только Windows. Zapret — есть tpws, но это терминал и ручная настройка. GUI для обхода Telegram на маке — **не существует**. Вообще.
|
||||
|
||||
Решил: не патчить старый код. Переписать с нуля.
|
||||
|
||||
## Что было не так с v1
|
||||
|
||||
### Обрыв через 2 минуты
|
||||
|
||||
Главный баг. WebSocket-серверы Telegram (`kws*.web.telegram.org`) шлют **Ping-фреймы** каждые ~60 секунд. Если клиент не отвечает Pong — сервер закрывает соединение.
|
||||
|
||||
В v1 я использовал `split()` из `futures` чтобы разделить WebSocket-стрим на два потока — чтение и запись. Красиво, идиоматично, по учебнику. И сломано.
|
||||
|
||||
Ping приходит в read-поток. Pong нужно отправить через write-поток. Между ними — channel или shared state. В теории работает. На практике — Pong опаздывает на десятки миллисекунд, сервер считает клиента мёртвым.
|
||||
|
||||
**Решение в v2:** один `tokio::select!` цикл, без split. WebSocket остаётся единым объектом. `biased` приоритизирует чтение WS — Pong улетает мгновенно:
|
||||
|
||||
```rust
|
||||
loop {
|
||||
tokio::select! {
|
||||
biased;
|
||||
msg = ws.next() => match msg {
|
||||
Some(Ok(Message::Binary(data))) => {
|
||||
tcp_w.write_all(data.as_ref()).await?;
|
||||
tcp_w.flush().await?;
|
||||
}
|
||||
Some(Ok(Message::Ping(p))) => {
|
||||
ws.send(Message::Pong(p)).await?;
|
||||
}
|
||||
_ => break,
|
||||
},
|
||||
n = tcp_r.read(&mut buf) => match n {
|
||||
Ok(0) | Err(_) => break,
|
||||
Ok(n) => { ws.send(Message::Binary(buf[..n].to_vec())).await?; }
|
||||
},
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Обратите внимание на `flush()` после каждого write в TCP. Без него tokio буферизует данные, Telegram Desktop ждёт ответ, не дожидается, переподключается. Ещё один баг v1, который маскировался под «нестабильное соединение».
|
||||
|
||||
### Неправильный DC
|
||||
|
||||
В v1 DC определялся по IP-адресу. Таблица маппинга из документации Telegram:
|
||||
|
||||
```
|
||||
149.154.160-163 → DC1
|
||||
149.154.164-167 → DC2
|
||||
91.108.56-59 → DC5
|
||||
...
|
||||
```
|
||||
|
||||
Проблема: в подсети `149.154.164-167` живут **и DC2, и DC4**. Telegram Desktop мог коннектиться к IP, который по таблице выглядит как DC2, а на самом деле хочет DC4. Прокси открывает WebSocket к `kws2.web.telegram.org`, отправляет данные — сервер дропает соединение. Пользователь видит «прокси не настроен».
|
||||
|
||||
**Решение в v2:** не угадывать DC по IP. Telegram Desktop использует **obfuscated2** транспорт. Первые 64 байта — зашифрованный init-пакет. Внутри — настоящий DC ID.
|
||||
|
||||
Ключ: байты `[8..40]`, IV: `[40..56]`. Алгоритм: AES-256-CTR. DC ID: `i32` в байтах `[60..64]` расшифрованного пакета.
|
||||
|
||||
```rust
|
||||
fn dc_from_init(init: &[u8; 64]) -> Option<u8> {
|
||||
use aes::Aes256;
|
||||
use cipher::{KeyIvInit, StreamCipher};
|
||||
|
||||
let mut dec = *init;
|
||||
let mut c = ctr::Ctr128BE::<Aes256>::new(
|
||||
init[8..40].into(),
|
||||
init[40..56].into(),
|
||||
);
|
||||
c.apply_keystream(&mut dec);
|
||||
|
||||
let id = i32::from_le_bytes([dec[60], dec[61], dec[62], dec[63]]);
|
||||
let dc = id.unsigned_abs() as u8;
|
||||
(1..=5).contains(&dc).then_some(dc)
|
||||
}
|
||||
```
|
||||
|
||||
12 строк. Три крейта (`aes`, `ctr`, `cipher`). Зато DC определяется **точно**, а не «скорее всего».
|
||||
|
||||
IP-маппинг остался как fallback — на случай если init-пакет повреждён (что на практике не случается).
|
||||
|
||||
### Привязка к Windows
|
||||
|
||||
v1 использовала:
|
||||
- `netsh` для смены DNS
|
||||
- Хардкоженный путь к шрифтам Windows
|
||||
- `taskkill` для остановки процессов
|
||||
- `ipconfig /flushdns`
|
||||
|
||||
Ни одна из этих вещей не нужна для WebSocket-прокси. DNS менять не надо — `web.telegram.org` резолвится нормально. Новый интерфейс работает в нативной оболочке Tauri 2 и использует системную типографику. Весь старый платформо-специфичный код был мусором.
|
||||
|
||||
**v2: 0 строк платформо-специфичного кода.** Один и тот же бинарник компилируется на Windows, macOS и Linux без единого `#[cfg(target_os)]`.
|
||||
|
||||
## macOS: почему это важно
|
||||
|
||||
Среди разработчиков, дизайнеров, людей из IT — процент маководов огромный. А инструментов для обхода блокировки Telegram на маке — ноль целых, ноль десятых.
|
||||
|
||||
- **GoodbyeDPI** — Windows only. Даже не обсуждается.
|
||||
- **Zapret** — есть `tpws` для macOS, но это CLI. Нужно: `brew install`, `sudo`, правка конфигов, ручная настройка системного прокси через `networksetup`. Для техничных людей — ОК. Для остальных — нет.
|
||||
- **VPN** — работает, но гонит весь трафик. Для одного Telegram — оверкилл за $5/мес.
|
||||
|
||||
TGLock v2: скачал бинарник, запустил, нажал кнопку. Всё. Никакого `brew`, никакого `sudo`, никаких конфигов.
|
||||
|
||||
Для macOS собирается единое universal-приложение: один пакет работает и на Apple Silicon, и на Intel. Сборка выполняется автоматически в GitHub Actions.
|
||||
|
||||
### Gatekeeper
|
||||
|
||||
Apple блокирует неподписанные приложения. Developer ID стоит $99/год. Для бесплатного open-source — не вариант. Решение стандартное:
|
||||
|
||||
```bash
|
||||
xattr -cr ~/Downloads/tglock-macos-arm64
|
||||
chmod +x ~/Downloads/tglock-macos-arm64
|
||||
```
|
||||
|
||||
Две команды, один раз.
|
||||
|
||||
## LAN-режим: один прокси на всю квартиру
|
||||
|
||||
Это была самая частая просьба в ишью:
|
||||
|
||||
> «Цель: пустить все домашние устройства с Telegram через один такой прокси на компе в локальной сети»
|
||||
|
||||
В v1 прокси слушал `127.0.0.1:1080` — только локально. Устройства в сети не могли подключиться.
|
||||
|
||||
В v2 — чекбокс **LAN** в интерфейсе. Включаешь — прокси биндится на `0.0.0.0`. Все устройства в домашней сети могут использовать прокси.
|
||||
|
||||
```
|
||||
Телефон ──┐
|
||||
Планшет ───┤── SOCKS5 → 192.168.1.42:1080 ──► TGLock ──► WSS → DC
|
||||
Ноутбук ───┘
|
||||
```
|
||||
|
||||
Приложение автоматически определяет LAN IP и показывает его в интерфейсе. На телефоне в настройках Telegram: SOCKS5, адрес — IP компьютера, порт — тот что в приложении.
|
||||
|
||||
Один компьютер. Все устройства. Без VPN, без роутера, без конфигов.
|
||||
|
||||
### Настраиваемый порт
|
||||
|
||||
Ещё один ишью: «порт 1080 занят другим сервисом».
|
||||
|
||||
Теперь порт можно менять прямо в интерфейсе. По умолчанию 1080, но если занят — ставишь любой другой. Порт валидируется при старте, в настройках Telegram автоматически отображается текущий.
|
||||
|
||||
## Архитектура v2
|
||||
|
||||
Два файла. 350 строк. Всё.
|
||||
|
||||
### proxy.rs (~160 строк)
|
||||
|
||||
```
|
||||
TcpListener (0.0.0.0 | 127.0.0.1 : port)
|
||||
│
|
||||
▼
|
||||
SOCKS5 handshake
|
||||
│
|
||||
├── IP ∈ Telegram? ──► read 64-byte init
|
||||
│ │
|
||||
│ ▼
|
||||
│ dc_from_init (AES-256-CTR)
|
||||
│ │
|
||||
│ ▼
|
||||
│ WSS kws{dc}.web.telegram.org
|
||||
│ │
|
||||
│ ▼
|
||||
│ select! { ws ⟷ tcp }
|
||||
│
|
||||
└── IP ∉ Telegram? ──► direct TCP relay
|
||||
```
|
||||
|
||||
Никаких абстракций, traits, generics. Прямолинейный async-код. Каждое соединение — один `tokio::spawn`, один `select!` цикл.
|
||||
|
||||
### main.rs (~190 строк)
|
||||
|
||||
GUI на Tauri 2 с TypeScript-интерфейсом. Настройки и диагностика открываются как внутренние страницы одного окна; статистика в реальном времени показывает активные соединения, WS-туннели, текущий DC и аптайм.
|
||||
|
||||
Кнопка «Настроить автоматически» — открывает Telegram через `tg://socks?server=...&port=...`. Один клик до рабочего Telegram.
|
||||
|
||||
## CI/CD: бинарники для всех
|
||||
|
||||
GitHub Actions при пуше тега `v*` собирает:
|
||||
|
||||
| Файл | Платформа |
|
||||
|---|---|
|
||||
| `tglock.exe` | Windows x64 |
|
||||
| `tglock-macos-arm64` | macOS Apple Silicon |
|
||||
| `tglock-macos-x64` | macOS Intel |
|
||||
| `tglock-linux-x64` | Linux x64 |
|
||||
|
||||
Четыре платформы, один workflow, автоматические релизы. Скачал — запустил — работает.
|
||||
|
||||
```yaml
|
||||
strategy:
|
||||
matrix:
|
||||
include:
|
||||
- os: windows-latest
|
||||
target: x86_64-pc-windows-msvc
|
||||
artifact: tglock.exe
|
||||
- os: macos-latest
|
||||
target: aarch64-apple-darwin
|
||||
artifact: tglock-macos-arm64
|
||||
- os: macos-latest
|
||||
target: x86_64-apple-darwin
|
||||
artifact: tglock-macos-x64
|
||||
- os: ubuntu-latest
|
||||
target: x86_64-unknown-linux-gnu
|
||||
artifact: tglock-linux-x64
|
||||
```
|
||||
|
||||
## Что изменилось: v1 vs v2
|
||||
|
||||
| | v1 | v2 |
|
||||
|---|---|---|
|
||||
| DC detection | IP-маппинг (ненадёжен) | AES-256-CTR из init (точно) |
|
||||
| Ping/Pong | Игнорировался → обрыв через 2 мин | `biased` select → мгновенный Pong |
|
||||
| flush() | Нет → потеря данных | Явный flush после каждого write |
|
||||
| WS timeout | Нет → бесконечное зависание | 10 секунд |
|
||||
| Платформы | Windows | Windows, macOS, Linux |
|
||||
| DNS | Менял системный DNS | Не трогает |
|
||||
| Адаптеры | Определял сетевой адаптер (баг с VMware) | Не определяет, не нужно |
|
||||
| Порт | Хардкод 1080 | Настраиваемый |
|
||||
| LAN | Нет | Чекбокс, 0.0.0.0 |
|
||||
| Файлов | 4 модуля + bat-скрипт | 2 файла |
|
||||
| Строк | ~800 | ~350 |
|
||||
|
||||
Половину кода удалил. Стало стабильнее.
|
||||
|
||||
## Сравнение с альтернативами (2026)
|
||||
|
||||
| | GoodbyeDPI | Zapret | VPN | **TGLock v2** |
|
||||
|---|---|---|---|---|
|
||||
| Подход | Фрагментация | Desync | Туннель | WebSocket |
|
||||
| IP-шейпинг | Не обходит | Не обходит | Обходит | **Обходит** |
|
||||
| macOS | Нет | CLI | Да | **GUI** |
|
||||
| Нужен сервер | Нет | Нет | Да | **Нет** |
|
||||
| Весь трафик | Нет | Нет | Да | **Только Telegram** |
|
||||
| LAN-шаринг | Нет | Можно настроить | Да | **Чекбокс** |
|
||||
| Стоимость | 0₽ | 0₽ | $3–10/мес | **0₽** |
|
||||
|
||||
## Цифры v2
|
||||
|
||||
- **350** строк кода
|
||||
- **2** файла
|
||||
- **4** платформы (Win x64, macOS ARM64, macOS x64, Linux x64)
|
||||
- **0** строк платформо-специфичного кода
|
||||
- **0** серверов
|
||||
- **0₽**
|
||||
|
||||
## Скачать
|
||||
|
||||
**[github.com/by-sonic/tglock](https://github.com/by-sonic/tglock)** → [Releases](https://github.com/by-sonic/tglock/releases/latest)
|
||||
|
||||
Или собрать:
|
||||
|
||||
```bash
|
||||
git clone https://github.com/by-sonic/tglock.git
|
||||
cd tglock
|
||||
cargo build --release
|
||||
```
|
||||
|
||||
macOS: после скачивания `xattr -cr tglock-macos-arm64 && chmod +x tglock-macos-arm64`
|
||||
|
||||
**P.S.** Для полного обхода блокировок (YouTube, Discord, Instagram и всё остальное) — **[RoseVPN](https://t.me/rosevpnru_bot)**.
|
||||
|
||||
---
|
||||
|
||||
*by sonic*
|
||||
|
||||
**Теги:** telegram, rust, websocket, macos, socks5, mtproto, обход блокировок, open-source, кроссплатформенность
|
||||
|
||||
**Хабы:** Rust · Open source · macOS · Сетевые технологии
|
||||
-307
@@ -1,307 +0,0 @@
|
||||
# Как я написал обход блокировки Telegram на Rust — без VPN, без серверов, через WebSocket
|
||||
|
||||
**Простой · 7 мин · Rust · Open source · Windows · Сетевые технологии · Из песочницы**
|
||||
|
||||
**TL;DR:** Написал open-source десктопное приложение **TG Unblock** на Rust, которое в один клик обходит блокировку Telegram через локальный WebSocket-прокси. Трафик заворачивается в обычный HTTPS к `web.telegram.org` — DPI не видит MTProto, провайдер не может шейпить. Без VPN, без серверов, без абонентки. Код на GitHub — [by-sonic/tglock](https://github.com/by-sonic/tglock).
|
||||
|
||||
---
|
||||
|
||||
## Предыстория: почему GoodbyeDPI не спасает
|
||||
|
||||
С весны 2025 года Telegram в России стал работать, мягко говоря, через боль. Сообщения доходят по 10 секунд, медиа не грузятся, звонки рвутся. Классическая картина: провайдер + DPI = страдания.
|
||||
|
||||
Первое, что приходит в голову — **GoodbyeDPI**. Запустил, пакеты фрагментируются, DPI не узнаёт MTProto... и вроде работает. Но:
|
||||
|
||||
- **Пинг 200+ мс** — при норме 40–60
|
||||
- **Постоянные переподключения** — DPI переобучается и режет соединения
|
||||
- **IP-шейпинг** — провайдер троттлит весь трафик к подсетям Telegram (149.154.x.x, 91.108.x.x)
|
||||
|
||||
GoodbyeDPI обманывает DPI на уровне пакетов, но **не решает проблему IP-шейпинга**. Если провайдер тупо режет скорость ко всем IP Telegram — хоть как фрагментируй, будет медленно.
|
||||
|
||||
VPN — вариант. Но:
|
||||
- Платные стоят денег и сливают скорость
|
||||
- Бесплатные сливают данные
|
||||
- Не все работают стабильно
|
||||
- Для одного Telegram гонять весь трафик через VPN — оверкилл
|
||||
|
||||
Нужно решение, которое **маскирует сам факт подключения к Telegram**, а не просто прячет протокол.
|
||||
|
||||
## Идея: WebSocket-туннель через web.telegram.org
|
||||
|
||||
Я провёл серию тестов. Прямое подключение к серверам Telegram (149.154.167.51:443) — либо таймаут, либо 200+ мс. А вот `web.telegram.org` отвечает стабильно за 50–80 мс через HTTPS. Провайдер его не трогает — это же «обычный сайт».
|
||||
|
||||
И тут я полез в [документацию MTProto](https://core.telegram.org/mtproto/transports) и нашёл золотую жилу:
|
||||
|
||||
> **WebSocket:** Implementation of the WebSocket transport is pretty much the same as with TCP... all data received and sent through WebSocket messages is to be treated as a single duplex stream of bytes, just like with TCP.
|
||||
|
||||
Telegram **официально поддерживает WebSocket-транспорт**. Серверы `pluto.web.telegram.org`, `venus.web.telegram.org` и т.д. — это не просто веб-клиент. Это **полноценные точки входа в сеть Telegram** через WSS.
|
||||
|
||||
Схема:
|
||||
|
||||
```
|
||||
Telegram Desktop
|
||||
│
|
||||
▼ SOCKS5
|
||||
┌──────────────────┐
|
||||
│ TG Unblock │ 127.0.0.1:1080
|
||||
│ WS-прокси │
|
||||
└──────┬───────────┘
|
||||
│
|
||||
├── IP Telegram? ──► WSS к {dc}.web.telegram.org/apiws
|
||||
│ (провайдер видит: HTTPS к web.telegram.org)
|
||||
│
|
||||
└── Другой IP? ────► Прямой TCP (без изменений)
|
||||
```
|
||||
|
||||
Провайдер видит:
|
||||
- Соединение к `venus.web.telegram.org` по порту 443
|
||||
- Обычный TLS/HTTPS трафик
|
||||
- Никакого MTProto
|
||||
|
||||
DPI видит:
|
||||
- Ничего подозрительного
|
||||
- Обычный WebSocket внутри HTTPS
|
||||
|
||||
Результат:
|
||||
- **Полная скорость** — провайдер не шейпит web.telegram.org
|
||||
- **Нет переподключений** — DPI не трогает HTTPS
|
||||
- **Нулевая задержка** — нет промежуточных серверов, трафик идёт напрямую к Telegram
|
||||
|
||||
## Реализация: Rust, SOCKS5, WebSocket
|
||||
|
||||
### Почему Rust?
|
||||
|
||||
Не Electron. Не Python. Не Node.js. **Rust.** Потому что:
|
||||
- Один бинарник ~6 МБ, без зависимостей
|
||||
- Нативная скорость — прокси не должен добавлять задержку
|
||||
- Async I/O через tokio — тысячи одновременных соединений
|
||||
- Компилируется, запускается, работает
|
||||
|
||||
### Архитектура
|
||||
|
||||
Приложение состоит из 4 модулей:
|
||||
|
||||
| Модуль | Что делает |
|
||||
|---|---|
|
||||
| `main.rs` | GUI на egui + управление прокси |
|
||||
| `ws_proxy.rs` | SOCKS5-сервер + WebSocket-туннель |
|
||||
| `bypass.rs` | DNS-настройка, системные утилиты |
|
||||
| `network.rs` | Сетевая диагностика |
|
||||
|
||||
### SOCKS5 → WebSocket: как это работает
|
||||
|
||||
Когда Telegram Desktop подключается через SOCKS5-прокси, происходит следующее:
|
||||
|
||||
**1. SOCKS5 handshake**
|
||||
|
||||
```rust
|
||||
// Клиент: [0x05, 0x01, 0x00] — SOCKS5, 1 метод, no auth
|
||||
// Сервер: [0x05, 0x00] — принято
|
||||
// Клиент: [0x05, 0x01, 0x00, 0x01, IP, PORT] — CONNECT к IP:PORT
|
||||
```
|
||||
|
||||
**2. Определение DC по IP**
|
||||
|
||||
Telegram использует фиксированные подсети для каждого Data Center. Из [документации](https://core.telegram.org/mtproto/transports):
|
||||
|
||||
```rust
|
||||
fn telegram_dc(ip: Ipv4Addr) -> Option<u8> {
|
||||
let o = ip.octets();
|
||||
match (o[0], o[1]) {
|
||||
(149, 154) => Some(match o[2] {
|
||||
160..=163 => 1, // DC1
|
||||
164..=167 => 2, // DC2
|
||||
168..=171 => 3, // DC3
|
||||
172..=175 => 1, // DC1 alt
|
||||
_ => 2,
|
||||
}),
|
||||
(91, 108) => Some(match o[2] {
|
||||
56..=59 => 5, // DC5
|
||||
8..=11 => 3, // DC3
|
||||
12..=15 => 4, // DC4
|
||||
_ => 2,
|
||||
}),
|
||||
(91, 105) => Some(2),
|
||||
(185, 76) => Some(2),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**3. WebSocket-туннель**
|
||||
|
||||
Каждый DC имеет именованный WebSocket-эндпоинт (имена из официальной документации Telegram):
|
||||
|
||||
| DC | Имя | URL |
|
||||
|---|---|---|
|
||||
| 1 | Pluto | `wss://pluto.web.telegram.org/apiws` |
|
||||
| 2 | Venus | `wss://venus.web.telegram.org/apiws` |
|
||||
| 3 | Aurora | `wss://aurora.web.telegram.org/apiws` |
|
||||
| 4 | Vesta | `wss://vesta.web.telegram.org/apiws` |
|
||||
| 5 | Flora | `wss://flora.web.telegram.org/apiws` |
|
||||
|
||||
Обязательный заголовок (из доки Telegram): `Sec-WebSocket-Protocol: binary`.
|
||||
|
||||
```rust
|
||||
let mut request = ws_url.as_str().into_client_request()?;
|
||||
request.headers_mut().insert(
|
||||
"Sec-WebSocket-Protocol", "binary".parse()?,
|
||||
);
|
||||
|
||||
let (ws, _) = tokio_tungstenite::connect_async_tls_with_config(
|
||||
request, None, false, Some(connector),
|
||||
).await?;
|
||||
```
|
||||
|
||||
**4. Двунаправленный relay**
|
||||
|
||||
Ключевая цитата из документации Telegram:
|
||||
|
||||
> All data received and sent through WebSocket messages is to be treated as a **single duplex stream of bytes**, just like with TCP.
|
||||
|
||||
Это значит, что нам не нужно парсить MTProto. Просто relay байтов: TCP → WebSocket binary frame, WebSocket binary frame → TCP.
|
||||
|
||||
```rust
|
||||
let up = async {
|
||||
let mut buf = vec![0u8; 32768];
|
||||
loop {
|
||||
match tcp_rx.read(&mut buf).await {
|
||||
Ok(0) => break,
|
||||
Ok(n) => {
|
||||
let msg = Message::Binary(buf[..n].to_vec());
|
||||
if ws_tx.send(msg).await.is_err() { break; }
|
||||
}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
let down = async {
|
||||
while let Some(Ok(msg)) = ws_rx.next().await {
|
||||
if let Message::Binary(data) = msg {
|
||||
if tcp_tx.write_all(&data).await.is_err() { break; }
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
tokio::select! { _ = up => {}, _ = down => {} }
|
||||
```
|
||||
|
||||
### GUI: egui, не Electron
|
||||
|
||||
Нативный GUI через `egui` / `eframe`. Никакого браузера, никакого DOM, никакого JavaScript. Вся отрисовка — immediate mode, 60 FPS.
|
||||
|
||||
Кнопка «Запустить обход» делает:
|
||||
1. Меняет DNS на Cloudflare (1.1.1.1) — обходит DNS-блокировку
|
||||
2. Запускает SOCKS5-прокси на 127.0.0.1:1080
|
||||
3. Предлагает автонастройку Telegram через `tg://socks?server=127.0.0.1&port=1080`
|
||||
|
||||
Кнопка «Настроить автоматически» — открывает Telegram Desktop с готовой конфигурацией прокси. Один клик.
|
||||
|
||||
## Технические детали, которые пришлось решить
|
||||
|
||||
### Проблема 1: Не-Telegram трафик
|
||||
|
||||
Если Telegram Desktop пускает через SOCKS5 не только MTProto, но и запросы к CDN, стикер-серверам, обновлениям — их нельзя заворачивать в WebSocket. Решение: проверяем IP по маппингу Telegram-подсетей. Telegram IP → WebSocket. Всё остальное → прямой TCP passthrough.
|
||||
|
||||
### Проблема 2: Определение DC
|
||||
|
||||
Telegram Desktop использует obfuscated2 транспорт. Первые 64 байта — зашифрованный хендшейк, в котором закодирован DC ID. Парсить его — целый проект.
|
||||
|
||||
Решение проще: определяем DC по destination IP. Telegram использует фиксированные подсети для каждого DC — маппинг стабильный и документированный.
|
||||
|
||||
### Проблема 3: TLS к WebSocket-эндпоинтам
|
||||
|
||||
WebSocket-соединение идёт через WSS (TLS). Используем `native-tls` — системные сертификаты Windows, без привязки к OpenSSL.
|
||||
|
||||
```rust
|
||||
let connector = tokio_tungstenite::Connector::NativeTls(
|
||||
native_tls::TlsConnector::new()?,
|
||||
);
|
||||
```
|
||||
|
||||
### Проблема 4: Graceful shutdown
|
||||
|
||||
При остановке прокси нужно:
|
||||
- Сбросить DNS обратно на DHCP
|
||||
- Корректно закрыть все WebSocket-соединения
|
||||
- Не оставить Telegram без связи
|
||||
|
||||
Используем `AtomicBool` для флага остановки — все задачи проверяют его и завершаются.
|
||||
|
||||
## Сравнение с альтернативами
|
||||
|
||||
| | GoodbyeDPI | Zapret | VPN | **TG Unblock** |
|
||||
|---|---|---|---|---|
|
||||
| Подход | Фрагментация пакетов | Desync пакетов | Туннель через сервер | WebSocket-туннель |
|
||||
| DPI видит MTProto? | Нет | Нет | Нет | **Нет** |
|
||||
| IP-шейпинг? | Не обходит | Не обходит | Обходит | **Обходит** |
|
||||
| Нужен сервер? | Нет | Нет | Да | **Нет** |
|
||||
| Скорость | Зависит от DPI | Зависит от DPI | Зависит от сервера | **Полная** |
|
||||
| Весь трафик? | Нет | Нет | Да | **Только Telegram** |
|
||||
| Стоимость | Бесплатно | Бесплатно | $3–10/мес | **Бесплатно** |
|
||||
|
||||
## Стек
|
||||
|
||||
| Технология | Зачем |
|
||||
|---|---|
|
||||
| **Rust** | Скорость, один бинарник, без зависимостей |
|
||||
| **egui / eframe** | Нативный GUI без браузера |
|
||||
| **tokio** | Async I/O, тысячи соединений |
|
||||
| **tokio-tungstenite** | WebSocket-клиент с TLS |
|
||||
| **native-tls** | Системные сертификаты Windows |
|
||||
| **GitHub Actions** | CI/CD — автобилд при новом теге |
|
||||
|
||||
## Цифры
|
||||
|
||||
- **5 DC** — полный маппинг всех Telegram Data Center
|
||||
- **1 бинарник** — ~6 МБ, без зависимостей
|
||||
- **0 серверов** — всё работает локально
|
||||
- **0₽** — полностью бесплатно и open-source
|
||||
- **1 клик** — от запуска до работающего Telegram
|
||||
|
||||
## Как попробовать
|
||||
|
||||
### Скачать готовый .exe
|
||||
|
||||
1. Скачайте `tg_unblock.exe` из [Releases](https://github.com/by-sonic/tglock/releases)
|
||||
2. Запустите (желательно от администратора — для DNS)
|
||||
3. Нажмите **«Запустить обход»**
|
||||
4. Нажмите **«Настроить автоматически»**
|
||||
5. В Telegram нажмите «Подключить»
|
||||
|
||||
### Собрать из исходников
|
||||
|
||||
```bash
|
||||
git clone https://github.com/by-sonic/tglock.git
|
||||
cd tglock
|
||||
cargo build --release
|
||||
# Бинарник: target/release/tg_unblock.exe
|
||||
```
|
||||
|
||||
## Что дальше
|
||||
|
||||
- **Автоопределение DC из obfuscated2** — парсинг первых 64 байт для точного маппинга
|
||||
- **Fallback на GoodbyeDPI** — если WebSocket-эндпоинт недоступен
|
||||
- **Linux / macOS** — porability через tokio + egui (уже почти готово)
|
||||
- **Статистика** — скорость, задержка, количество туннелей в реальном времени
|
||||
|
||||
## Вместо заключения
|
||||
|
||||
Telegram — это не просто мессенджер. Для миллионов людей это рабочий инструмент, канал связи, источник информации. Когда он работает через боль — страдают все.
|
||||
|
||||
GoodbyeDPI — отличный инструмент, но у него есть потолок. Когда DPI побеждён, а трафик всё равно шейпится — нужен другой подход. WebSocket-туннель через `web.telegram.org` — это как проехать мимо камеры на легальной машине вместо того, чтобы заклеивать номера.
|
||||
|
||||
Код полностью открыт. Если пригодился — поставьте звезду на GitHub. Если нашли баг — PR приветствуются.
|
||||
|
||||
**GitHub:** [github.com/by-sonic/tglock](https://github.com/by-sonic/tglock)
|
||||
|
||||
**P.S.** Если нужен полный обход блокировок для всех приложений (YouTube, Discord, Instagram и др.) — попробуйте [by sonic VPN](https://t.me/bysonicvpn_bot). Быстрый, стабильный, без ограничений скорости.
|
||||
|
||||
---
|
||||
|
||||
*by sonic*
|
||||
|
||||
**Теги:** telegram, dpi bypass, websocket, rust, socks5, mtproto, обход блокировок, open-source
|
||||
|
||||
**Хабы:** Rust · Open source · Windows · Сетевые технологии
|
||||
@@ -1,159 +1,482 @@
|
||||
<!-- ════════════════════════ ROSEVPN — sponsor ════════════════════════ -->
|
||||
|
||||
<p align="center">
|
||||
<h1 align="center">TG Unblock</h1>
|
||||
<p align="center">
|
||||
<b>Обход блокировки Telegram через WebSocket-туннель</b><br>
|
||||
Без VPN. Без серверов. Без абонентки. Один клик.
|
||||
</p>
|
||||
<p align="center">
|
||||
<a href="https://github.com/by-sonic/tglock/releases"><img src="https://img.shields.io/github/v/release/by-sonic/tglock?style=for-the-badge&color=blue" alt="Release"></a>
|
||||
<a href="https://github.com/by-sonic/tglock/blob/main/LICENSE"><img src="https://img.shields.io/github/license/by-sonic/tglock?style=for-the-badge" alt="License"></a>
|
||||
<a href="https://github.com/by-sonic/tglock/stargazers"><img src="https://img.shields.io/github/stars/by-sonic/tglock?style=for-the-badge&color=yellow" alt="Stars"></a>
|
||||
<img src="https://img.shields.io/badge/rust-1.70%2B-orange?style=for-the-badge&logo=rust" alt="Rust">
|
||||
<img src="https://img.shields.io/badge/platform-Windows-0078D6?style=for-the-badge&logo=windows" alt="Windows">
|
||||
</p>
|
||||
<a href="https://t.me/rosevpnru_bot">
|
||||
<img src="https://img.shields.io/badge/%F0%9F%8C%B9%20RoseVPN-%D0%9F%D0%BE%D0%BF%D1%80%D0%BE%D0%B1%D0%BE%D0%B2%D0%B0%D1%82%D1%8C%20%D0%B1%D0%B5%D1%81%D0%BF%D0%BB%D0%B0%D1%82%D0%BD%D0%BE-E63946?style=for-the-badge&logo=telegram&logoColor=white&labelColor=0a0a0a" height="44" alt="RoseVPN — попробовать бесплатно в Telegram"/>
|
||||
</a>
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<b>Быстрый VPN для России</b> — YouTube без буферизации, Discord/Instagram/ChatGPT снова работают.<br/>
|
||||
<sub>Подключение в Telegram через <a href="https://t.me/rosevpnru_bot"><b>@rosevpnru_bot</b></a> — бесплатный пробный период, без регистрации, без карты.</sub>
|
||||
</p>
|
||||
|
||||
<p align="center">
|
||||
<a href="https://t.me/rosevpnru_bot"><img alt="YouTube — без буферов" src="https://img.shields.io/badge/YouTube-%D0%B1%D0%B5%D0%B7%20%D0%B1%D1%83%D1%84%D0%B5%D1%80%D0%BE%D0%B2-E63946?style=flat-square&logo=youtube&logoColor=white"></a>
|
||||
<a href="https://t.me/rosevpnru_bot"><img alt="Discord — голос работает" src="https://img.shields.io/badge/Discord-%D0%B3%D0%BE%D0%BB%D0%BE%D1%81%20%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B0%D0%B5%D1%82-E63946?style=flat-square&logo=discord&logoColor=white"></a>
|
||||
<a href="https://t.me/rosevpnru_bot"><img alt="Instagram — открывается" src="https://img.shields.io/badge/Instagram-%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D0%B2%D0%B0%D0%B5%D1%82%D1%81%D1%8F-E63946?style=flat-square&logo=instagram&logoColor=white"></a>
|
||||
<a href="https://t.me/rosevpnru_bot"><img alt="ChatGPT — доступен" src="https://img.shields.io/badge/ChatGPT-%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%B5%D0%BD-E63946?style=flat-square&logo=openai&logoColor=white"></a>
|
||||
</p>
|
||||
|
||||
---
|
||||
|
||||
## Что это?
|
||||
<!-- ═════════════════════════════ TGLOCK ═════════════════════════════ -->
|
||||
|
||||
**TG Unblock** — десктопное приложение на Rust, которое обходит блокировку Telegram через локальный WebSocket-прокси. Провайдер видит обычный HTTPS к `web.telegram.org`, а не MTProto — DPI не может обнаружить и заблокировать трафик.
|
||||
<div align="center">
|
||||
|
||||
### Почему не GoodbyeDPI / Zapret?
|
||||
# 🔓 TGLock
|
||||
|
||||
| | GoodbyeDPI | Zapret | **TG Unblock** |
|
||||
|---|---|---|---|
|
||||
| Метод | Фрагментация пакетов | Desync пакетов | WebSocket-туннель |
|
||||
| DPI видит MTProto? | Нет (обфускация) | Нет (desync) | **Нет (обычный HTTPS)** |
|
||||
| IP-шейпинг обходит? | Нет | Нет | **Да** |
|
||||
| Скорость | Зависит от DPI | Зависит от DPI | **Полная** |
|
||||
| Переподключения | Возможны | Возможны | **Нет** |
|
||||
| Настройка | Много параметров | Стратегии | **Один клик** |
|
||||
### Обход блокировки Telegram через WebSocket-туннель
|
||||
|
||||
## Скачать
|
||||
**Один клик. Без VPN. Без серверов. Без подписки.**
|
||||
|
||||
> **[Скачать последний релиз](https://github.com/by-sonic/tglock/releases)**
|
||||
<p>
|
||||
<a href="https://github.com/by-sonic/tglock/releases/latest"><img alt="Скачать последний релиз" src="https://img.shields.io/github/v/release/by-sonic/tglock?style=for-the-badge&color=2ea043&label=%D1%81%D0%BA%D0%B0%D1%87%D0%B0%D1%82%D1%8C"></a>
|
||||
<a href="https://github.com/by-sonic/tglock/releases"><img alt="Всего загрузок" src="https://img.shields.io/github/downloads/by-sonic/tglock/total?style=for-the-badge&color=0969da&label=%D0%B7%D0%B0%D0%B3%D1%80%D1%83%D0%B7%D0%BE%D0%BA"></a>
|
||||
<a href="https://github.com/by-sonic/tglock/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/by-sonic/tglock?style=for-the-badge&color=f5a623"></a>
|
||||
</p>
|
||||
|
||||
Или собрать из исходников:
|
||||
<p>
|
||||
<img alt="Windows" src="https://img.shields.io/badge/Windows-0078D6?style=flat&logo=windows&logoColor=white">
|
||||
<img alt="macOS" src="https://img.shields.io/badge/macOS-000000?style=flat&logo=apple&logoColor=white">
|
||||
<img alt="Linux" src="https://img.shields.io/badge/Linux-FCC624?style=flat&logo=linux&logoColor=black">
|
||||
<img alt="Rust" src="https://img.shields.io/badge/Rust-CE422B?style=flat&logo=rust&logoColor=white">
|
||||
<a href="LICENSE"><img alt="MIT License" src="https://img.shields.io/github/license/by-sonic/tglock?style=flat&color=lightgrey"></a>
|
||||
</p>
|
||||
|
||||
</div>
|
||||
|
||||
> **Telegram стал тормозить или перестал открываться?** Запусти TGLock — и мессенджер снова работает. Не нужны VPN, прокси-серверы, абонентская плата или регистрация.
|
||||
|
||||
<p align="center">
|
||||
<img src="docs/assets/tglock-v2-main.jpeg" width="420" alt="Новый интерфейс TGLock"/>
|
||||
</p>
|
||||
|
||||
---
|
||||
|
||||
## 🤔 Что это и зачем
|
||||
|
||||
TGLock — это **локальный прокси** на твоём компьютере: принимает и MTProto, и SOCKS5. Он перехватывает соединения Telegram, заворачивает их в WebSocket и отправляет на веб-инфраструктуру Telegram — по нескольким маршрутам сразу, переключаясь на следующий, если текущий перестал отвечать. Провайдер видит обычный HTTPS.
|
||||
|
||||
**Кому подойдёт:**
|
||||
|
||||
- 📱 Telegram открывается через раз, сообщения уходят с задержкой, фото и видео не грузятся
|
||||
- 🛡 GoodbyeDPI, Zapret или ByeDPI больше не помогают — провайдер шейпит **по IP**
|
||||
- 🍎 Нужен графический интерфейс под **macOS**
|
||||
- 💻 Нужно решение для **Windows, macOS или Linux** без подписок и без своего сервера
|
||||
- 🖥 Нужен вариант **для сервера или машины без монитора** — для этого есть [`tglock-cli`](#-без-графического-интерфейса-tglock-cli)
|
||||
|
||||
**Чего TGLock не делает** — честно, чтобы не тратить твоё время:
|
||||
|
||||
- ❌ **Голосовые и видеозвонки.** Они идут по UDP, а TGLock проксирует только TCP. Со звонками ничего не изменится
|
||||
- ❌ **Всё, кроме Telegram.** YouTube, Discord, Instagram, ChatGPT работать не начнут: TGLock разворачивает только MTProto — протокол, который больше нигде не используется
|
||||
- ❌ **Android и iOS.** Своего приложения нет. Телефон можно подключить к TGLock на компьютере через [LAN-режим](#-lan-режим--один-прокси-на-всю-квартиру)
|
||||
|
||||
**Чем отличается от VPN:** TGLock работает **только с Telegram**. Остальной трафик идёт напрямую — ничего не замедляется, мобильный трафик не расходуется впустую.
|
||||
|
||||
---
|
||||
|
||||
## ⚡ Скачать
|
||||
|
||||
**[👉 Последний релиз](https://github.com/by-sonic/tglock/releases/latest)**
|
||||
|
||||
| Платформа | Файл |
|
||||
|---|---|
|
||||
| **Windows 10/11** (x64) | `_x64-setup.exe` |
|
||||
| **macOS** (Apple Silicon + Intel) | universal `.dmg` |
|
||||
| **Linux** (x86_64) | `.deb` |
|
||||
| **Linux** (x86_64, портативно) | `.AppImage` |
|
||||
| **Сервер, контейнер, машина без монитора** | `tglock-cli-*` |
|
||||
|
||||
Все сборки весят единицы мегабайт. Исключение — `.AppImage`: он несёт своё окружение и поэтому крупный.
|
||||
|
||||
> **🖥 `tglock-cli`** — тот же туннель без графического интерфейса, одним бинарём. Нужен там, где окно не создаётся: сервер, контейнер, виртуалка, машина без монитора. Доступен начиная с `v2.0.0-beta.2`. Если ты скачал beta.2 и приложение не открывалось — это была ошибка сборки, исправлено в beta.3. Подробности — [ниже](#-без-графического-интерфейса-tglock-cli).
|
||||
|
||||
### 🛡 Антивирус ругается, SmartScreen предупреждает, VirusTotal показывает детекты
|
||||
|
||||
Так и будет. Объясню механизм и дам способы проверить, не доверяя мне на слово.
|
||||
|
||||
**Что ты увидишь.** На Windows — «Система Windows защитила ваш компьютер» от SmartScreen. На VirusTotal — детекты у части движков, обычно единицы из примерно шестидесяти.
|
||||
|
||||
**Почему.** Складываются две вещи. Установщик не подписан сертификатом, а неподписанные файлы проверяются эвристиками гораздо строже, чем подписанные. И само поведение программы — открыть локальный порт, объявить себя прокси-сервером, прописаться в настройки соединения Telegram — это ровно тот профиль, по которому эвристики ищут прокси-трояны. Программа делает именно это, только по твоей просьбе. Отличить одно от другого автоматически движок не может, поэтому и реагирует.
|
||||
|
||||
**Подписи не будет.** Сертификат — это ежегодный платёж, а проект бесплатный и ничего не зарабатывает. Значит предупреждение останется, и делать вид, что «скоро подпишем», я не буду.
|
||||
|
||||
**Как проверить вместо доверия.** Три способа, все не требуют верить мне:
|
||||
|
||||
1. **Сверить контрольную сумму.** GitHub публикует `sha256` каждого файла прямо на [странице релиза](https://github.com/by-sonic/tglock/releases/latest) — разверни `Assets` и увидишь digest рядом с именем. Сравни с тем, что скачалось:
|
||||
|
||||
```powershell
|
||||
Get-FileHash .\TGLock_<версия>_x64-setup.exe -Algorithm SHA256
|
||||
```
|
||||
|
||||
```bash
|
||||
sha256sum tglock-cli-x86_64-unknown-linux-gnu # Linux
|
||||
shasum -a 256 tglock-cli-universal-apple-darwin # macOS
|
||||
```
|
||||
|
||||
Это доказывает, что файл не подменили по пути к тебе.
|
||||
|
||||
2. **Посмотреть, как файл собирался.** Бинарники собирает GitHub Actions из публичного коммита, лог открыт и его никто не может отредактировать задним числом. У каждого релиза на странице Actions есть свой запуск: видно, какой коммит взят и какими командами собран. Ссылка на него — в описании релиза.
|
||||
|
||||
3. **Собрать самому.** Для CLI это одна команда и никаких зависимостей кроме Rust:
|
||||
|
||||
```bash
|
||||
cargo build --release --locked --no-default-features --features cli --bin tglock-cli
|
||||
```
|
||||
|
||||
Полная сборка с интерфейсом — [ниже](#-сборка-из-исходников).
|
||||
|
||||
**Если этого недостаточно — не запускай.** Это нормальное решение, а не паранойя: исполняемый файл из интернета без подписи заслуживает недоверия по умолчанию. Собери из исходников или возьми [tg-ws-proxy](https://github.com/Flowseal/tg-ws-proxy) — он решает ту же задачу и тоже открыт.
|
||||
|
||||
> **🍎 macOS:** пока сборка не нотарифицирована Apple, при первом запуске может понадобиться:
|
||||
> ```bash
|
||||
> xattr -cr /Applications/TGLock.app
|
||||
> ```
|
||||
> Это снимает карантин Gatekeeper с приложения, скачанного из GitHub.
|
||||
|
||||
---
|
||||
|
||||
## 🚀 Как пользоваться
|
||||
|
||||
1. **Скачай и запусти** приложение для своей системы.
|
||||
2. Нажми **«Включить защиту»**.
|
||||
3. TGLock откроет Telegram и предложит подключить локальный MTProto-прокси.
|
||||
4. ✅ **Telegram работает.** Окно TGLock можно свернуть.
|
||||
|
||||
### Ручная настройка (если автоматическая не сработала)
|
||||
|
||||
Telegram → Настройки → **Продвинутые** → Тип соединения → **Использовать прокси** → **SOCKS5**
|
||||
|
||||
- Сервер: `127.0.0.1`
|
||||
- Порт: `1080`
|
||||
|
||||
### 🏠 LAN-режим — один прокси на всю квартиру
|
||||
|
||||
В окне TGLock включи галочку **LAN** — приложение начнёт слушать на `0.0.0.0`. Все устройства в домашней сети (телефон, планшет, ноутбук, телевизор) смогут подключиться к `<IP-компьютера>:1080` и тоже получить рабочий Telegram.
|
||||
|
||||
Ссылку `tg://proxy` с уже подставленным адресом TGLock открывает сам при включении — её достаточно переслать себе в Telegram и открыть на телефоне. Если нужен адрес руками: `ipconfig` на Windows, `ip a` на Linux, `ifconfig` на macOS.
|
||||
|
||||
Удобно, если дома один компьютер всегда включён — он становится «домашним Telegram-роутером».
|
||||
|
||||
В LAN-режиме TGLock пропускает **только адреса Telegram**. Открытым SOCKS5-прокси для всего интернета он при этом не становится — иначе им бы воспользовались не только твои устройства.
|
||||
|
||||
### 🖥 Без графического интерфейса: `tglock-cli`
|
||||
|
||||
Для сервера, виртуалки, контейнера и машины без монитора или без 3D-ускорения. Это отдельный бинарь, в котором **нет ни Tauri, ни системного WebView** — там, где окно просто не создаётся, CLI работает.
|
||||
|
||||
```bash
|
||||
tglock-cli # 127.0.0.1:1080, только для этого компьютера
|
||||
tglock-cli --lan # 0.0.0.0:1080, только адреса Telegram
|
||||
tglock-cli --bind 10.0.0.5 --port 1443 # свой адрес и порт
|
||||
tglock-cli --worker my-name.workers.dev # резервный маршрут, см. docs/CLOUDFLARE_WORKER.md
|
||||
tglock-cli --help # все флаги
|
||||
```
|
||||
|
||||
При запуске печатается готовая `tg://proxy`-ссылка — её можно открыть на любом устройстве в сети, чтобы Telegram настроился сам. Дальше в лог идёт по строке на каждое изменение состояния: сколько соединений, какой дата-центр, какой маршрут живой, сколько сбоев.
|
||||
|
||||
Прав администратора не нужно: TGLock не правит ни системный DNS, ни файл `hosts` — нужные адреса Telegram зашиты в маршрутах, а TLS SNI остаётся настоящим.
|
||||
|
||||
`--lan` и любой другой сетевой адрес пропускают **только** адреса Telegram. Обычным SOCKS5-прокси TGLock становится исключительно по явному `--allow-direct`, и на сетевом адресе это открытый прокси для всего интернета — включайте осознанно.
|
||||
|
||||
#### Юнит для systemd
|
||||
|
||||
```ini
|
||||
[Unit]
|
||||
Description=TGLock — Telegram через WebSocket-туннель
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=exec
|
||||
ExecStart=/usr/local/bin/tglock-cli --lan --secret-file /var/lib/tglock/secret
|
||||
Restart=on-failure
|
||||
RestartSec=5s
|
||||
StateDirectory=tglock
|
||||
DynamicUser=yes
|
||||
NoNewPrivileges=yes
|
||||
ProtectSystem=strict
|
||||
ProtectHome=yes
|
||||
PrivateTmp=yes
|
||||
RestrictAddressFamilies=AF_INET AF_INET6
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
```
|
||||
|
||||
```bash
|
||||
sudo install -m755 tglock-cli-x86_64-unknown-linux-gnu /usr/local/bin/tglock-cli
|
||||
sudo systemctl enable --now tglock
|
||||
journalctl -u tglock -f
|
||||
```
|
||||
|
||||
`--secret-file` здесь обязателен, и это не украшение: секрет — половина `tg://proxy`-ссылки. Без файла он генерируется заново при каждом старте, и после первого же `systemctl restart` все настроенные клиенты перестанут подключаться. `StateDirectory=tglock` создаёт `/var/lib/tglock` с нужными правами, а сам файл пишется с режимом `600`.
|
||||
|
||||
Остановка по `systemctl stop` приходит как `SIGTERM` — CLI закрывает туннели и выходит с нулевым кодом, а не умирает по `SIGKILL`.
|
||||
|
||||
#### Docker
|
||||
|
||||
```dockerfile
|
||||
FROM rust:1.88 AS build
|
||||
WORKDIR /src
|
||||
COPY . .
|
||||
RUN cargo build --release --locked --no-default-features --features cli --bin tglock-cli
|
||||
|
||||
FROM debian:bookworm-slim
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends ca-certificates \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
COPY --from=build /src/target/release/tglock-cli /usr/local/bin/tglock-cli
|
||||
EXPOSE 1080
|
||||
ENTRYPOINT ["tglock-cli", "--lan", "--secret-file", "/data/secret"]
|
||||
```
|
||||
|
||||
```bash
|
||||
docker run -d --name tglock -p 1080:1080 -v tglock-data:/data tglock
|
||||
```
|
||||
|
||||
Образу не нужны ни Node.js, ни `libwebkit2gtk` — только `ca-certificates` для проверки сертификата Telegram.
|
||||
|
||||
---
|
||||
|
||||
## 🔬 Как это работает
|
||||
|
||||
```
|
||||
Telegram Desktop / mobile (через LAN)
|
||||
▼
|
||||
MTProto или SOCKS5 (127.0.0.1:1080 либо 0.0.0.0:1080)
|
||||
▼
|
||||
TGLock — читает первые 64 байта
|
||||
obfuscated2 init-пакета,
|
||||
расшифровывает AES-256-CTR,
|
||||
достаёт номер DC
|
||||
▼
|
||||
WSS → kws{dc}.web.telegram.org
|
||||
каскад маршрутов, см. ниже
|
||||
▼
|
||||
Telegram Data Center
|
||||
```
|
||||
|
||||
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 в браузере.
|
||||
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-рукопожатие уже прошло. Смешивание первого и третьего состояния и было основной причиной жалоб «прокси подключён, а 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) — цифры там описывают код на момент написания, документацией он не является.
|
||||
|
||||
---
|
||||
|
||||
## 🆚 Сравнение с альтернативами
|
||||
|
||||
| | GoodbyeDPI | Zapret | AmneziaVPN | **TGLock** |
|
||||
|---|:---:|:---:|:---:|:---:|
|
||||
| Подход | Фрагментация пакетов | TCP/UDP desync | Полноценный VPN-туннель | **WebSocket-туннель** |
|
||||
| Обходит IP-шейпинг | ❌ | ❌ | ✅ | **✅** |
|
||||
| macOS (GUI) | ❌ Windows only | ❌ только CLI | ✅ | **✅** |
|
||||
| Нужен сервер / подписка | ❌ | ❌ | ✅ ($) | **❌** |
|
||||
| Только Telegram | ❌ | ❌ | ❌ | **✅** |
|
||||
| LAN-шаринг | ❌ | сложно | ✅ | **✅ (галочка)** |
|
||||
| Режим без GUI | ✅ | ✅ | ❌ | **✅ (`tglock-cli`)** |
|
||||
| Размер | ~200 КБ | ~5 МБ | ~80 МБ | **2 МБ установщик, 2 МБ CLI** |
|
||||
| Цена | 0 ₽ | 0 ₽ | свой сервер | **0 ₽** |
|
||||
|
||||
> **⚠ Когда TGLock не подойдёт:** если заблокирован не только Telegram, а ещё YouTube, Discord, Instagram или ChatGPT — обходить каждый сервис отдельно смысла нет, нужен полноценный VPN. TGLock эту задачу не решает и решать не будет: он разворачивает только MTProto.
|
||||
>
|
||||
> Звонки тоже не заработают — они по UDP, а TGLock проксирует только TCP.
|
||||
|
||||
---
|
||||
|
||||
## ❓ Часто задаваемые вопросы
|
||||
|
||||
<details>
|
||||
<summary><b>Telegram заблокировали в России — это правда?</b></summary>
|
||||
|
||||
Полностью Telegram в РФ не заблокирован, но провайдеры **замедляют** трафик через DPI и **шейпят по IP-диапазонам** Telegram DC (149.154.160–175, 91.108.4–8, 91.108.56–59 и др.). У части пользователей мессенджер открывается через раз, видео не грузится, фото уходят минутами.
|
||||
|
||||
TGLock решает именно это — заворачивает Telegram-трафик в HTTPS к веб-инфраструктуре Telegram, которая под шейпинг не попадает. **Голосовые и видеозвонки он не лечит:** они идут по UDP, а TGLock проксирует только TCP.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Это безопасно? Что с моими данными?</b></summary>
|
||||
|
||||
TGLock — **локальный прокси**. Он работает только на твоём компьютере и не отправляет данные третьим сторонам. Соединение идёт к серверам Telegram через их же домен `web.telegram.org` — тот же, что использует Telegram Web в браузере. Единственное исключение — если ты сам укажешь в настройках свой Cloudflare Worker как резервный маршрут; по умолчанию это поле пустое, и никакой сторонней инфраструктуры в схеме нет.
|
||||
|
||||
Кода — около 2900 строк Rust (из них ~1100 приходится на тесты) и ~380 строк TypeScript на интерфейс. Всё открыто, можно прочитать и собрать самому. Бинарники в релизах собираются из этого же исходника в GitHub Actions — логи сборки публичные.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Чем отличается от GoodbyeDPI / Zapret / ByeDPI?</b></summary>
|
||||
|
||||
GoodbyeDPI, Zapret и ByeDPI **фрагментируют пакеты**, чтобы DPI не распознал MTProto. Это работает, пока провайдер блокирует *по содержимому*. Но если шейпинг идёт **по IP** (а так делают большинство крупных РФ-провайдеров с 2024–2026 — Ростелеком, МТС, Билайн, Мегафон), фрагментация не помогает: пакеты всё равно идут на «нехороший» IP и троттлятся.
|
||||
|
||||
TGLock же отправляет трафик на **`web.telegram.org`** — обычный HTTPS-домен, который под IP-шейпинг Telegram DC не попадает.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Работает ли на iPhone или Android?</b></summary>
|
||||
|
||||
Своего приложения под 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), сроков нет: Tauri 2 умеет собирать под Android, но перехват трафика там делается через `VpnService` — это другая архитектура, а не пересборка того же кода.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Замедляет ли TGLock интернет?</b></summary>
|
||||
|
||||
Нет. Через прокси идёт **только** трафик Telegram (фильтрация по IP-диапазонам Telegram DC). YouTube, браузер, игры, торренты — всё это идёт напрямую и не замедляется. В этом главное отличие от VPN.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Apple ругается «приложение не проверено / нельзя открыть»</b></summary>
|
||||
|
||||
Сборка пока не подписана и не нотарифицирована — Apple Developer ID стоит $99 в год. Сними карантин Gatekeeper руками: перенеси приложение из `.dmg` в «Программы» и выполни в Терминале
|
||||
|
||||
```bash
|
||||
xattr -cr /Applications/TGLock.app
|
||||
```
|
||||
|
||||
После этого приложение запустится двойным кликом из Finder.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Telegram пишет «прокси не настроен» или сразу отключается</b></summary>
|
||||
|
||||
Открой TGLock — он должен показывать **«ПОДКЛЮЧЕНО»** и хотя бы одно активное соединение, когда Telegram пытается работать. Если соединений ноль:
|
||||
|
||||
- Не запущен ли уже другой прокси на порту 1080? В TGLock можно поменять порт в настройках.
|
||||
- Антивирус/файрвол не блокирует localhost-подключения?
|
||||
- В настройках Telegram сервер указан как `127.0.0.1`, не `localhost` — на некоторых системах это разные сетевые стеки.
|
||||
- На macOS — убедись что снят Gatekeeper (`xattr -cr ...`).
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Приложение вообще не запускается — окно не появляется</b></summary>
|
||||
|
||||
Так проявляется отсутствие 3D-ускорения: интерфейс построен на системном WebView, а тот без ускорения окно не создаёт. Отсюда же случаи «не работает в виртуалке», «не стартует с дефолтным драйвером Microsoft» и «нет монитора».
|
||||
|
||||
Начиная с **2.0.0-beta.2** TGLock сам просит у WebView программный рендер, так что на таких машинах должен запускаться. Если хочется вернуть аппаратное ускорение — запусти с переменной `TGLOCK_FORCE_GPU=1`.
|
||||
|
||||
Если окно всё равно не появилось, интерфейс тебе и не нужен: возьми [`tglock-cli`](#-без-графического-интерфейса-tglock-cli), которому WebView не требуется вообще. И напиши в [#10](https://github.com/by-sonic/tglock/issues/10) или [#17](https://github.com/by-sonic/tglock/issues/17), что именно за система — это как раз те ишью.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Порт 1080 уже занят другим приложением</b></summary>
|
||||
|
||||
В окне TGLock есть поле **«Порт»** — поменяй на любой свободный (например, `10800`, `1081`, `8888`). После рестарта прокси автоматически обновит deep-link для Telegram. В настройках Telegram укажи новый порт.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>А что если провайдер заблокирует и <code>web.telegram.org</code>?</b></summary>
|
||||
|
||||
Это реальный риск, и TGLock 2.0 к нему подготовлен настолько, насколько может.
|
||||
|
||||
Маршрут не один: пробуются закреплённые IP Telegram, дублёры `kwsN-1` и системный DNS. Пока жив хотя бы один — туннель поднимается.
|
||||
|
||||
Если у твоего провайдера легли **все** маршруты, есть запасной выход — **свой Cloudflare Worker**. Тогда соединение идёт на твой домен `*.workers.dev`, а воркер доводит его до Telegram; блокировать его провайдеру придётся отдельно. Готовый скрипт и пошаговая установка: **[docs/CLOUDFLARE_WORKER.md](docs/CLOUDFLARE_WORKER.md)**. Нужен только аккаунт Cloudflare, бесплатного тарифа хватает, свой сервер и домен не нужны.
|
||||
|
||||
Признак, что пора это делать: приложение показывает «Ищем новый маршрут» и не проходит, а в диагностике туннелей 0 и растёт счётчик сбоев. Если Telegram работает — настраивать ничего не надо.
|
||||
|
||||
Но честно: если веб-версию Telegram заблокируют так, что её не видно и из датацентров Cloudflare, подход исчерпает себя. TGLock держится на доступности `web.telegram.org`, и никакой запас маршрутов этого не отменяет.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Можно ли использовать TGLock как обычный SOCKS5 для других приложений?</b></summary>
|
||||
|
||||
Смысла нет, и по умолчанию это запрещено.
|
||||
|
||||
TGLock определяет Telegram по IP получателя и заворачивает в WebSocket только его. Не-Telegram адреса он релеит напрямую — без шифрования, то есть никакой пользы для обхода в этом нет.
|
||||
|
||||
Поэтому такой релей разрешён **только когда прокси слушает `127.0.0.1`**, где до него дотянутся лишь процессы твоего компьютера. На `0.0.0.0` и любом сетевом адресе не-Telegram запросы отклоняются: иначе LAN-режим сделал бы из твоей машины открытый прокси для всего интернета. В `tglock-cli` это можно переопределить флагом `--allow-direct` — но на сетевом адресе ты получишь именно открытый SOCKS5, так что делай это осознанно.
|
||||
</details>
|
||||
|
||||
<details>
|
||||
<summary><b>Где скачать новые версии? Будут ли обновления?</b></summary>
|
||||
|
||||
Все релизы — на странице **[GitHub Releases](https://github.com/by-sonic/tglock/releases)**. При пуше тега `v*` GitHub Actions собирает и публикует установщики под Windows x64, macOS (universal) и Linux x64, плюс headless `tglock-cli` под те же три платформы. Подпишись на репозиторий (кнопка **Watch** → **Custom** → **Releases**), чтобы получать уведомления.
|
||||
</details>
|
||||
|
||||
---
|
||||
|
||||
## 🛠 Стек технологий
|
||||
|
||||
| Технология | Зачем |
|
||||
|---|---|
|
||||
| **Rust** | Один бинарник, нативная скорость, без runtime-зависимостей |
|
||||
| **Tauri 2** | Нативная оболочка для GUI. Опциональна: за фичей `gui`, в CLI не входит |
|
||||
| **TypeScript + Vite** | Интерфейс, внутренняя навигация и строгая типизация |
|
||||
| **tokio** | Async I/O, обработка сигналов для корректной остановки сервиса |
|
||||
| **tokio-tungstenite** | WebSocket-клиент с TLS поверх `native-tls` |
|
||||
| **aes** + **ctr** | Расшифровка MTProto `obfuscated2` init-пакета |
|
||||
| **clap** | Разбор аргументов `tglock-cli` |
|
||||
|
||||
Ядро (`src/lib.rs`: разбор MTProto, каскад маршрутов, прокси) не зависит ни от Tauri, ни от оконной системы — поэтому один и тот же код обслуживает и графический интерфейс, и headless-режим.
|
||||
|
||||
---
|
||||
|
||||
## 🏗 Сборка из исходников
|
||||
|
||||
```bash
|
||||
git clone https://github.com/by-sonic/tglock.git
|
||||
cd tglock
|
||||
cargo build --release
|
||||
npm ci
|
||||
npm run tauri build
|
||||
```
|
||||
|
||||
Готовый `.exe` будет в `target/release/tg_unblock.exe`.
|
||||
Результат — `target/release/tglock` (или `tglock.exe` на Windows).
|
||||
|
||||
## Как пользоваться
|
||||
Минимальная версия Rust — **1.88** (`rust-version` в `Cargo.toml`, проверяется отдельной задачей в CI). На более старых тулчейнах зависимости не соберутся: часть из них требует edition 2024.
|
||||
|
||||
1. Запустите `tg_unblock.exe`
|
||||
2. Нажмите **"Запустить обход"**
|
||||
3. Нажмите **"Настроить автоматически"** — откроется Telegram, нажмите "Подключить"
|
||||
4. Готово. Telegram работает на полной скорости.
|
||||
### Только CLI, без графики
|
||||
|
||||
### Ручная настройка прокси
|
||||
|
||||
Если автонастройка не сработала:
|
||||
|
||||
**Telegram Desktop** → Настройки → Продвинутые → Тип соединения → **Использовать SOCKS5-прокси**
|
||||
|
||||
| Параметр | Значение |
|
||||
|---|---|
|
||||
| Сервер | `127.0.0.1` |
|
||||
| Порт | `1080` |
|
||||
| Логин | *пусто* |
|
||||
| Пароль | *пусто* |
|
||||
|
||||
## Как это работает
|
||||
|
||||
```
|
||||
Telegram Desktop
|
||||
│
|
||||
▼ (SOCKS5)
|
||||
┌──────────────────┐
|
||||
│ TG Unblock │ 127.0.0.1:1080
|
||||
│ WS-прокси │
|
||||
└──────┬───────────┘
|
||||
│
|
||||
▼ (определяет DC по IP)
|
||||
│
|
||||
├── Telegram IP? ──► WSS-туннель к {dc}.web.telegram.org/apiws
|
||||
│ (провайдер видит обычный HTTPS)
|
||||
│
|
||||
└── Другой IP? ────► Прямое TCP-соединение (без изменений)
|
||||
```bash
|
||||
cargo build --release --locked --no-default-features --features cli --bin tglock-cli
|
||||
```
|
||||
|
||||
### DC-маппинг
|
||||
Ни Node.js, ни фронтенда, ни `libwebkit2gtk` для этого не нужно — при выключенной фиче `gui` Tauri и системный WebView в сборку не попадают вообще. Именно так CLI собирается на голом сервере.
|
||||
|
||||
Приложение автоматически определяет Data Center по IP-адресу и маршрутизирует через правильный WebSocket-эндпоинт:
|
||||
### Проверки, которые гоняет CI
|
||||
|
||||
| DC | Подсеть | WebSocket |
|
||||
|---|---|---|
|
||||
| DC1 | `149.154.160.0/22` | `wss://pluto.web.telegram.org/apiws` |
|
||||
| DC2 | `149.154.164.0/22` | `wss://venus.web.telegram.org/apiws` |
|
||||
| DC3 | `149.154.168.0/22` | `wss://aurora.web.telegram.org/apiws` |
|
||||
| DC4 | `91.108.12.0/22` | `wss://vesta.web.telegram.org/apiws` |
|
||||
| DC5 | `91.108.56.0/22` | `wss://flora.web.telegram.org/apiws` |
|
||||
|
||||
Имена DC (`pluto`, `venus`, `aurora`, `vesta`, `flora`) — из [официальной документации MTProto](https://core.telegram.org/mtproto/transports).
|
||||
|
||||
## Стек
|
||||
|
||||
| Что | Зачем |
|
||||
|---|---|
|
||||
| **Rust** | Скорость, безопасность, один бинарник без зависимостей |
|
||||
| **egui / eframe** | Нативный GUI без Electron, без браузера |
|
||||
| **tokio** | Async I/O для высокопроизводительного проксирования |
|
||||
| **tokio-tungstenite** | WebSocket-клиент с TLS |
|
||||
| **native-tls** | TLS через системные сертификаты Windows |
|
||||
|
||||
## Структура проекта
|
||||
|
||||
```
|
||||
tglock/
|
||||
├── Cargo.toml # Зависимости
|
||||
├── src/
|
||||
│ ├── main.rs # GUI + управление прокси
|
||||
│ ├── ws_proxy.rs # SOCKS5-сервер + WebSocket-туннель
|
||||
│ ├── bypass.rs # DNS-настройка, утилиты Windows
|
||||
│ └── network.rs # Сетевая диагностика
|
||||
└── tg_blacklist.txt # IP-подсети и домены Telegram
|
||||
```bash
|
||||
cargo fmt --check
|
||||
cargo clippy --all-targets -- -D warnings
|
||||
cargo clippy --no-default-features --features cli --all-targets -- -D warnings
|
||||
cargo test --all-targets
|
||||
cargo test --no-default-features --features cli --lib --bins
|
||||
```
|
||||
|
||||
## Требования
|
||||
Тестов 59: разбор `obfuscated2`, каскад маршрутов и его cooldown, протокольные отказы SOCKS5, устойчивость секрета к перезапуску, плюс сквозной тест туннеля против мок-сервера, который реализует сторону Telegram и проверяет, что до неё доходит ровно тот открытый текст, который отправил клиент. Единственный тест с пометкой `#[ignore]` — тот, что требует живой сети.
|
||||
|
||||
- Windows 10/11
|
||||
- [Rust 1.70+](https://rustup.rs/) (для сборки из исходников)
|
||||
- Права администратора (для смены DNS, опционально)
|
||||
### Свой релиз через GitHub Actions
|
||||
|
||||
## FAQ
|
||||
Форкни репозиторий и поставь тег `v*` — `.github/workflows/release.yml` соберёт установщики под Windows x64, macOS (universal, Apple Silicon + Intel) и Linux x64, а также `tglock-cli` под те же три платформы, и опубликует их в релизе.
|
||||
|
||||
**Q: Это VPN?**
|
||||
A: Нет. Трафик не идёт через сторонние серверы. Прокси работает локально и туннелирует только Telegram-трафик через WebSocket к официальным серверам Telegram.
|
||||
---
|
||||
|
||||
**Q: Это безопасно?**
|
||||
A: Весь код открыт. Никакой телеметрии. Никаких данных не отправляется. Соединение с Telegram остаётся end-to-end зашифрованным (MTProto).
|
||||
## 🤝 Как помочь
|
||||
|
||||
**Q: Будет ли работать с мобильным Telegram?**
|
||||
A: Пока только Telegram Desktop. Для мобильных устройств рекомендуем [by sonic VPN](https://t.me/bysonicvpn_bot).
|
||||
Проект живой, PR и баг-репорты разбираются.
|
||||
|
||||
**Q: Замедляется ли интернет?**
|
||||
A: Нет. Проксируется только трафик к серверам Telegram. Весь остальной трафик идёт напрямую.
|
||||
- **Нашёл баг** — [открой issue](https://github.com/by-sonic/tglock/issues/new). Полезнее всего: ОС и версия, что показывает вкладка диагностики (маршрут, DC, число сбоев) и провайдер. Для `tglock-cli` — вывод из консоли.
|
||||
- **Хочешь фичу** — тоже issue. Если её нет в планах, так и будет написано, без месяцев тишины.
|
||||
- **Присылаешь PR** — перед отправкой прогони проверки выше, они те же, что в CI. Небольшие PR ревьюятся быстрее.
|
||||
- **Не работает после релиза** — это регрессия, пиши сразу, такие вещи в приоритете.
|
||||
|
||||
## VPN для полного обхода
|
||||
Известные ограничения, о которых не нужно открывать issue: звонки (UDP), сервисы кроме Telegram (только MTProto), Android и iOS (обсуждается в [#9](https://github.com/by-sonic/tglock/issues/9)).
|
||||
|
||||
Если нужен обход блокировок для **всех** приложений (YouTube, Discord, Instagram и др.) — попробуйте **[by sonic VPN](https://t.me/bysonicvpn_bot)**. Быстрый, без ограничений скорости.
|
||||
---
|
||||
|
||||
## Лицензия
|
||||
## 📄 Лицензия
|
||||
|
||||
MIT — делайте что хотите.
|
||||
|
||||
## Автор
|
||||
|
||||
**by sonic** — [@bysonicvpn_bot](https://t.me/bysonicvpn_bot)
|
||||
[MIT](LICENSE) — делай что хочешь. Форки, модификации, использование в коммерческих проектах — всё разрешено. Ссылка на репозиторий приветствуется, но необязательна.
|
||||
|
||||
---
|
||||
|
||||
<p align="center">
|
||||
<b>Если пригодилось — поставьте ⭐ на GitHub</b>
|
||||
<sub><b>by sonic</b> · <a href="https://github.com/by-sonic/tglock/issues">Issues & feedback</a> · <a href="https://github.com/by-sonic/tglock/releases">Releases</a></sub>
|
||||
</p>
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
fn main() {
|
||||
// Only the GUI binary needs Tauri's generated context. Without this guard a
|
||||
// headless build would still require the frontend bundle and the WebView
|
||||
// toolchain to be present.
|
||||
#[cfg(feature = "gui")]
|
||||
tauri_build::build();
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"$schema": "../gen/schemas/desktop-schema.json",
|
||||
"identifier": "default",
|
||||
"description": "TGLock desktop window",
|
||||
"windows": ["main"],
|
||||
"permissions": ["core:default"]
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
# TGLock 2.0 architecture
|
||||
|
||||
## Сборка: ядро, GUI и headless
|
||||
|
||||
Крейт собирается в библиотеку и два бинаря:
|
||||
|
||||
- `src/lib.rs` — ядро: `mtproto`, `transport`, `proxy`, `config`. Не зависит ни
|
||||
от Tauri, ни от оконной системы;
|
||||
- `src/main.rs` — GUI, доступен только при включённой фиче `gui`
|
||||
(`required-features`);
|
||||
- `src/bin/cli.rs` — headless `tglock-cli`.
|
||||
|
||||
Фича `gui` включена по умолчанию и подтягивает `tauri`, `tauri-build` и `open`.
|
||||
При `--no-default-features` ни Tauri, ни системный WebView, ни фронтенд в сборку
|
||||
не попадают, и `build.rs` не вызывает `tauri_build`. Так TGLock собирается и
|
||||
работает там, где WebView недоступен в принципе: сервер без графического
|
||||
окружения, контейнер, машина без монитора. Для случаев, где WebView есть, но нет
|
||||
3D-ускорения, GUI дополнительно просит программный рендер — см. Current
|
||||
limitations.
|
||||
|
||||
## Local protocols
|
||||
|
||||
Один TCP-порт автоматически принимает два типа клиентов:
|
||||
|
||||
- MTProto proxy с постоянным 16-байтовым secret — основной режим;
|
||||
- SOCKS5 без авторизации — режим совместимости.
|
||||
|
||||
MTProto init проверяется по secret и transport tag. Из него извлекаются DC,
|
||||
признак media-соединения и тип транспорта. Для upstream создаётся новый
|
||||
стандартный obfuscated2 init, а последующий поток пере-шифровывается между
|
||||
локальным secret и Telegram.
|
||||
|
||||
### Различение протоколов
|
||||
|
||||
Определять протокол по первому байту нельзя. SOCKS5-приветствие начинается с
|
||||
`0x05`, но MTProto init — это 64 случайных байта, и `is_reserved_init`
|
||||
исключает только `0xef`, `0xee`, `0xdd`, HTTP-глаголы и заголовок TLS-записи.
|
||||
Значение `0x05` попадается примерно в одном init из 256, и такое соединение
|
||||
уходило в SOCKS5-ветку и умирало — снаружи это выглядит как «Telegram
|
||||
отправляет сообщения через раз».
|
||||
|
||||
Поэтому неоднозначный первый байт разрешается так: не потребляя данные,
|
||||
ожидается полный 64-байтовый init и делается попытка разобрать его под текущим
|
||||
secret. Успешный разбор означает MTProto. Настоящий SOCKS5-клиент присылает
|
||||
короткое приветствие и блокируется на ответе, поэтому 64 байта у него не
|
||||
появятся и по истечении короткого таймаута он корректно уходит в SOCKS5-ветку.
|
||||
|
||||
## Политика прямого релея
|
||||
|
||||
Не-Telegram адреса релеятся напрямую, без шифрования, и пользы для обхода в
|
||||
этом нет. Поэтому такой релей разрешён только когда прокси слушает loopback,
|
||||
где до него дотягиваются лишь локальные процессы. На `0.0.0.0` и любом другом
|
||||
сетевом адресе не-Telegram запросы отклоняются кодом SOCKS5 `0x02`, иначе
|
||||
LAN-режим превращал бы машину в открытый прокси. Правило выражено в типе
|
||||
`config::ListenConfig`, а не в условиях по месту вызова; переопределяется
|
||||
только явным `--allow-direct` в CLI.
|
||||
|
||||
## Учёт состояния
|
||||
|
||||
`Stats::ws` считает **установленные** туннели: счётчик поднимается после
|
||||
успешного `transport.connect`, а не перед попыткой. Иначе интерфейс
|
||||
рапортовал бы «Telegram на связи», пока рукопожатие ещё перебирает маршруты по
|
||||
несколько секунд каждый. Состояния «порт открыт», «идёт перебор маршрутов» и
|
||||
«туннель установлен» различимы и в GUI, и в выводе CLI.
|
||||
|
||||
Секрет прокси — половина ссылки `tg://proxy`. Для сервиса его нужно закрепить
|
||||
файлом (`--secret-file`): под `DynamicUser` и `ProtectHome` домашней папки нет,
|
||||
путь по умолчанию не определяется, и секрет генерировался бы заново при каждом
|
||||
старте, отключая всех уже настроенных клиентов.
|
||||
|
||||
## Transport cascade
|
||||
|
||||
Для каждого DC и отдельно для media-соединений строится список маршрутов:
|
||||
|
||||
1. сохранённый успешный маршрут;
|
||||
2. точный Telegram IP с `kwsN` или `kwsN-1` в TLS SNI и WebSocket Host;
|
||||
3. дополнительный Telegram IP, если он определён;
|
||||
4. системный DNS;
|
||||
5. явно настроенный пользователем Cloudflare Worker.
|
||||
|
||||
Поддерживаются DC1–5 и media/CDN DC203. DC203 использует WebSocket-host DC2,
|
||||
но подключается к собственному IP.
|
||||
|
||||
После ошибки маршрут получает exponential cooldown от 30 секунд до 30 минут.
|
||||
Успешный маршрут становится первым для следующего соединения того же DC и
|
||||
типа трафика.
|
||||
|
||||
## TLS policy
|
||||
|
||||
Проверка сертификатов и hostname никогда не отключается. При подключении к
|
||||
заданному Telegram IP TCP destination отделён от URI host: TLS продолжает
|
||||
проверять сертификат настоящего `kws*.web.telegram.org`.
|
||||
|
||||
Cloudflare Worker принимается только как пользовательская настройка. TGLock
|
||||
не загружает и не скрывает публичные списки чужих доменов.
|
||||
|
||||
## Cloudflare Worker contract
|
||||
|
||||
Worker должен принимать WebSocket на:
|
||||
|
||||
```text
|
||||
/apiws?dst=<telegram-ip>&dc=<dc-id>
|
||||
```
|
||||
|
||||
и проксировать бинарные frames в TCP `<telegram-ip>:443`. Рекомендуется
|
||||
добавить собственную авторизацию до стабильного релиза; поэтому Worker
|
||||
остаётся расширенной опцией alpha-версии.
|
||||
|
||||
## Current limitations
|
||||
|
||||
- SNI camouflage не включена: небезопасное отключение hostname verification
|
||||
из референсной реализации не переносится.
|
||||
- Голосовые звонки по UDP не поддерживаются.
|
||||
- **GUI зависит от WebView, а тот — от 3D-ускорения.** Начиная с
|
||||
2.0.0-beta.2 приложение перед стартом Tauri само просит программный рендер:
|
||||
на Windows через `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS`, на Linux через
|
||||
`WEBKIT_DISABLE_COMPOSITING_MODE` и `WEBKIT_DISABLE_DMABUF_RENDERER`. Уже
|
||||
заданные оператором значения не перезаписываются, а `TGLOCK_FORCE_GPU=1`
|
||||
возвращает аппаратное ускорение. Для машин без монитора остаётся
|
||||
`tglock-cli`, которому WebView не нужен вовсе (issues #10, #17).
|
||||
- Windows-инсталлятор не подписан, macOS-сборка не нотарифицирована, и
|
||||
подписывать их не планируется: сертификат — ежегодный платёж, а проект
|
||||
бесплатный. Часть антивирусов будет реагировать на неподписанный установщик,
|
||||
который открывает локальный сокет и прописывается прокси-сервером — это тот
|
||||
же профиль, по которому ищут прокси-трояны. Вместо доверия предлагаются
|
||||
проверяемые пути: `sha256` каждого артефакта публикуется GitHub на странице
|
||||
релиза, сборка идёт в GitHub Actions из публичного коммита с открытым логом,
|
||||
CLI собирается одной командой. Подробно — в разделе README про антивирус.
|
||||
- Работоспособность медиа зависит от конкретного DC аккаунта и доступности
|
||||
Telegram/Cloudflare у провайдера.
|
||||
- Пулы заранее открытых WebSocket-соединений будут добавлены после измерения,
|
||||
что они не создают лишнюю нагрузку и не ухудшают стабильность.
|
||||
@@ -0,0 +1,86 @@
|
||||
# Резервный маршрут через свой Cloudflare Worker
|
||||
|
||||
## Когда это нужно
|
||||
|
||||
Только в одном случае: провайдер заблокировал саму веб-инфраструктуру Telegram, и **все** обычные маршруты TGLock перестали отвечать.
|
||||
|
||||
Как это выглядит в приложении:
|
||||
|
||||
| Что видно | Что это значит | Нужен ли Worker |
|
||||
|---|---|---|
|
||||
| «Telegram на связи» | туннель работает | нет |
|
||||
| «Ищем новый маршрут» и не проходит | маршруты перебираются и все падают | **да** |
|
||||
| «Защита включена», DC не определяется | Telegram ещё не подключался | нет, открой Telegram |
|
||||
| В диагностике счётчик сбоев растёт, туннелей 0 | ни один маршрут не отвечает | **да** |
|
||||
|
||||
В CLI то же самое видно в строке статуса: `туннелей 0 · DC не определён · сбоев 14`.
|
||||
|
||||
Если Telegram работает — **ничего настраивать не надо.** Поле Worker в настройках существует для случая, когда обычные маршруты умерли.
|
||||
|
||||
Обрати внимание: Worker не спасает, если Telegram недоступен *с самого воркера*. Он помогает, когда домены Telegram заблокированы **у тебя**, а датацентры Cloudflare до них дотягиваются.
|
||||
|
||||
## Что понадобится
|
||||
|
||||
- аккаунт Cloudflare (бесплатного тарифа достаточно);
|
||||
- 10 минут.
|
||||
|
||||
Ни своего сервера, ни домена, ни карты не нужно — воркер получит адрес вида `имя.твой-логин.workers.dev`.
|
||||
|
||||
## Установка через веб-интерфейс
|
||||
|
||||
1. Зайди на [dash.cloudflare.com](https://dash.cloudflare.com) → **Workers & Pages** → **Create application** → **Create Worker**.
|
||||
2. Дай имя, например `tglock`. Нажми **Deploy** — сначала задеплоится заготовка, это нормально.
|
||||
3. Нажми **Edit code**.
|
||||
4. Удали всё содержимое редактора и вставь файл [`worker/tglock-worker.js`](../worker/tglock-worker.js) из этого репозитория целиком.
|
||||
5. **Deploy**.
|
||||
6. Скопируй адрес воркера. Он показан сверху и выглядит как `tglock.имя.workers.dev` — **без** `https://` и без пути.
|
||||
|
||||
### Проверка, что воркер жив
|
||||
|
||||
Открой в браузере `https://tglock.имя.workers.dev/apiws`. Должно вернуться `expected a websocket upgrade` — это правильный ответ: значит код развёрнут и работает, просто браузер пришёл обычным запросом.
|
||||
|
||||
Если вернулось `not found` — проверь, что путь именно `/apiws`. Если ошибка про `cloudflare:sockets` — у воркера слишком старая дата совместимости, поставь в **Settings → Compatibility date** сегодняшнюю.
|
||||
|
||||
## Подключение в TGLock
|
||||
|
||||
**В приложении:** Настройки → поле **Cloudflare Worker** → вставь `tglock.имя.workers.dev` → Сохранить. Настройки меняются только при выключенной защите.
|
||||
|
||||
**В CLI:** флаг `--worker`, можно повторять:
|
||||
|
||||
```bash
|
||||
tglock-cli --worker tglock.имя.workers.dev
|
||||
tglock-cli --worker первый.workers.dev --worker второй.workers.dev
|
||||
```
|
||||
|
||||
Worker всегда пробуется **последним**, после всех маршрутов Telegram. Пока обычные маршруты живы, трафик через него не пойдёт, и это осознанно: чужая инфраструктура в цепочке — это лишнее звено, а не улучшение.
|
||||
|
||||
## Ограничение доступа
|
||||
|
||||
Адрес воркера сам по себе секрет, но лучше поставить токен: **Settings → Variables → Add variable**, имя `TGLOCK_TOKEN`, значение — любая длинная строка.
|
||||
|
||||
Пока переменная не задана, проверка токена выключена. Когда задана — воркер начнёт отвечать `403` без параметра `?token=`. Клиент TGLock этот параметр пока не отправляет, так что включать токен есть смысл, если ты правишь и сам скрипт, и адрес.
|
||||
|
||||
Независимо от токена воркер соединяется **только** с семью адресами Telegram, которые запрашивает TGLock. Любой другой `dst` получает `403`, так что открытым TCP-прокси он не станет.
|
||||
|
||||
## Контракт
|
||||
|
||||
Если захочешь написать свою реализацию — вот что именно делает клиент (`src/transport.rs`):
|
||||
|
||||
```text
|
||||
wss://<домен>/apiws?dst=<telegram-ip>&dc=<номер-dc>
|
||||
Sec-WebSocket-Protocol: binary
|
||||
```
|
||||
|
||||
- `dst` — адрес Telegram, к которому нужно подключиться по TCP на порт 443;
|
||||
- `dc` — номер датацентра, для логов;
|
||||
- **подпротокол `binary` обязательно нужно подтвердить в ответе** — без этого клиент разорвёт рукопожатие;
|
||||
- дальше бинарные frames пересылаются в обе стороны без изменений;
|
||||
- TLS до самого воркера обеспечивает Cloudflare.
|
||||
|
||||
Список допустимых `dst` совпадает с `transport::worker_allowed_destinations()`.
|
||||
|
||||
## Честно про проверку
|
||||
|
||||
Скрипт написан по контракту, вычитанному из исходников клиента, и путь с параметрами закреплён тестом `connects_through_the_documented_worker_contract` — он поднимает локальный сервер, который ведёт себя ровно так, как описано выше, и проверяет, что туннель через него поднимается и данные доходят в обе стороны.
|
||||
|
||||
Чего этот тест не проверяет: развёрнутый воркер в самом Cloudflare. Если что-то не сойдётся с их API — [открой issue](https://github.com/by-sonic/tglock/issues/new), поправлю.
|
||||
@@ -0,0 +1,89 @@
|
||||
# TGLock 2.0 issue audit
|
||||
|
||||
Проверено 29 июля 2026 года: все 15 issues и 5 pull requests, существовавшие
|
||||
в репозитории на момент аудита.
|
||||
|
||||
> **Статус на 30 июля 2026.** Аудит ниже оставлен как есть — это фиксация
|
||||
> состояния на дату проверки. Что с тех пор сделано:
|
||||
>
|
||||
> - Разобраны все issues и pull requests. Открытых PR не осталось.
|
||||
> - Закрыты #1–#5, #8, #11, #13, #14, #19, #23 и #3 — с техническими
|
||||
> объяснениями в самих issues.
|
||||
> - #15 реализован заново поверх архитектуры 2.0 в #25: смерджить исходный PR
|
||||
> было нельзя, он патчил `bypass.rs`, `network.rs` и `ws_proxy.rs`, которых
|
||||
> больше нет, и правил системный DNS. Взято разделение GUI/CLI и произвольный
|
||||
> bind-адрес; DNS-менеджмент и проверка root отброшены как ненужные.
|
||||
> - #12 закрыт: относился к шрифту старого egui-интерфейса.
|
||||
> - #10 и #17 закрыты выпуском `v2.0.0-beta.2`: GUI перед стартом просит у
|
||||
> WebView программный рендер. Проверить это на машине без 3D-ускорения
|
||||
> возможности не было, поэтому закрыто как «исправление выпущено», а не
|
||||
> «исправлено» — репортерам предложено переоткрыть, если проблема осталась.
|
||||
> Независимо от WebView работает `tglock-cli`.
|
||||
> - #21 закрыт: репорт относился к сборке macOS, которой больше нет, в
|
||||
> `v2.0.0-beta.2` она пересобрана универсальным `.dmg`.
|
||||
> - #9 (Android) остаётся единственным открытым — backlog без сроков.
|
||||
>
|
||||
> Претензия из публичного обсуждения, которую нельзя закрыть кодом: инсталлятор
|
||||
> не подписан, из-за чего часть антивирусов на него реагирует. Решение принято
|
||||
> и зафиксировано: подписи не будет, сертификат — ежегодный платёж, а проект
|
||||
> бесплатный. Вместо неё в README описан механизм срабатывания и три
|
||||
> проверяемых пути — сверка `sha256` с публикуемым GitHub digest, открытый лог
|
||||
> сборки в Actions и сборка из исходников одной командой.
|
||||
>
|
||||
> Дополнительно исправлено то, чего в issues не было: коллизия MTProto-init с
|
||||
> байтом `0x05` (одно соединение из 256 уходило в SOCKS5-ветку и умирало),
|
||||
> подсчёт туннеля до успешного рукопожатия, неверные подписи маршрутов в
|
||||
> интерфейсе и генерация нового секрета при каждом старте сервиса. Подробности —
|
||||
> в [ARCHITECTURE_V2.md](ARCHITECTURE_V2.md).
|
||||
>
|
||||
> Из списка «не подтверждённых обещаний» в конце документа закрыты все четыре
|
||||
> пункта: формулировки про звонки и про «Подключено» приведены в соответствие с
|
||||
> кодом, LAN-режим ограничен адресами Telegram на уровне типа, Cloudflare Worker
|
||||
> остаётся исключительно пользовательской настройкой.
|
||||
|
||||
## Выводы
|
||||
|
||||
Главная причина жалоб «прокси подключён, но Telegram не работает» — приложение
|
||||
считало успешный запуск локального SOCKS5-сервера успешным подключением к
|
||||
Telegram. Единственный upstream `kws{dc}.web.telegram.org` может резолвиться в
|
||||
недоступный IP или блокироваться провайдером.
|
||||
|
||||
TGLock 2.0 разделяет эти состояния и использует адаптивный список Telegram IP,
|
||||
`kwsN`/`kwsN-1`, системный DNS и опциональный пользовательский Cloudflare
|
||||
Worker. TLS SNI и WebSocket Host проверяются. Системный DNS и файл `hosts`
|
||||
не изменяются.
|
||||
|
||||
## Классификация
|
||||
|
||||
| Issue | Наблюдение | Решение для 2.0 |
|
||||
|---|---|---|
|
||||
| #1 | Порт 1080 занят | Уже есть выбор порта; добавить автоматический подбор |
|
||||
| #2, #11 | Неверный сетевой адаптер | В переписанном Rust-ядре привязка исходящего адаптера отсутствует; добавить только как расширенную настройку |
|
||||
| #3 | Rust 1.75 не собирает зависимости | `Cargo.lock` зафиксирован; MSRV 1.88 документирована и проверяется в CI |
|
||||
| #4 | Linux/серверный режим | Добавить headless CLI и systemd/Docker-примеры |
|
||||
| #5 | macOS | Публиковать universal `.app`, затем подписанный и notarized DMG |
|
||||
| #8, #19, #21, #23 | Нет подключения | Резервные маршруты, live-probe, понятная диагностика вместо ложного «Подключено» |
|
||||
| #9 | Android | Не входит в desktop 2.0; LAN остаётся отдельным сценарием |
|
||||
| #10, #17 | GUI не запускается без GPU/монитора | Headless CLI; отдельно проверить software rendering |
|
||||
| #13 | Discord/YouTube | Вне области проекта; не смешивать с Telegram-транспортом |
|
||||
| #14 | Медиа, звонки, LAN | Медиа тестировать отдельно; звонки не обещать без UDP; LAN ограничить Telegram-адресами |
|
||||
|
||||
## Pull requests
|
||||
|
||||
- #6 относится к старой Windows-реализации выбора адаптера.
|
||||
- #12 относился к шрифту старого GUI. В v2 интерфейс перенесён на Tauri 2 и
|
||||
использует системную типографику каждой платформы.
|
||||
- #15 содержит полезное направление разделения GUI/CLI, но основан на старой
|
||||
архитектуре и меняет DNS системы.
|
||||
- #18 — экспериментальный Linux GUI без подтверждённого мобильного сценария.
|
||||
- #7 не содержит продуктового изменения.
|
||||
|
||||
## Не подтверждённые обещания
|
||||
|
||||
- Голосовые и видеозвонки нельзя заявлять рабочими: SOCKS5 UDP Associate не
|
||||
реализован, а Telegram может обходить proxy для части звонков.
|
||||
- «Подключено» допустимо показывать только после успешного WebSocket handshake,
|
||||
а не после открытия локального порта.
|
||||
- LAN-режим не должен становиться открытым универсальным SOCKS5-прокси.
|
||||
- Резерв через чужую Cloudflare-инфраструктуру нельзя включать без ясной модели
|
||||
доверия, владельца, мониторинга и политики обновления endpoint-ов.
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 42 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 40 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 35 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 2.0 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 5.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 11 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 40 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 1.8 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 45 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.0 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 6.1 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 8.3 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.5 KiB |
Binary file not shown.
Binary file not shown.
|
After Width: | Height: | Size: 50 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 85 KiB |
@@ -0,0 +1,28 @@
|
||||
<svg xmlns="http://www.w3.org/2000/svg" width="1024" height="1024" viewBox="0 0 1024 1024">
|
||||
<defs>
|
||||
<linearGradient id="background" x1="150" y1="100" x2="850" y2="930" gradientUnits="userSpaceOnUse">
|
||||
<stop stop-color="#263247"/>
|
||||
<stop offset="0.45" stop-color="#0C1422"/>
|
||||
<stop offset="1" stop-color="#06090F"/>
|
||||
</linearGradient>
|
||||
<linearGradient id="orb" x1="320" y1="260" x2="710" y2="760" gradientUnits="userSpaceOnUse">
|
||||
<stop stop-color="#55BBFF"/>
|
||||
<stop offset="0.48" stop-color="#168EFA"/>
|
||||
<stop offset="1" stop-color="#0756B0"/>
|
||||
</linearGradient>
|
||||
<radialGradient id="glow">
|
||||
<stop stop-color="#38A9FF" stop-opacity=".5"/>
|
||||
<stop offset="1" stop-color="#147AD6" stop-opacity="0"/>
|
||||
</radialGradient>
|
||||
<filter id="shadow" x="-30%" y="-30%" width="160%" height="160%">
|
||||
<feGaussianBlur stdDeviation="28"/>
|
||||
</filter>
|
||||
</defs>
|
||||
<rect x="28" y="28" width="968" height="968" rx="224" fill="url(#background)"/>
|
||||
<rect x="42" y="42" width="940" height="940" rx="210" fill="none" stroke="#FFFFFF" stroke-opacity=".08" stroke-width="4"/>
|
||||
<circle cx="512" cy="512" r="330" fill="url(#glow)" filter="url(#shadow)"/>
|
||||
<circle cx="512" cy="512" r="268" fill="none" stroke="#4AAFFF" stroke-opacity=".15" stroke-width="5"/>
|
||||
<circle cx="512" cy="512" r="220" fill="url(#orb)"/>
|
||||
<circle cx="512" cy="512" r="218" fill="none" stroke="#A5D9FF" stroke-opacity=".58" stroke-width="5"/>
|
||||
<path fill="#fff" d="M690 358 338 494c-24 10-24 22-5 28l90 28 35 107c4 12 3 17 15 17 9 0 13-4 19-10l44-42 92 68c17 10 29 5 33-16l61-285c6-25-10-36-32-31ZM454 544l176-111c9-6 17-2 10 3L496 568l-6 59-36-83Z"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 1.6 KiB |
+13
@@ -0,0 +1,13 @@
|
||||
<!doctype html>
|
||||
<html lang="ru">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<meta name="theme-color" content="#070a10" />
|
||||
<title>TGLock</title>
|
||||
</head>
|
||||
<body>
|
||||
<div id="app"></div>
|
||||
<script type="module" src="/ui/main.ts"></script>
|
||||
</body>
|
||||
</html>
|
||||
Generated
+1350
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"name": "tglock-ui",
|
||||
"private": true,
|
||||
"version": "2.0.0-beta.4",
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"dev": "vite --port 1420",
|
||||
"build": "tsc && vite build",
|
||||
"preview": "vite preview",
|
||||
"tauri": "tauri"
|
||||
},
|
||||
"dependencies": {
|
||||
"@tauri-apps/api": "^2.8.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@tauri-apps/cli": "^2.8.0",
|
||||
"typescript": "^5.8.3",
|
||||
"vite": "^6.2.6"
|
||||
}
|
||||
}
|
||||
+333
@@ -0,0 +1,333 @@
|
||||
//! TGLock without a graphical interface.
|
||||
//!
|
||||
//! Built with `--no-default-features` this binary links neither Tauri nor a
|
||||
//! system WebView, so it runs on servers, in containers and on machines with no
|
||||
//! GPU or monitor — the cases that make the GUI fail to start at all
|
||||
//! (by-sonic/tglock#10, by-sonic/tglock#17).
|
||||
|
||||
use clap::Parser;
|
||||
use std::net::IpAddr;
|
||||
use std::path::PathBuf;
|
||||
use std::process::ExitCode;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
use tglock::config::ListenConfig;
|
||||
use tglock::{mtproto, proxy, transport};
|
||||
|
||||
const STATUS_POLL: Duration = Duration::from_secs(1);
|
||||
|
||||
#[derive(Debug, Parser)]
|
||||
#[command(
|
||||
name = "tglock-cli",
|
||||
version,
|
||||
about = "TGLock без графического интерфейса: локальный MTProto-прокси через WebSocket"
|
||||
)]
|
||||
struct Args {
|
||||
/// Адрес для прослушивания. 127.0.0.1 — только этот компьютер
|
||||
#[arg(short, long, value_name = "IP", default_value = "127.0.0.1")]
|
||||
bind: IpAddr,
|
||||
|
||||
/// Порт локального прокси
|
||||
#[arg(short, long, value_name = "PORT", default_value_t = proxy::DEFAULT_PORT)]
|
||||
port: u16,
|
||||
|
||||
/// То же, что --bind 0.0.0.0: доступ с других устройств в локальной сети
|
||||
#[arg(long, conflicts_with = "bind")]
|
||||
lan: bool,
|
||||
|
||||
/// Домен своего Cloudflare Worker как резервный маршрут. Можно повторять
|
||||
#[arg(long, value_name = "DOMAIN")]
|
||||
worker: Vec<String>,
|
||||
|
||||
/// Проксировать и не-Telegram адреса. На сетевом адресе это открытый SOCKS5
|
||||
#[arg(long)]
|
||||
allow_direct: bool,
|
||||
|
||||
/// Файл с секретом прокси. Обязателен для сервиса: иначе после перезапуска
|
||||
/// секрет будет новым и уже настроенные клиенты перестанут подключаться
|
||||
#[arg(long, value_name = "PATH")]
|
||||
secret_file: Option<PathBuf>,
|
||||
|
||||
/// Печатать только ошибки
|
||||
#[arg(short, long)]
|
||||
quiet: bool,
|
||||
}
|
||||
|
||||
impl Args {
|
||||
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(),
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
let args = Args::parse();
|
||||
let runtime = match tokio::runtime::Runtime::new() {
|
||||
Ok(runtime) => runtime,
|
||||
Err(error) => {
|
||||
eprintln!("tglock-cli: не удалось запустить среду выполнения: {error}");
|
||||
return ExitCode::FAILURE;
|
||||
}
|
||||
};
|
||||
|
||||
match runtime.block_on(serve(args)) {
|
||||
Ok(()) => ExitCode::SUCCESS,
|
||||
Err(error) => {
|
||||
eprintln!("tglock-cli: {error}");
|
||||
ExitCode::FAILURE
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn serve(args: Args) -> Result<(), String> {
|
||||
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 !args.quiet {
|
||||
println!("Слушаю {}", listen.addr);
|
||||
println!(
|
||||
"Ссылка для Telegram: {}",
|
||||
listen.telegram_link(&stats.telegram_secret())
|
||||
);
|
||||
if listen.allow_direct && !listen.addr.ip().is_loopback() {
|
||||
println!(
|
||||
"Внимание: --allow-direct на адресе {} превращает TGLock в открытый SOCKS5-прокси",
|
||||
listen.addr.ip()
|
||||
);
|
||||
} else if !listen.allow_direct {
|
||||
println!("Пропускаю только адреса Telegram");
|
||||
}
|
||||
if !args.worker.is_empty() {
|
||||
println!("Резервные Worker-домены: {}", args.worker_domains());
|
||||
}
|
||||
}
|
||||
|
||||
let server_stats = stats.clone();
|
||||
let mut server =
|
||||
tokio::spawn(
|
||||
async move { proxy::serve(server_stats, listener, listen.allow_direct).await },
|
||||
);
|
||||
let watcher = (!args.quiet).then(|| tokio::spawn(watch_status(stats.clone())));
|
||||
|
||||
let outcome = tokio::select! {
|
||||
joined = &mut server => joined.map_err(|error| format!("рабочая задача упала: {error}"))?,
|
||||
signal = shutdown_signal() => {
|
||||
signal.map_err(|error| format!("обработчик сигналов: {error}"))?;
|
||||
if !args.quiet {
|
||||
println!("Получен сигнал остановки, закрываю соединения…");
|
||||
}
|
||||
stats.stop();
|
||||
server
|
||||
.await
|
||||
.map_err(|error| format!("рабочая задача упала: {error}"))?
|
||||
}
|
||||
};
|
||||
|
||||
if let Some(watcher) = watcher {
|
||||
watcher.abort();
|
||||
}
|
||||
outcome
|
||||
}
|
||||
|
||||
/// Print a line whenever the tunnel state changes.
|
||||
///
|
||||
/// This is the text equivalent of the GUI diagnostics tab: without it a daemon
|
||||
/// gives journald nothing to show when Telegram stops working.
|
||||
async fn watch_status(stats: Arc<proxy::Stats>) {
|
||||
let mut previous = None;
|
||||
loop {
|
||||
tokio::time::sleep(STATUS_POLL).await;
|
||||
let current = (
|
||||
stats.active.load(Ordering::Relaxed),
|
||||
stats.ws.load(Ordering::Relaxed),
|
||||
stats.last_dc.load(Ordering::Relaxed),
|
||||
stats.last_route.load(Ordering::Relaxed),
|
||||
stats.ws_failures.load(Ordering::Relaxed),
|
||||
);
|
||||
if previous.as_ref() == Some(¤t) {
|
||||
continue;
|
||||
}
|
||||
let (active, tunnels, dc, route, failures) = current;
|
||||
println!(
|
||||
"соединений {active} · туннелей {tunnels} · {} · {} · сбоев {failures}",
|
||||
if dc > 0 {
|
||||
format!("DC{dc}")
|
||||
} else {
|
||||
"DC не определён".to_owned()
|
||||
},
|
||||
transport::route_label(route)
|
||||
);
|
||||
previous = Some(current);
|
||||
}
|
||||
}
|
||||
|
||||
/// Ctrl+C everywhere, plus SIGTERM on unix so `systemctl stop` shuts the
|
||||
/// tunnel down cleanly instead of killing it.
|
||||
#[cfg(unix)]
|
||||
async fn shutdown_signal() -> std::io::Result<()> {
|
||||
use tokio::signal::unix::{signal, SignalKind};
|
||||
|
||||
let mut terminate = signal(SignalKind::terminate())?;
|
||||
tokio::select! {
|
||||
result = tokio::signal::ctrl_c() => result,
|
||||
_ = terminate.recv() => Ok(()),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
async fn shutdown_signal() -> std::io::Result<()> {
|
||||
tokio::signal::ctrl_c().await
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use clap::CommandFactory;
|
||||
|
||||
fn parse(args: &[&str]) -> Args {
|
||||
Args::try_parse_from(std::iter::once("tglock-cli").chain(args.iter().copied())).unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn command_definition_is_valid() {
|
||||
Args::command().debug_assert();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defaults_to_loopback_on_the_default_port() {
|
||||
let listen = parse(&[]).listen();
|
||||
assert_eq!(listen.addr.to_string(), "127.0.0.1:1080");
|
||||
assert!(listen.allow_direct);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lan_flag_matches_explicit_wildcard_bind() {
|
||||
assert_eq!(
|
||||
parse(&["--lan"]).listen(),
|
||||
parse(&["-b", "0.0.0.0"]).listen()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lan_does_not_relay_non_telegram_traffic() {
|
||||
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!(!parse(&["-b", "192.168.1.10"]).listen().allow_direct);
|
||||
assert!(
|
||||
parse(&["-b", "192.168.1.10", "--allow-direct"])
|
||||
.listen()
|
||||
.allow_direct
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bind_and_port_are_honoured() {
|
||||
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 = 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 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!(parse(&[]).worker_domains().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lan_and_explicit_bind_cannot_be_combined() {
|
||||
assert!(Args::try_parse_from(["tglock-cli", "--lan", "-b", "127.0.0.1"]).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_pinned_secret_file_survives_a_restart() {
|
||||
let path = std::env::temp_dir().join(format!(
|
||||
"tglock-cli-secret-{}-{:?}",
|
||||
std::process::id(),
|
||||
std::thread::current().id()
|
||||
));
|
||||
let _ = std::fs::remove_file(&path);
|
||||
|
||||
let first = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
let second = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
|
||||
assert_eq!(
|
||||
first, second,
|
||||
"a restart must advertise the same tg:// secret"
|
||||
);
|
||||
assert!(first.starts_with("dd"));
|
||||
|
||||
// A corrupted file must not wedge the daemon: it is replaced.
|
||||
std::fs::write(&path, "garbage").unwrap();
|
||||
let third = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
assert_ne!(third, first);
|
||||
let fourth = parse(&["--secret-file", path.to_str().unwrap()])
|
||||
.stats()
|
||||
.telegram_secret();
|
||||
assert_eq!(third, fourth, "the replacement must be persisted in turn");
|
||||
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_malformed_values() {
|
||||
for bad in [
|
||||
vec!["-b", "not-an-ip"],
|
||||
vec!["-p", "70000"],
|
||||
vec!["-p", "-1"],
|
||||
vec!["--unknown"],
|
||||
] {
|
||||
assert!(
|
||||
Args::try_parse_from(std::iter::once("tglock-cli").chain(bad.iter().copied()))
|
||||
.is_err(),
|
||||
"{bad:?} must be rejected"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
-201
@@ -1,201 +0,0 @@
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
pub fn check_admin() -> bool {
|
||||
let output = Command::new("net")
|
||||
.args(["session"])
|
||||
.output();
|
||||
matches!(output, Ok(o) if o.status.success())
|
||||
}
|
||||
|
||||
pub fn set_dns(adapter: &str, primary: &str, secondary: &str) -> Result<(), String> {
|
||||
let out1 = Command::new("netsh")
|
||||
.args([
|
||||
"interface", "ipv4", "set", "dnsservers",
|
||||
adapter, "static", primary, "primary", "validate=no",
|
||||
])
|
||||
.output()
|
||||
.map_err(|e| format!("netsh error: {}", e))?;
|
||||
|
||||
if !out1.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&out1.stderr);
|
||||
return Err(format!("Failed to set primary DNS: {}", stderr));
|
||||
}
|
||||
|
||||
let out2 = Command::new("netsh")
|
||||
.args([
|
||||
"interface", "ipv4", "add", "dnsservers",
|
||||
adapter, secondary, "index=2", "validate=no",
|
||||
])
|
||||
.output()
|
||||
.map_err(|e| format!("netsh error: {}", e))?;
|
||||
|
||||
if !out2.status.success() {
|
||||
// Non-critical: secondary DNS may already exist
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn reset_dns(adapter: &str) -> Result<(), String> {
|
||||
let out = Command::new("netsh")
|
||||
.args([
|
||||
"interface", "ipv4", "set", "dnsservers",
|
||||
adapter, "dhcp",
|
||||
])
|
||||
.output()
|
||||
.map_err(|e| format!("netsh error: {}", e))?;
|
||||
|
||||
if !out.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&out.stderr);
|
||||
return Err(format!("Failed to reset DNS: {}", stderr));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn flush_dns() {
|
||||
let _ = Command::new("ipconfig")
|
||||
.args(["/flushdns"])
|
||||
.output();
|
||||
}
|
||||
|
||||
pub fn find_goodbyedpi() -> Option<String> {
|
||||
let exe_dir = std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|p| p.parent().map(|p| p.to_path_buf()))
|
||||
.unwrap_or_else(|| PathBuf::from("."));
|
||||
|
||||
let search_dirs = vec![
|
||||
exe_dir.join("tools"),
|
||||
exe_dir.join("tools").join("goodbyedpi"),
|
||||
exe_dir.clone(),
|
||||
PathBuf::from("tools"),
|
||||
PathBuf::from("tools").join("goodbyedpi"),
|
||||
PathBuf::from("."),
|
||||
];
|
||||
|
||||
for dir in &search_dirs {
|
||||
// Check common locations
|
||||
for sub in &["x86_64", "x86", ""] {
|
||||
let candidate = if sub.is_empty() {
|
||||
dir.join("goodbyedpi.exe")
|
||||
} else {
|
||||
dir.join(sub).join("goodbyedpi.exe")
|
||||
};
|
||||
if candidate.exists() {
|
||||
return Some(candidate.to_string_lossy().to_string());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Recursive search in tools/
|
||||
if let Ok(entries) = find_file_recursive(Path::new("tools"), "goodbyedpi.exe") {
|
||||
if !entries.is_empty() {
|
||||
return Some(entries[0].to_string_lossy().to_string());
|
||||
}
|
||||
}
|
||||
|
||||
None
|
||||
}
|
||||
|
||||
fn find_file_recursive(dir: &Path, filename: &str) -> Result<Vec<PathBuf>, std::io::Error> {
|
||||
let mut results = Vec::new();
|
||||
if !dir.exists() {
|
||||
return Ok(results);
|
||||
}
|
||||
for entry in std::fs::read_dir(dir)? {
|
||||
let entry = entry?;
|
||||
let path = entry.path();
|
||||
if path.is_file() && path.file_name().map(|n| n == filename).unwrap_or(false) {
|
||||
results.push(path);
|
||||
} else if path.is_dir() {
|
||||
results.extend(find_file_recursive(&path, filename)?);
|
||||
}
|
||||
}
|
||||
Ok(results)
|
||||
}
|
||||
|
||||
pub fn get_blacklist_path() -> Option<String> {
|
||||
let candidates = vec![
|
||||
PathBuf::from("tg_blacklist.txt"),
|
||||
PathBuf::from("tools").join("tg_blacklist.txt"),
|
||||
std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|p| p.parent().map(|p| p.join("tg_blacklist.txt")))
|
||||
.unwrap_or_default(),
|
||||
];
|
||||
|
||||
for path in candidates {
|
||||
if path.exists() {
|
||||
return Some(path.to_string_lossy().to_string());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn start_goodbyedpi(exe_path: &str, args: &[&str], blacklist: Option<&str>) -> Result<(), String> {
|
||||
let mut cmd = Command::new(exe_path);
|
||||
cmd.args(args);
|
||||
|
||||
if let Some(bl) = blacklist {
|
||||
cmd.args(["--blacklist", bl]);
|
||||
}
|
||||
|
||||
cmd.spawn().map_err(|e| format!("Failed to start GoodbyeDPI: {}", e))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn kill_goodbyedpi() {
|
||||
let _ = Command::new("taskkill")
|
||||
.args(["/f", "/im", "goodbyedpi.exe"])
|
||||
.output();
|
||||
}
|
||||
|
||||
pub fn download_goodbyedpi() -> Result<String, String> {
|
||||
let tools_dir = PathBuf::from("tools");
|
||||
std::fs::create_dir_all(&tools_dir)
|
||||
.map_err(|e| format!("Cannot create tools dir: {}", e))?;
|
||||
|
||||
let zip_path = tools_dir.join("goodbyedpi.zip");
|
||||
let url = "https://github.com/ValdikSS/GoodbyeDPI/releases/download/0.2.3rc3/goodbyedpi-0.2.3rc3-2.zip";
|
||||
|
||||
// Download using powershell
|
||||
let dl_script = format!(
|
||||
"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; Invoke-WebRequest -Uri '{}' -OutFile '{}' -UseBasicParsing",
|
||||
url,
|
||||
zip_path.to_string_lossy()
|
||||
);
|
||||
|
||||
let output = Command::new("powershell")
|
||||
.args(["-Command", &dl_script])
|
||||
.output()
|
||||
.map_err(|e| format!("Download failed: {}", e))?;
|
||||
|
||||
if !output.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
return Err(format!("Download failed: {}", stderr));
|
||||
}
|
||||
|
||||
// Extract
|
||||
let extract_script = format!(
|
||||
"Expand-Archive -Path '{}' -DestinationPath '{}' -Force",
|
||||
zip_path.to_string_lossy(),
|
||||
tools_dir.to_string_lossy()
|
||||
);
|
||||
|
||||
let output = Command::new("powershell")
|
||||
.args(["-Command", &extract_script])
|
||||
.output()
|
||||
.map_err(|e| format!("Extraction failed: {}", e))?;
|
||||
|
||||
if !output.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
return Err(format!("Extraction failed: {}", stderr));
|
||||
}
|
||||
|
||||
// Clean up zip
|
||||
let _ = std::fs::remove_file(&zip_path);
|
||||
|
||||
// Find the exe
|
||||
find_goodbyedpi().ok_or_else(|| "goodbyedpi.exe not found after extraction".to_string())
|
||||
}
|
||||
+135
@@ -0,0 +1,135 @@
|
||||
//! Listener configuration shared by the GUI and the CLI.
|
||||
|
||||
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
|
||||
|
||||
/// Where the local proxy listens and whether it is allowed to relay anything
|
||||
/// other than Telegram.
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct ListenConfig {
|
||||
pub addr: SocketAddr,
|
||||
/// Relay non-Telegram destinations as a plain SOCKS5 proxy.
|
||||
///
|
||||
/// Loopback listeners get this for free because only local processes can
|
||||
/// reach them. A listener the network can reach must opt in explicitly, so
|
||||
/// that sharing TGLock across a flat never silently turns the machine into
|
||||
/// an open SOCKS5 relay.
|
||||
pub allow_direct: bool,
|
||||
}
|
||||
|
||||
impl ListenConfig {
|
||||
/// Listener with the default policy for the given address.
|
||||
pub fn new(ip: IpAddr, port: u16) -> Self {
|
||||
Self {
|
||||
addr: SocketAddr::new(ip, port),
|
||||
allow_direct: ip.is_loopback(),
|
||||
}
|
||||
}
|
||||
|
||||
/// `127.0.0.1` — only this machine, non-Telegram traffic relayed.
|
||||
pub fn loopback(port: u16) -> Self {
|
||||
Self::new(IpAddr::V4(Ipv4Addr::LOCALHOST), port)
|
||||
}
|
||||
|
||||
/// `0.0.0.0` — reachable from the local network, Telegram destinations only.
|
||||
pub fn lan(port: u16) -> Self {
|
||||
Self::new(IpAddr::V4(Ipv4Addr::UNSPECIFIED), port)
|
||||
}
|
||||
|
||||
/// Override the direct-relay policy. Used by `--allow-direct`.
|
||||
pub fn with_allow_direct(mut self, allow_direct: bool) -> Self {
|
||||
self.allow_direct = allow_direct;
|
||||
self
|
||||
}
|
||||
|
||||
/// Host to advertise in a `tg://proxy` link for this listener.
|
||||
///
|
||||
/// A wildcard bind is not a usable destination, so it is resolved to the
|
||||
/// address this machine uses to reach the network.
|
||||
pub fn advertised_host(&self) -> String {
|
||||
let ip = self.addr.ip();
|
||||
if ip.is_unspecified() {
|
||||
outbound_ip().unwrap_or_else(|| Ipv4Addr::LOCALHOST.to_string())
|
||||
} else {
|
||||
ip.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
/// `tg://proxy` link that points Telegram at this listener.
|
||||
pub fn telegram_link(&self, secret: &str) -> String {
|
||||
format!(
|
||||
"tg://proxy?server={}&port={}&secret={}",
|
||||
self.advertised_host(),
|
||||
self.addr.port(),
|
||||
secret
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Local address of the interface that reaches the default route.
|
||||
///
|
||||
/// No packet is sent: connecting a UDP socket only makes the OS pick a route.
|
||||
fn outbound_ip() -> Option<String> {
|
||||
let socket = std::net::UdpSocket::bind("0.0.0.0:0").ok()?;
|
||||
socket.connect("8.8.8.8:80").ok()?;
|
||||
Some(socket.local_addr().ok()?.ip().to_string())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn loopback_relays_direct_traffic() {
|
||||
let config = ListenConfig::loopback(1080);
|
||||
assert_eq!(config.addr.to_string(), "127.0.0.1:1080");
|
||||
assert!(config.allow_direct);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lan_restricts_to_telegram_by_default() {
|
||||
let config = ListenConfig::lan(1080);
|
||||
assert_eq!(config.addr.to_string(), "0.0.0.0:1080");
|
||||
assert!(!config.allow_direct);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn any_routable_address_restricts_to_telegram() {
|
||||
for ip in ["192.168.1.10", "10.0.0.5", "::"] {
|
||||
let config = ListenConfig::new(ip.parse().unwrap(), 1080);
|
||||
assert!(
|
||||
!config.allow_direct,
|
||||
"{ip} must not relay non-Telegram traffic without an explicit opt-in"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ipv6_loopback_is_treated_as_local() {
|
||||
let config = ListenConfig::new("::1".parse().unwrap(), 1080);
|
||||
assert!(config.allow_direct);
|
||||
assert_eq!(config.addr.to_string(), "[::1]:1080");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn allow_direct_override_is_explicit_in_both_directions() {
|
||||
assert!(ListenConfig::lan(1080).with_allow_direct(true).allow_direct);
|
||||
assert!(
|
||||
!ListenConfig::loopback(1080)
|
||||
.with_allow_direct(false)
|
||||
.allow_direct
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn link_uses_concrete_host_and_port() {
|
||||
let link = ListenConfig::new("192.168.1.10".parse().unwrap(), 1443).telegram_link("ddaa");
|
||||
assert_eq!(link, "tg://proxy?server=192.168.1.10&port=1443&secret=ddaa");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn wildcard_bind_never_advertises_itself() {
|
||||
let host = ListenConfig::lan(1080).advertised_host();
|
||||
assert_ne!(host, "0.0.0.0");
|
||||
assert!(!host.is_empty());
|
||||
}
|
||||
}
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
//! TGLock core: the MTProto/WebSocket transport shared by the desktop GUI and
|
||||
//! the headless CLI.
|
||||
//!
|
||||
//! Nothing in this crate depends on Tauri or on a windowing system, so the
|
||||
//! `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 transport;
|
||||
+310
-325
@@ -1,356 +1,341 @@
|
||||
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
|
||||
|
||||
mod bypass;
|
||||
mod network;
|
||||
mod ws_proxy;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::Ordering;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::{Instant, SystemTime, UNIX_EPOCH};
|
||||
use tauri::{Manager, State};
|
||||
use tglock::config::ListenConfig;
|
||||
use tglock::{proxy, transport};
|
||||
|
||||
use eframe::egui;
|
||||
#[derive(Clone, Debug, Deserialize, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct Settings {
|
||||
lan_mode: bool,
|
||||
port: u16,
|
||||
worker_domain: String,
|
||||
}
|
||||
|
||||
const PROXY_PORT: u16 = 1080;
|
||||
impl Default for Settings {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
lan_mode: false,
|
||||
port: proxy::DEFAULT_PORT,
|
||||
worker_domain: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> eframe::Result<()> {
|
||||
let options = eframe::NativeOptions {
|
||||
viewport: egui::ViewportBuilder::default()
|
||||
.with_inner_size([680.0, 560.0])
|
||||
.with_min_inner_size([580.0, 460.0])
|
||||
.with_title("TG Unblock"),
|
||||
..Default::default()
|
||||
};
|
||||
#[derive(Clone, Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct LogLine {
|
||||
timestamp: String,
|
||||
message: String,
|
||||
error: bool,
|
||||
}
|
||||
|
||||
eframe::run_native(
|
||||
"TG Unblock",
|
||||
options,
|
||||
Box::new(|cc| {
|
||||
setup_fonts(&cc.egui_ctx);
|
||||
Ok(Box::new(App::new()))
|
||||
}),
|
||||
#[derive(Serialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
struct StatusSnapshot {
|
||||
running: bool,
|
||||
active_connections: u32,
|
||||
tunnels: u32,
|
||||
data_center: Option<u16>,
|
||||
route: String,
|
||||
failures: u32,
|
||||
uptime_seconds: u64,
|
||||
port: u16,
|
||||
logs: Vec<LogLine>,
|
||||
}
|
||||
|
||||
struct AppState {
|
||||
stats: Arc<proxy::Stats>,
|
||||
settings: Mutex<Settings>,
|
||||
active_port: Mutex<u16>,
|
||||
started_at: Mutex<Option<Instant>>,
|
||||
logs: Arc<Mutex<Vec<LogLine>>>,
|
||||
settings_path: PathBuf,
|
||||
}
|
||||
|
||||
impl AppState {
|
||||
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: proxy::Stats::new(),
|
||||
settings: Mutex::new(settings),
|
||||
active_port: Mutex::new(proxy::DEFAULT_PORT),
|
||||
started_at: Mutex::new(None),
|
||||
logs: Arc::new(Mutex::new(Vec::new())),
|
||||
settings_path,
|
||||
}
|
||||
}
|
||||
|
||||
fn log(&self, message: impl Into<String>, error: bool) {
|
||||
let mut logs = self.logs.lock().unwrap();
|
||||
logs.push(LogLine {
|
||||
timestamp: current_time(),
|
||||
message: message.into(),
|
||||
error,
|
||||
});
|
||||
if logs.len() > 100 {
|
||||
logs.remove(0);
|
||||
}
|
||||
}
|
||||
|
||||
fn snapshot(&self) -> StatusSnapshot {
|
||||
let data_center = self.stats.last_dc.load(Ordering::Relaxed);
|
||||
let route = transport::route_label(self.stats.last_route.load(Ordering::Relaxed));
|
||||
StatusSnapshot {
|
||||
running: self.stats.running.load(Ordering::SeqCst),
|
||||
active_connections: self.stats.active.load(Ordering::Relaxed),
|
||||
tunnels: self.stats.ws.load(Ordering::Relaxed),
|
||||
data_center: (data_center > 0).then_some(data_center),
|
||||
route: route.to_owned(),
|
||||
failures: self.stats.ws_failures.load(Ordering::Relaxed),
|
||||
uptime_seconds: self
|
||||
.started_at
|
||||
.lock()
|
||||
.unwrap()
|
||||
.map_or(0, |started| started.elapsed().as_secs()),
|
||||
port: *self.active_port.lock().unwrap(),
|
||||
logs: self.logs.lock().unwrap().clone(),
|
||||
}
|
||||
}
|
||||
|
||||
fn persist_settings(&self, settings: &Settings) -> Result<(), String> {
|
||||
if let Some(parent) = self.settings_path.parent() {
|
||||
std::fs::create_dir_all(parent)
|
||||
.map_err(|error| format!("Не удалось создать папку настроек: {error}"))?;
|
||||
}
|
||||
let contents = serde_json::to_vec_pretty(settings)
|
||||
.map_err(|error| format!("Не удалось сохранить настройки: {error}"))?;
|
||||
std::fs::write(&self.settings_path, contents)
|
||||
.map_err(|error| format!("Не удалось сохранить настройки: {error}"))
|
||||
}
|
||||
}
|
||||
|
||||
fn current_time() -> String {
|
||||
let seconds = SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.unwrap_or_default()
|
||||
.as_secs();
|
||||
format!(
|
||||
"{:02}:{:02}:{:02}",
|
||||
(seconds / 3600) % 24,
|
||||
(seconds / 60) % 60,
|
||||
seconds % 60
|
||||
)
|
||||
}
|
||||
|
||||
fn setup_fonts(ctx: &egui::Context) {
|
||||
let mut fonts = egui::FontDefinitions::default();
|
||||
fonts.font_data.insert(
|
||||
"system".to_owned(),
|
||||
std::sync::Arc::new(egui::FontData::from_static(include_bytes!(
|
||||
"C:\\Windows\\Fonts\\segoeui.ttf"
|
||||
))),
|
||||
);
|
||||
fonts
|
||||
.families
|
||||
.entry(egui::FontFamily::Proportional)
|
||||
.or_default()
|
||||
.insert(0, "system".to_owned());
|
||||
fonts
|
||||
.families
|
||||
.entry(egui::FontFamily::Monospace)
|
||||
.or_default()
|
||||
.insert(0, "system".to_owned());
|
||||
ctx.set_fonts(fonts);
|
||||
#[tauri::command]
|
||||
fn get_status(state: State<'_, AppState>) -> StatusSnapshot {
|
||||
state.snapshot()
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct LogEntry {
|
||||
text: String,
|
||||
is_error: bool,
|
||||
ts: String,
|
||||
#[tauri::command]
|
||||
fn get_settings(state: State<'_, AppState>) -> Settings {
|
||||
state.settings.lock().unwrap().clone()
|
||||
}
|
||||
|
||||
struct App {
|
||||
log: Arc<Mutex<Vec<LogEntry>>>,
|
||||
proxy_stats: Arc<ws_proxy::ProxyStats>,
|
||||
is_admin: bool,
|
||||
adapter_name: Arc<Mutex<Option<String>>>,
|
||||
dns_set: Arc<Mutex<bool>>,
|
||||
#[tauri::command]
|
||||
fn save_settings(settings: Settings, state: State<'_, AppState>) -> Result<Settings, String> {
|
||||
if state.stats.running.load(Ordering::SeqCst) {
|
||||
return Err("Сначала выключите защиту".into());
|
||||
}
|
||||
if settings.port == 0 {
|
||||
return Err("Порт должен быть от 1 до 65535".into());
|
||||
}
|
||||
state.persist_settings(&settings)?;
|
||||
*state.settings.lock().unwrap() = settings.clone();
|
||||
state.log("Настройки сохранены", false);
|
||||
Ok(settings)
|
||||
}
|
||||
|
||||
impl App {
|
||||
fn new() -> Self {
|
||||
let is_admin = bypass::check_admin();
|
||||
let app = Self {
|
||||
log: Arc::new(Mutex::new(Vec::new())),
|
||||
proxy_stats: ws_proxy::ProxyStats::new(),
|
||||
is_admin,
|
||||
adapter_name: Arc::new(Mutex::new(None)),
|
||||
dns_set: Arc::new(Mutex::new(false)),
|
||||
#[tauri::command]
|
||||
fn start_proxy(state: State<'_, AppState>) -> Result<StatusSnapshot, String> {
|
||||
if state.stats.running.load(Ordering::SeqCst) {
|
||||
return Ok(state.snapshot());
|
||||
}
|
||||
|
||||
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 stats = state.stats.clone();
|
||||
let logs = state.logs.clone();
|
||||
std::thread::spawn(move || {
|
||||
let runtime = match tokio::runtime::Runtime::new() {
|
||||
Ok(runtime) => runtime,
|
||||
Err(error) => {
|
||||
push_log(&logs, format!("Не удалось запустить сервис: {error}"), true);
|
||||
return;
|
||||
}
|
||||
};
|
||||
log_msg(&app.log, "Запущено", false);
|
||||
if !is_admin {
|
||||
log_msg(&app.log, "Нет прав администратора — DNS менять не получится", true);
|
||||
if let Err(error) = runtime.block_on(proxy::run(stats, listen)) {
|
||||
push_log(&logs, format!("Ошибка подключения: {error}"), true);
|
||||
}
|
||||
{
|
||||
let adapter = app.adapter_name.clone();
|
||||
let log = app.log.clone();
|
||||
std::thread::spawn(move || {
|
||||
if let Some(name) = network::detect_adapter() {
|
||||
log_msg(&log, &format!("Адаптер: {}", name), false);
|
||||
*adapter.lock().unwrap() = Some(name);
|
||||
}
|
||||
});
|
||||
}
|
||||
app
|
||||
});
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(220));
|
||||
if !state.stats.running.load(Ordering::SeqCst) {
|
||||
*state.started_at.lock().unwrap() = None;
|
||||
return Err(state
|
||||
.logs
|
||||
.lock()
|
||||
.unwrap()
|
||||
.last()
|
||||
.map(|line| line.message.clone())
|
||||
.unwrap_or_else(|| "Не удалось запустить прокси".into()));
|
||||
}
|
||||
|
||||
fn proxy_running(&self) -> bool {
|
||||
self.proxy_stats.running.load(Ordering::SeqCst)
|
||||
}
|
||||
|
||||
fn start_proxy(&self) {
|
||||
if self.proxy_running() {
|
||||
return;
|
||||
}
|
||||
let stats = self.proxy_stats.clone();
|
||||
let log = self.log.clone();
|
||||
let adapter = self.adapter_name.clone();
|
||||
let dns_set = self.dns_set.clone();
|
||||
let is_admin = self.is_admin;
|
||||
|
||||
std::thread::spawn(move || {
|
||||
// DNS
|
||||
if is_admin {
|
||||
let aname = adapter.lock().unwrap().clone().or_else(network::detect_adapter);
|
||||
if let Some(ref name) = aname {
|
||||
if bypass::set_dns(name, "1.1.1.1", "1.0.0.1").is_ok() {
|
||||
bypass::flush_dns();
|
||||
log_msg(&log, "DNS → Cloudflare 1.1.1.1", false);
|
||||
*dns_set.lock().unwrap() = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
log_msg(&log, &format!("Запускаю WS-прокси на 127.0.0.1:{}...", PROXY_PORT), false);
|
||||
|
||||
let rt = tokio::runtime::Runtime::new().unwrap();
|
||||
let result = rt.block_on(ws_proxy::run_proxy(PROXY_PORT, stats));
|
||||
if let Err(e) = result {
|
||||
log_msg(&log, &format!("Прокси остановлен: {}", e), true);
|
||||
}
|
||||
});
|
||||
|
||||
std::thread::sleep(std::time::Duration::from_millis(300));
|
||||
if self.proxy_running() {
|
||||
log_msg(&self.log, "Прокси запущен! Настройте Telegram.", false);
|
||||
}
|
||||
}
|
||||
|
||||
fn stop_proxy(&self) {
|
||||
self.proxy_stats.running.store(false, Ordering::SeqCst);
|
||||
log_msg(&self.log, "Прокси остановлен", false);
|
||||
|
||||
if *self.dns_set.lock().unwrap() {
|
||||
let adapter = self.adapter_name.clone();
|
||||
let log = self.log.clone();
|
||||
let dns_set = self.dns_set.clone();
|
||||
std::thread::spawn(move || {
|
||||
let aname = adapter.lock().unwrap().clone().or_else(network::detect_adapter);
|
||||
if let Some(ref name) = aname {
|
||||
let _ = bypass::reset_dns(name);
|
||||
bypass::flush_dns();
|
||||
*dns_set.lock().unwrap() = false;
|
||||
log_msg(&log, "DNS сброшен", false);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn open_tg_proxy_link(&self) {
|
||||
let url = format!("tg://socks?server=127.0.0.1&port={}", PROXY_PORT);
|
||||
log_msg(&self.log, "Открываю настройку прокси в Telegram...", false);
|
||||
let _ = open::that(&url);
|
||||
}
|
||||
state.log(format!("Прокси запущен на {}", listen.addr), false);
|
||||
let _ = open::that(listen.telegram_link(&state.stats.telegram_secret()));
|
||||
state.log("Открываю подключение в Telegram…", false);
|
||||
Ok(state.snapshot())
|
||||
}
|
||||
|
||||
fn log_msg(log: &Arc<Mutex<Vec<LogEntry>>>, text: &str, err: bool) {
|
||||
let now = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_secs();
|
||||
let ts = format!("{:02}:{:02}:{:02}", (now % 86400) / 3600, (now % 3600) / 60, now % 60);
|
||||
log.lock().unwrap().push(LogEntry {
|
||||
text: text.to_string(),
|
||||
is_error: err,
|
||||
ts,
|
||||
#[tauri::command]
|
||||
fn stop_proxy(state: State<'_, AppState>) -> StatusSnapshot {
|
||||
state.stats.stop();
|
||||
*state.started_at.lock().unwrap() = None;
|
||||
state.log("Защита выключена", false);
|
||||
state.snapshot()
|
||||
}
|
||||
|
||||
fn push_log(logs: &Arc<Mutex<Vec<LogLine>>>, message: String, error: bool) {
|
||||
logs.lock().unwrap().push(LogLine {
|
||||
timestamp: current_time(),
|
||||
message,
|
||||
error,
|
||||
});
|
||||
}
|
||||
|
||||
impl eframe::App for App {
|
||||
fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
|
||||
ctx.request_repaint_after(std::time::Duration::from_millis(400));
|
||||
/// Environment variables that make the WebView render without a GPU.
|
||||
///
|
||||
/// The window is never created when 3D acceleration is unavailable: no
|
||||
/// monitor, the default Microsoft display driver, a virtual machine without
|
||||
/// 3D enabled (by-sonic/tglock#10, by-sonic/tglock#17). For a small status
|
||||
/// panel software rendering costs nothing noticeable, so preferring it is the
|
||||
/// safer default.
|
||||
///
|
||||
/// Values already present in the environment are never overwritten, and
|
||||
/// `TGLOCK_FORCE_GPU` disables the whole mechanism.
|
||||
fn software_rendering_vars(
|
||||
force_gpu: bool,
|
||||
is_set: impl Fn(&str) -> bool,
|
||||
) -> Vec<(&'static str, &'static str)> {
|
||||
if force_gpu {
|
||||
return Vec::new();
|
||||
}
|
||||
|
||||
let running = self.proxy_running();
|
||||
let active = self.proxy_stats.active_conn.load(Ordering::Relaxed);
|
||||
let total = self.proxy_stats.total_conn.load(Ordering::Relaxed);
|
||||
let ws = self.proxy_stats.ws_active.load(Ordering::Relaxed);
|
||||
let candidates: &[(&str, &str)] = if cfg!(target_os = "windows") {
|
||||
&[(
|
||||
"WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS",
|
||||
"--disable-gpu --disable-gpu-compositing",
|
||||
)]
|
||||
} else if cfg!(target_os = "macos") {
|
||||
// WebKit on macOS falls back to software rendering on its own.
|
||||
&[]
|
||||
} else {
|
||||
&[
|
||||
("WEBKIT_DISABLE_COMPOSITING_MODE", "1"),
|
||||
("WEBKIT_DISABLE_DMABUF_RENDERER", "1"),
|
||||
]
|
||||
};
|
||||
|
||||
// --- Top bar ---
|
||||
egui::TopBottomPanel::top("top").show(ctx, |ui| {
|
||||
ui.horizontal(|ui| {
|
||||
ui.heading("TG Unblock");
|
||||
ui.separator();
|
||||
if running {
|
||||
ui.colored_label(
|
||||
egui::Color32::from_rgb(80, 220, 120),
|
||||
egui::RichText::new("ПРОКСИ РАБОТАЕТ").strong(),
|
||||
);
|
||||
ui.separator();
|
||||
ui.label(format!("Соединений: {} (WS: {}) | Всего: {}", active, ws, total));
|
||||
} else {
|
||||
ui.label("Прокси не запущен");
|
||||
}
|
||||
});
|
||||
});
|
||||
candidates
|
||||
.iter()
|
||||
.filter(|(key, _)| !is_set(key))
|
||||
.copied()
|
||||
.collect()
|
||||
}
|
||||
|
||||
// --- Log panel ---
|
||||
egui::TopBottomPanel::bottom("log")
|
||||
.min_height(130.0)
|
||||
.show(ctx, |ui| {
|
||||
ui.label(egui::RichText::new("Лог").strong());
|
||||
ui.separator();
|
||||
egui::ScrollArea::vertical()
|
||||
.auto_shrink([false, false])
|
||||
.stick_to_bottom(true)
|
||||
.show(ui, |ui| {
|
||||
let logs = self.log.lock().unwrap();
|
||||
for e in logs.iter() {
|
||||
let color = if e.is_error {
|
||||
egui::Color32::from_rgb(255, 100, 100)
|
||||
} else {
|
||||
egui::Color32::from_rgb(170, 215, 170)
|
||||
};
|
||||
ui.colored_label(color, format!("[{}] {}", e.ts, e.text));
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
// --- Main panel ---
|
||||
egui::CentralPanel::default().show(ctx, |ui| {
|
||||
ui.add_space(10.0);
|
||||
|
||||
// --- VPN ad (top) ---
|
||||
ui.vertical_centered(|ui| {
|
||||
egui::Frame::new()
|
||||
.fill(egui::Color32::from_rgb(25, 30, 42))
|
||||
.corner_radius(8.0)
|
||||
.inner_margin(egui::Margin::symmetric(14, 8))
|
||||
.show(ui, |ui| {
|
||||
ui.horizontal(|ui| {
|
||||
ui.colored_label(
|
||||
egui::Color32::from_rgb(100, 180, 255),
|
||||
egui::RichText::new("by sonic VPN").size(13.0).strong(),
|
||||
);
|
||||
ui.label(
|
||||
egui::RichText::new("Полный обход для всех приложений")
|
||||
.size(12.0)
|
||||
.color(egui::Color32::from_rgb(160, 165, 180)),
|
||||
);
|
||||
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
|
||||
if ui.add(
|
||||
egui::Button::new(
|
||||
egui::RichText::new("@bysonicvpn_bot")
|
||||
.size(12.0)
|
||||
.strong()
|
||||
.color(egui::Color32::from_rgb(100, 200, 255)),
|
||||
)
|
||||
.frame(false),
|
||||
).clicked() {
|
||||
let _ = open::that("https://t.me/bysonicvpn_bot");
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
ui.add_space(12.0);
|
||||
|
||||
ui.vertical_centered(|ui| {
|
||||
if !running {
|
||||
ui.label(egui::RichText::new("Обход блокировки Telegram через WebSocket-прокси").size(15.0));
|
||||
ui.add_space(5.0);
|
||||
ui.label("Трафик идёт через web.telegram.org — провайдер видит обычный HTTPS");
|
||||
ui.add_space(15.0);
|
||||
|
||||
let btn = ui.add_sized(
|
||||
[340.0, 55.0],
|
||||
egui::Button::new(egui::RichText::new("Запустить обход").size(20.0).strong()),
|
||||
);
|
||||
if btn.clicked() {
|
||||
self.start_proxy();
|
||||
}
|
||||
} else {
|
||||
ui.colored_label(
|
||||
egui::Color32::from_rgb(80, 220, 120),
|
||||
egui::RichText::new("Обход работает").size(22.0).strong(),
|
||||
);
|
||||
ui.add_space(5.0);
|
||||
ui.label(format!("SOCKS5 прокси на 127.0.0.1:{}", PROXY_PORT));
|
||||
ui.label(format!("WebSocket-туннелей: {} | Соединений: {}", ws, active));
|
||||
ui.add_space(12.0);
|
||||
|
||||
// Stop button
|
||||
let stop = ui.add_sized(
|
||||
[340.0, 42.0],
|
||||
egui::Button::new(egui::RichText::new("Остановить").size(17.0)),
|
||||
);
|
||||
if stop.clicked() {
|
||||
self.stop_proxy();
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
ui.add_space(20.0);
|
||||
ui.separator();
|
||||
ui.add_space(8.0);
|
||||
|
||||
// --- Telegram setup ---
|
||||
ui.heading("Настройка Telegram Desktop");
|
||||
ui.add_space(6.0);
|
||||
|
||||
if running {
|
||||
ui.horizontal(|ui| {
|
||||
if ui.button(" Настроить автоматически ").clicked() {
|
||||
self.open_tg_proxy_link();
|
||||
}
|
||||
ui.label("(откроет Telegram, нажмите \"Подключить\")");
|
||||
});
|
||||
ui.add_space(8.0);
|
||||
}
|
||||
|
||||
ui.label("Или вручную: Настройки → Продвинутые → Тип соединения → SOCKS5");
|
||||
ui.add_space(4.0);
|
||||
egui::Grid::new("manual_setup")
|
||||
.num_columns(2)
|
||||
.spacing([15.0, 4.0])
|
||||
.show(ui, |ui| {
|
||||
ui.label("Сервер:");
|
||||
ui.monospace("127.0.0.1");
|
||||
ui.end_row();
|
||||
ui.label("Порт:");
|
||||
ui.monospace(format!("{}", PROXY_PORT));
|
||||
ui.end_row();
|
||||
ui.label("Логин/Пароль:");
|
||||
ui.label("оставить пустыми");
|
||||
ui.end_row();
|
||||
});
|
||||
|
||||
ui.add_space(15.0);
|
||||
ui.separator();
|
||||
ui.add_space(5.0);
|
||||
|
||||
// --- How it works ---
|
||||
ui.heading("Как это работает");
|
||||
ui.add_space(4.0);
|
||||
ui.label("1. Локальный SOCKS5-прокси принимает соединения от Telegram");
|
||||
ui.label("2. Трафик к серверам Telegram заворачивается в WebSocket (WSS)");
|
||||
ui.label("3. Подключение идёт через web.telegram.org — обычный HTTPS");
|
||||
ui.label("4. Провайдер/DPI не видит MTProto, не может замедлить");
|
||||
ui.add_space(4.0);
|
||||
ui.colored_label(
|
||||
egui::Color32::from_rgb(170, 170, 170),
|
||||
"Не-Telegram трафик проходит напрямую без изменений",
|
||||
);
|
||||
|
||||
});
|
||||
fn prefer_software_rendering() {
|
||||
let force_gpu = std::env::var_os("TGLOCK_FORCE_GPU").is_some();
|
||||
for (key, value) in software_rendering_vars(force_gpu, |key| std::env::var_os(key).is_some()) {
|
||||
std::env::set_var(key, value);
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
prefer_software_rendering();
|
||||
|
||||
tauri::Builder::default()
|
||||
.setup(|app| {
|
||||
let settings_path = app
|
||||
.path()
|
||||
.app_config_dir()
|
||||
.map_err(|error| error.to_string())?
|
||||
.join("settings.json");
|
||||
app.manage(AppState::new(settings_path));
|
||||
Ok(())
|
||||
})
|
||||
.invoke_handler(tauri::generate_handler![
|
||||
get_status,
|
||||
get_settings,
|
||||
save_settings,
|
||||
start_proxy,
|
||||
stop_proxy
|
||||
])
|
||||
.run(tauri::generate_context!())
|
||||
.expect("failed to run TGLock");
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn software_rendering_is_requested_by_default() {
|
||||
let vars = software_rendering_vars(false, |_| false);
|
||||
if cfg!(target_os = "macos") {
|
||||
assert!(vars.is_empty(), "macOS needs no override");
|
||||
} else {
|
||||
assert!(
|
||||
!vars.is_empty(),
|
||||
"a machine without 3D acceleration must still get a window"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn force_gpu_disables_the_override() {
|
||||
assert!(software_rendering_vars(true, |_| false).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_operators_own_value_is_never_overwritten() {
|
||||
assert!(software_rendering_vars(false, |_| true).is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn windows_uses_webview2_arguments_and_linux_uses_webkit_ones() {
|
||||
let keys: Vec<_> = software_rendering_vars(false, |_| false)
|
||||
.into_iter()
|
||||
.map(|(key, _)| key)
|
||||
.collect();
|
||||
if cfg!(target_os = "windows") {
|
||||
assert_eq!(keys, ["WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS"]);
|
||||
} else if cfg!(target_os = "linux") {
|
||||
assert_eq!(
|
||||
keys,
|
||||
[
|
||||
"WEBKIT_DISABLE_COMPOSITING_MODE",
|
||||
"WEBKIT_DISABLE_DMABUF_RENDERER"
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+515
@@ -0,0 +1,515 @@
|
||||
use aes::Aes256;
|
||||
use cipher::{KeyIvInit, StreamCipher};
|
||||
use rand::{rngs::OsRng, RngCore};
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::path::Path;
|
||||
#[cfg(not(test))]
|
||||
use std::path::PathBuf;
|
||||
|
||||
type AesCtr = ctr::Ctr128BE<Aes256>;
|
||||
|
||||
const INIT_LEN: usize = 64;
|
||||
const KEY_START: usize = 8;
|
||||
const KEY_END: usize = 40;
|
||||
const IV_END: usize = 56;
|
||||
const TAG_START: usize = 56;
|
||||
const DC_START: usize = 60;
|
||||
|
||||
const ABRIDGED: [u8; 4] = [0xef; 4];
|
||||
const INTERMEDIATE: [u8; 4] = [0xee; 4];
|
||||
const PADDED_INTERMEDIATE: [u8; 4] = [0xdd; 4];
|
||||
|
||||
pub struct ClientInit {
|
||||
pub dc: u16,
|
||||
pub media: bool,
|
||||
pub relay_init: [u8; INIT_LEN],
|
||||
pub crypto: CryptoContext,
|
||||
}
|
||||
|
||||
pub struct CryptoContext {
|
||||
client_decrypt: AesCtr,
|
||||
client_encrypt: AesCtr,
|
||||
telegram_encrypt: AesCtr,
|
||||
telegram_decrypt: AesCtr,
|
||||
}
|
||||
|
||||
impl CryptoContext {
|
||||
pub fn client_to_telegram(&mut self, data: &mut [u8]) {
|
||||
self.client_decrypt.apply_keystream(data);
|
||||
self.telegram_encrypt.apply_keystream(data);
|
||||
}
|
||||
|
||||
pub fn telegram_to_client(&mut self, data: &mut [u8]) {
|
||||
self.telegram_decrypt.apply_keystream(data);
|
||||
self.client_encrypt.apply_keystream(data);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn generate_secret() -> [u8; 16] {
|
||||
let mut secret = [0; 16];
|
||||
OsRng.fill_bytes(&mut secret);
|
||||
secret
|
||||
}
|
||||
|
||||
/// Reuse the secret stored at `path`, creating it if it is missing or unusable.
|
||||
///
|
||||
/// 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(secret) = parse_secret_hex(value.trim()) {
|
||||
return secret;
|
||||
}
|
||||
}
|
||||
|
||||
let secret = generate_secret();
|
||||
if let Some(parent) = path.parent() {
|
||||
let _ = std::fs::create_dir_all(parent);
|
||||
}
|
||||
write_secret_file(path, &secret_hex(&secret));
|
||||
secret
|
||||
}
|
||||
|
||||
#[cfg(not(test))]
|
||||
pub fn load_or_create_secret() -> [u8; 16] {
|
||||
match secret_path() {
|
||||
Some(path) => load_or_create_secret_at(&path),
|
||||
None => generate_secret(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(test))]
|
||||
fn secret_path() -> Option<PathBuf> {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
std::env::var_os("APPDATA")
|
||||
.map(PathBuf::from)
|
||||
.map(|path| path.join("TGLock").join("secret"))
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
std::env::var_os("HOME")
|
||||
.map(PathBuf::from)
|
||||
.map(|path| path.join("Library/Application Support/TGLock/secret"))
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
if let Some(path) = std::env::var_os("XDG_CONFIG_HOME") {
|
||||
return Some(PathBuf::from(path).join("tglock").join("secret"));
|
||||
}
|
||||
std::env::var_os("HOME")
|
||||
.map(PathBuf::from)
|
||||
.map(|path| path.join(".config/tglock/secret"))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
fn write_secret_file(path: &Path, value: &str) {
|
||||
use std::io::Write;
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
if let Ok(mut file) = std::fs::OpenOptions::new()
|
||||
.create(true)
|
||||
.truncate(true)
|
||||
.write(true)
|
||||
.mode(0o600)
|
||||
.open(path)
|
||||
{
|
||||
let _ = file.write_all(value.as_bytes());
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(not(unix))]
|
||||
fn write_secret_file(path: &Path, value: &str) {
|
||||
let _ = std::fs::write(path, value);
|
||||
}
|
||||
|
||||
pub fn secret_hex(secret: &[u8; 16]) -> String {
|
||||
let mut output = String::with_capacity(32);
|
||||
for byte in secret {
|
||||
use std::fmt::Write;
|
||||
let _ = write!(output, "{:02x}", byte);
|
||||
}
|
||||
output
|
||||
}
|
||||
|
||||
fn parse_secret_hex(value: &str) -> Option<[u8; 16]> {
|
||||
if value.len() != 32 {
|
||||
return None;
|
||||
}
|
||||
let mut secret = [0; 16];
|
||||
for (index, byte) in secret.iter_mut().enumerate() {
|
||||
*byte = u8::from_str_radix(&value[index * 2..index * 2 + 2], 16).ok()?;
|
||||
}
|
||||
Some(secret)
|
||||
}
|
||||
|
||||
pub fn telegram_secret(secret: &[u8; 16]) -> String {
|
||||
format!("dd{}", secret_hex(secret))
|
||||
}
|
||||
|
||||
pub fn parse_client_init(init: &[u8; INIT_LEN], secret: &[u8; 16]) -> Option<ClientInit> {
|
||||
let client_dec_key = secret_key(&init[KEY_START..KEY_END], secret);
|
||||
let client_dec_iv: [u8; 16] = init[KEY_END..IV_END].try_into().ok()?;
|
||||
let mut client_decrypt = AesCtr::new((&client_dec_key).into(), (&client_dec_iv).into());
|
||||
|
||||
let mut decrypted = *init;
|
||||
client_decrypt.apply_keystream(&mut decrypted);
|
||||
let protocol_tag: [u8; 4] = decrypted[TAG_START..DC_START].try_into().ok()?;
|
||||
if !matches!(protocol_tag, ABRIDGED | INTERMEDIATE | PADDED_INTERMEDIATE) {
|
||||
return None;
|
||||
}
|
||||
|
||||
let dc_index = i16::from_le_bytes([decrypted[DC_START], decrypted[DC_START + 1]]);
|
||||
let dc = dc_index.unsigned_abs();
|
||||
if !matches!(dc, 1..=5 | 203) {
|
||||
return None;
|
||||
}
|
||||
|
||||
let relay_init = generate_relay_init(protocol_tag, dc_index);
|
||||
let crypto = build_crypto_context(init, secret, &relay_init)?;
|
||||
Some(ClientInit {
|
||||
dc,
|
||||
media: dc_index < 0,
|
||||
relay_init,
|
||||
crypto,
|
||||
})
|
||||
}
|
||||
|
||||
fn secret_key(prekey: &[u8], secret: &[u8; 16]) -> [u8; 32] {
|
||||
let mut hash = Sha256::new();
|
||||
hash.update(prekey);
|
||||
hash.update(secret);
|
||||
hash.finalize().into()
|
||||
}
|
||||
|
||||
fn generate_relay_init(protocol_tag: [u8; 4], dc_index: i16) -> [u8; INIT_LEN] {
|
||||
loop {
|
||||
let mut init = [0; INIT_LEN];
|
||||
OsRng.fill_bytes(&mut init);
|
||||
if is_reserved_init(&init) {
|
||||
continue;
|
||||
}
|
||||
|
||||
let key: [u8; 32] = init[KEY_START..KEY_END].try_into().unwrap();
|
||||
let iv: [u8; 16] = init[KEY_END..IV_END].try_into().unwrap();
|
||||
let mut cipher = AesCtr::new((&key).into(), (&iv).into());
|
||||
let mut encrypted = init;
|
||||
cipher.apply_keystream(&mut encrypted);
|
||||
|
||||
let mut tail = [0; 8];
|
||||
tail[..4].copy_from_slice(&protocol_tag);
|
||||
tail[4..6].copy_from_slice(&dc_index.to_le_bytes());
|
||||
OsRng.fill_bytes(&mut tail[6..]);
|
||||
for index in 0..8 {
|
||||
init[TAG_START + index] ^= tail[index] ^ encrypted[TAG_START + index];
|
||||
}
|
||||
return init;
|
||||
}
|
||||
}
|
||||
|
||||
fn is_reserved_init(init: &[u8; INIT_LEN]) -> bool {
|
||||
init[0] == 0xef
|
||||
|| &init[..4] == b"HEAD"
|
||||
|| &init[..4] == b"POST"
|
||||
|| &init[..4] == b"GET "
|
||||
|| init[..4] == [0xee; 4]
|
||||
|| init[..4] == [0xdd; 4]
|
||||
|| init[..4] == [0x16, 0x03, 0x01, 0x02]
|
||||
|| init[4..8] == [0; 4]
|
||||
}
|
||||
|
||||
fn build_crypto_context(
|
||||
client_init: &[u8; INIT_LEN],
|
||||
secret: &[u8; 16],
|
||||
relay_init: &[u8; INIT_LEN],
|
||||
) -> Option<CryptoContext> {
|
||||
let client_dec_key = secret_key(&client_init[KEY_START..KEY_END], secret);
|
||||
let client_dec_iv: [u8; 16] = client_init[KEY_END..IV_END].try_into().ok()?;
|
||||
let mut client_decrypt = AesCtr::new((&client_dec_key).into(), (&client_dec_iv).into());
|
||||
client_decrypt.apply_keystream(&mut [0; INIT_LEN]);
|
||||
|
||||
let reversed_client: Vec<_> = client_init[KEY_START..IV_END]
|
||||
.iter()
|
||||
.rev()
|
||||
.copied()
|
||||
.collect();
|
||||
let client_enc_key = secret_key(&reversed_client[..32], secret);
|
||||
let client_enc_iv: [u8; 16] = reversed_client[32..].try_into().ok()?;
|
||||
let client_encrypt = AesCtr::new((&client_enc_key).into(), (&client_enc_iv).into());
|
||||
|
||||
let relay_enc_key: [u8; 32] = relay_init[KEY_START..KEY_END].try_into().ok()?;
|
||||
let relay_enc_iv: [u8; 16] = relay_init[KEY_END..IV_END].try_into().ok()?;
|
||||
let mut telegram_encrypt = AesCtr::new((&relay_enc_key).into(), (&relay_enc_iv).into());
|
||||
telegram_encrypt.apply_keystream(&mut [0; INIT_LEN]);
|
||||
|
||||
let reversed_relay: Vec<_> = relay_init[KEY_START..IV_END]
|
||||
.iter()
|
||||
.rev()
|
||||
.copied()
|
||||
.collect();
|
||||
let relay_dec_key: [u8; 32] = reversed_relay[..32].try_into().ok()?;
|
||||
let relay_dec_iv: [u8; 16] = reversed_relay[32..].try_into().ok()?;
|
||||
let telegram_decrypt = AesCtr::new((&relay_dec_key).into(), (&relay_dec_iv).into());
|
||||
|
||||
Some(CryptoContext {
|
||||
client_decrypt,
|
||||
client_encrypt,
|
||||
telegram_encrypt,
|
||||
telegram_decrypt,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
pub(crate) fn test_client_init(secret: &[u8; 16], dc_index: i16) -> [u8; INIT_LEN] {
|
||||
tests::generate_client_init(secret, PADDED_INTERMEDIATE, dc_index)
|
||||
}
|
||||
|
||||
/// One end of an obfuscated2 stream, built the way the real peer builds it.
|
||||
///
|
||||
/// Lets tests assert on the bytes the peer actually observes rather than on the
|
||||
/// proxy's own view of them, so a mistake that is symmetric inside
|
||||
/// [`CryptoContext`] still fails the test.
|
||||
#[cfg(test)]
|
||||
pub(crate) struct TestPeer {
|
||||
encrypt: AesCtr,
|
||||
decrypt: AesCtr,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl TestPeer {
|
||||
pub(crate) fn encrypt(&mut self, data: &mut [u8]) {
|
||||
self.encrypt.apply_keystream(data);
|
||||
}
|
||||
|
||||
pub(crate) fn decrypt(&mut self, data: &mut [u8]) {
|
||||
self.decrypt.apply_keystream(data);
|
||||
}
|
||||
}
|
||||
|
||||
/// The Telegram client: its keys come from the init it sent, salted with the
|
||||
/// shared secret.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn test_client_peer(init: &[u8; INIT_LEN], secret: &[u8; 16]) -> TestPeer {
|
||||
let key = secret_key(&init[KEY_START..KEY_END], secret);
|
||||
let iv: [u8; 16] = init[KEY_END..IV_END].try_into().unwrap();
|
||||
let mut encrypt = AesCtr::new((&key).into(), (&iv).into());
|
||||
encrypt.apply_keystream(&mut [0; INIT_LEN]);
|
||||
|
||||
let reversed: Vec<u8> = init[KEY_START..IV_END].iter().rev().copied().collect();
|
||||
let decrypt_key = secret_key(&reversed[..32], secret);
|
||||
let decrypt_iv: [u8; 16] = reversed[32..].try_into().unwrap();
|
||||
let decrypt = AesCtr::new((&decrypt_key).into(), (&decrypt_iv).into());
|
||||
|
||||
TestPeer { encrypt, decrypt }
|
||||
}
|
||||
|
||||
/// The Telegram relay: no shared secret, keys come straight from the init the
|
||||
/// proxy generated for it.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn test_relay_peer(relay_init: &[u8; INIT_LEN]) -> TestPeer {
|
||||
let key: [u8; 32] = relay_init[KEY_START..KEY_END].try_into().unwrap();
|
||||
let iv: [u8; 16] = relay_init[KEY_END..IV_END].try_into().unwrap();
|
||||
let mut decrypt = AesCtr::new((&key).into(), (&iv).into());
|
||||
decrypt.apply_keystream(&mut [0; INIT_LEN]);
|
||||
|
||||
let reversed: Vec<u8> = relay_init[KEY_START..IV_END]
|
||||
.iter()
|
||||
.rev()
|
||||
.copied()
|
||||
.collect();
|
||||
let encrypt_key: [u8; 32] = reversed[..32].try_into().unwrap();
|
||||
let encrypt_iv: [u8; 16] = reversed[32..].try_into().unwrap();
|
||||
let encrypt = AesCtr::new((&encrypt_key).into(), (&encrypt_iv).into());
|
||||
|
||||
TestPeer { encrypt, decrypt }
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
pub(super) fn generate_client_init(
|
||||
secret: &[u8; 16],
|
||||
protocol_tag: [u8; 4],
|
||||
dc_index: i16,
|
||||
) -> [u8; INIT_LEN] {
|
||||
let mut init = generate_relay_init(protocol_tag, dc_index);
|
||||
let key = secret_key(&init[KEY_START..KEY_END], secret);
|
||||
let iv: [u8; 16] = init[KEY_END..IV_END].try_into().unwrap();
|
||||
let mut cipher = AesCtr::new((&key).into(), (&iv).into());
|
||||
let mut encrypted = init;
|
||||
cipher.apply_keystream(&mut encrypted);
|
||||
|
||||
let mut tail = [0; 8];
|
||||
tail[..4].copy_from_slice(&protocol_tag);
|
||||
tail[4..6].copy_from_slice(&dc_index.to_le_bytes());
|
||||
tail[6..].copy_from_slice(&[17, 23]);
|
||||
for index in 0..8 {
|
||||
init[TAG_START + index] ^= tail[index] ^ encrypted[TAG_START + index];
|
||||
}
|
||||
init
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_secret_protected_media_init() {
|
||||
let secret = [42; 16];
|
||||
let init = generate_client_init(&secret, PADDED_INTERMEDIATE, -4);
|
||||
let parsed = parse_client_init(&init, &secret).unwrap();
|
||||
assert_eq!(parsed.dc, 4);
|
||||
assert!(parsed.media);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_wrong_secret() {
|
||||
let init = generate_client_init(&[42; 16], INTERMEDIATE, 2);
|
||||
assert!(parse_client_init(&init, &[7; 16]).is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn telegram_link_secret_has_padded_intermediate_prefix() {
|
||||
assert_eq!(
|
||||
telegram_secret(&[0xab; 16]),
|
||||
"ddabababababababababababababababab"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn accepts_every_supported_protocol_tag() {
|
||||
let secret = [7; 16];
|
||||
for tag in [ABRIDGED, INTERMEDIATE, PADDED_INTERMEDIATE] {
|
||||
let init = generate_client_init(&secret, tag, 2);
|
||||
let parsed = parse_client_init(&init, &secret)
|
||||
.unwrap_or_else(|| panic!("tag {tag:02x?} must be accepted"));
|
||||
assert_eq!(parsed.dc, 2);
|
||||
assert!(!parsed.media);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn relay_init_carries_the_clients_protocol_tag_and_dc() {
|
||||
let secret = [3; 16];
|
||||
for (tag, dc_index) in [
|
||||
(ABRIDGED, 1_i16),
|
||||
(INTERMEDIATE, -5),
|
||||
(PADDED_INTERMEDIATE, 203),
|
||||
] {
|
||||
let init = generate_client_init(&secret, tag, dc_index);
|
||||
let parsed = parse_client_init(&init, &secret).unwrap();
|
||||
|
||||
// The relay init is freshly generated, never the client's bytes.
|
||||
assert_ne!(parsed.relay_init, init);
|
||||
|
||||
// Decoding the relay init the way Telegram does must recover the
|
||||
// same protocol and data centre the client asked for.
|
||||
let key: [u8; 32] = parsed.relay_init[KEY_START..KEY_END].try_into().unwrap();
|
||||
let iv: [u8; 16] = parsed.relay_init[KEY_END..IV_END].try_into().unwrap();
|
||||
let mut cipher = AesCtr::new((&key).into(), (&iv).into());
|
||||
let mut decoded = parsed.relay_init;
|
||||
cipher.apply_keystream(&mut decoded);
|
||||
|
||||
assert_eq!(decoded[TAG_START..DC_START], tag);
|
||||
assert_eq!(
|
||||
i16::from_le_bytes([decoded[DC_START], decoded[DC_START + 1]]),
|
||||
dc_index
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rejects_data_centers_outside_the_known_range() {
|
||||
let secret = [11; 16];
|
||||
for dc_index in [0_i16, 6, -6, 204, -204, 1000] {
|
||||
let init = generate_client_init(&secret, INTERMEDIATE, dc_index);
|
||||
assert!(
|
||||
parse_client_init(&init, &secret).is_none(),
|
||||
"DC index {dc_index} must be rejected"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn negative_index_marks_media_and_keeps_the_data_center() {
|
||||
let secret = [13; 16];
|
||||
for dc in [1_u16, 2, 3, 4, 5, 203] {
|
||||
let index = -(dc as i16);
|
||||
let parsed =
|
||||
parse_client_init(&generate_client_init(&secret, ABRIDGED, index), &secret)
|
||||
.unwrap();
|
||||
assert_eq!(parsed.dc, dc);
|
||||
assert!(parsed.media);
|
||||
|
||||
let parsed =
|
||||
parse_client_init(&generate_client_init(&secret, ABRIDGED, dc as i16), &secret)
|
||||
.unwrap();
|
||||
assert_eq!(parsed.dc, dc);
|
||||
assert!(!parsed.media);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn plaintext_survives_the_trip_to_the_relay_and_back() {
|
||||
let secret = [42; 16];
|
||||
let init = generate_client_init(&secret, ABRIDGED, 2);
|
||||
let mut parsed = parse_client_init(&init, &secret).unwrap();
|
||||
let mut client = test_client_peer(&init, &secret);
|
||||
let mut relay = test_relay_peer(&parsed.relay_init);
|
||||
|
||||
let request = b"exactly what Telegram must receive".to_vec();
|
||||
let mut wire = request.clone();
|
||||
client.encrypt(&mut wire);
|
||||
assert_ne!(wire, request, "the wire must not carry plaintext");
|
||||
parsed.crypto.client_to_telegram(&mut wire);
|
||||
assert_ne!(wire, request, "the upstream wire must not carry plaintext");
|
||||
relay.decrypt(&mut wire);
|
||||
assert_eq!(wire, request);
|
||||
|
||||
let response = b"exactly what the client must receive".to_vec();
|
||||
let mut wire = response.clone();
|
||||
relay.encrypt(&mut wire);
|
||||
parsed.crypto.telegram_to_client(&mut wire);
|
||||
client.decrypt(&mut wire);
|
||||
assert_eq!(wire, response);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keystream_advances_across_chunks() {
|
||||
let secret = [5; 16];
|
||||
let init = generate_client_init(&secret, INTERMEDIATE, 3);
|
||||
let mut parsed = parse_client_init(&init, &secret).unwrap();
|
||||
let mut client = test_client_peer(&init, &secret);
|
||||
let mut relay = test_relay_peer(&parsed.relay_init);
|
||||
|
||||
// A stream cipher is only correct if both ends stay in lockstep across
|
||||
// arbitrary chunk boundaries, which is how TCP actually delivers data.
|
||||
let chunks: [&[u8]; 4] = [b"one", b"", b"the third chunk is longer", b"4"];
|
||||
for chunk in chunks {
|
||||
let mut wire = chunk.to_vec();
|
||||
client.encrypt(&mut wire);
|
||||
parsed.crypto.client_to_telegram(&mut wire);
|
||||
relay.decrypt(&mut wire);
|
||||
assert_eq!(wire, chunk);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reserved_prefixes_never_leave_the_generator() {
|
||||
// A relay init that starts with an HTTP verb or a protocol tag would be
|
||||
// misread by Telegram's frontend.
|
||||
for _ in 0..2_000 {
|
||||
assert!(!is_reserved_init(&generate_relay_init(ABRIDGED, 2)));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parses_persisted_secret() {
|
||||
assert_eq!(
|
||||
parse_secret_hex("00112233445566778899aabbccddeeff"),
|
||||
Some([
|
||||
0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd,
|
||||
0xee, 0xff,
|
||||
])
|
||||
);
|
||||
assert_eq!(parse_secret_hex("not-a-secret"), None);
|
||||
}
|
||||
}
|
||||
-176
@@ -1,176 +0,0 @@
|
||||
use std::net::{TcpStream, SocketAddr};
|
||||
use std::process::Command;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
pub fn detect_adapter() -> Option<String> {
|
||||
let output = Command::new("powershell")
|
||||
.args([
|
||||
"-Command",
|
||||
"(Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Select-Object -First 1).Name",
|
||||
])
|
||||
.output()
|
||||
.ok()?;
|
||||
|
||||
let name = String::from_utf8_lossy(&output.stdout).trim().to_string();
|
||||
if name.is_empty() {
|
||||
None
|
||||
} else {
|
||||
Some(name)
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_current_dns() -> Option<String> {
|
||||
let output = Command::new("powershell")
|
||||
.args([
|
||||
"-Command",
|
||||
"Get-DnsClientServerAddress -AddressFamily IPv4 | Where-Object {$_.ServerAddresses.Count -gt 0} | Select-Object -First 1 -ExpandProperty ServerAddresses | Out-String",
|
||||
])
|
||||
.output()
|
||||
.ok()?;
|
||||
|
||||
let result = String::from_utf8_lossy(&output.stdout).trim().to_string();
|
||||
if result.is_empty() {
|
||||
Some("Не определено".to_string())
|
||||
} else {
|
||||
Some(result.replace('\n', ", ").replace('\r', ""))
|
||||
}
|
||||
}
|
||||
|
||||
pub fn ping_host(ip: &str) -> (bool, Option<u64>) {
|
||||
let start = Instant::now();
|
||||
let output = Command::new("ping")
|
||||
.args(["-n", "1", "-w", "3000", ip])
|
||||
.output();
|
||||
|
||||
match output {
|
||||
Ok(out) => {
|
||||
let elapsed = start.elapsed().as_millis() as u64;
|
||||
let stdout = String::from_utf8_lossy(&out.stdout);
|
||||
let ok = out.status.success() && (stdout.contains("TTL=") || stdout.contains("ttl="));
|
||||
|
||||
if ok {
|
||||
// Try to extract actual time from ping output
|
||||
if let Some(time_str) = extract_ping_time(&stdout) {
|
||||
(true, Some(time_str))
|
||||
} else {
|
||||
(true, Some(elapsed))
|
||||
}
|
||||
} else {
|
||||
(false, None)
|
||||
}
|
||||
}
|
||||
Err(_) => (false, None),
|
||||
}
|
||||
}
|
||||
|
||||
fn extract_ping_time(output: &str) -> Option<u64> {
|
||||
// Match patterns like "time=46ms" or "time<1ms" or "время=46мс"
|
||||
for line in output.lines() {
|
||||
let lower = line.to_lowercase();
|
||||
if let Some(pos) = lower.find("time=").or_else(|| lower.find("time<")) {
|
||||
let after = &lower[pos + 5..];
|
||||
let num: String = after.chars().take_while(|c| c.is_ascii_digit()).collect();
|
||||
if let Ok(ms) = num.parse::<u64>() {
|
||||
return Some(ms);
|
||||
}
|
||||
}
|
||||
// Russian locale
|
||||
if let Some(pos) = lower.find("=").filter(|_| lower.contains("ms") || lower.contains("мс")) {
|
||||
let after = &lower[pos + 1..];
|
||||
let num: String = after.chars().take_while(|c| c.is_ascii_digit()).collect();
|
||||
if let Ok(ms) = num.parse::<u64>() {
|
||||
if ms < 10000 {
|
||||
return Some(ms);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
pub fn tcp_check(ip: &str, port: u16) -> (bool, Option<u64>) {
|
||||
let addr: SocketAddr = format!("{}:{}", ip, port).parse().unwrap();
|
||||
let start = Instant::now();
|
||||
match TcpStream::connect_timeout(&addr, Duration::from_secs(5)) {
|
||||
Ok(_stream) => {
|
||||
let elapsed = start.elapsed().as_millis() as u64;
|
||||
(true, Some(elapsed))
|
||||
}
|
||||
Err(_) => (false, None),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn https_check(url: &str) -> (bool, Option<u64>) {
|
||||
let start = Instant::now();
|
||||
let client = reqwest::blocking::Client::builder()
|
||||
.timeout(Duration::from_secs(10))
|
||||
.danger_accept_invalid_certs(true)
|
||||
.build();
|
||||
|
||||
match client {
|
||||
Ok(c) => match c.get(url).send() {
|
||||
Ok(resp) => {
|
||||
let elapsed = start.elapsed().as_millis() as u64;
|
||||
(resp.status().is_success(), Some(elapsed))
|
||||
}
|
||||
Err(_) => (false, None),
|
||||
},
|
||||
Err(_) => (false, None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Benchmarks Telegram connectivity: runs multiple TCP+HTTPS checks,
|
||||
/// returns (works: bool, score: u64) where lower score = faster connection.
|
||||
/// Score is average latency across all successful checks. u64::MAX if nothing works.
|
||||
pub fn benchmark_telegram() -> (bool, u64) {
|
||||
let tcp_targets = [
|
||||
("149.154.167.51", 443u16),
|
||||
("149.154.175.50", 443),
|
||||
("149.154.167.91", 443),
|
||||
("91.108.56.100", 443),
|
||||
];
|
||||
|
||||
let mut total_ms: u64 = 0;
|
||||
let mut ok_count: u64 = 0;
|
||||
let mut fail_count: u64 = 0;
|
||||
|
||||
// TCP checks (x2 rounds for stability)
|
||||
for _ in 0..2 {
|
||||
for (ip, port) in &tcp_targets {
|
||||
let (ok, latency) = tcp_check(ip, *port);
|
||||
if ok {
|
||||
total_ms += latency.unwrap_or(5000);
|
||||
ok_count += 1;
|
||||
} else {
|
||||
fail_count += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// HTTPS check — the real indicator of usable speed
|
||||
let https_urls = [
|
||||
"https://web.telegram.org",
|
||||
"https://t.me",
|
||||
];
|
||||
for url in &https_urls {
|
||||
let (ok, latency) = https_check(url);
|
||||
if ok {
|
||||
// Weight HTTPS 3x heavier since it's closer to real usage
|
||||
let ms = latency.unwrap_or(10000);
|
||||
total_ms += ms * 3;
|
||||
ok_count += 3;
|
||||
} else {
|
||||
fail_count += 3;
|
||||
}
|
||||
}
|
||||
|
||||
if ok_count == 0 {
|
||||
return (false, u64::MAX);
|
||||
}
|
||||
|
||||
// Penalize failures: each fail adds 2000ms to the score
|
||||
let penalty = fail_count * 2000;
|
||||
let avg = (total_ms + penalty) / (ok_count + fail_count);
|
||||
|
||||
(true, avg)
|
||||
}
|
||||
+1086
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,729 @@
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Mutex;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use tokio::net::TcpStream;
|
||||
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
|
||||
use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
|
||||
|
||||
const CONNECT_TIMEOUT: Duration = Duration::from_secs(4);
|
||||
const FAILURE_BACKOFF_INITIAL: Duration = Duration::from_secs(30);
|
||||
const FAILURE_BACKOFF_MAX: Duration = Duration::from_secs(30 * 60);
|
||||
const HTTPS_PORT: u16 = 443;
|
||||
|
||||
pub type TelegramWebSocket = WebSocketStream<MaybeTlsStream<TcpStream>>;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
pub enum RouteKind {
|
||||
TelegramIp,
|
||||
AlternateTelegramIp,
|
||||
SystemDns,
|
||||
CloudflareWorker,
|
||||
}
|
||||
|
||||
impl RouteKind {
|
||||
pub fn ui_code(self) -> u8 {
|
||||
match self {
|
||||
Self::TelegramIp => 1,
|
||||
Self::AlternateTelegramIp => 2,
|
||||
Self::SystemDns => 3,
|
||||
Self::CloudflareWorker => 4,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_ui_code(code: u8) -> Option<Self> {
|
||||
match code {
|
||||
1 => Some(Self::TelegramIp),
|
||||
2 => Some(Self::AlternateTelegramIp),
|
||||
3 => Some(Self::SystemDns),
|
||||
4 => Some(Self::CloudflareWorker),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Human-readable name of the route, shown by both frontends.
|
||||
pub fn label(self) -> &'static str {
|
||||
match self {
|
||||
Self::TelegramIp => "Telegram IP",
|
||||
Self::AlternateTelegramIp => "Запасной Telegram IP",
|
||||
Self::SystemDns => "Системный DNS",
|
||||
Self::CloudflareWorker => "Cloudflare Worker",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Label for a route code as stored in `Stats::last_route`.
|
||||
///
|
||||
/// Code `0` means no tunnel has been established yet, which must never be
|
||||
/// reported as a working route.
|
||||
pub fn route_label(ui_code: u8) -> &'static str {
|
||||
RouteKind::from_ui_code(ui_code).map_or("Маршрут ещё не выбран", RouteKind::label)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
|
||||
pub struct Route {
|
||||
pub connect_host: String,
|
||||
pub websocket_host: String,
|
||||
pub path: String,
|
||||
pub kind: RouteKind,
|
||||
/// TCP port to dial. Always 443 for Telegram and for Cloudflare Workers.
|
||||
pub port: u16,
|
||||
/// Wrap the connection in TLS. Always true outside tests.
|
||||
pub secure: bool,
|
||||
}
|
||||
|
||||
impl Route {
|
||||
/// A production route: TLS on 443.
|
||||
fn https(connect_host: String, websocket_host: String, path: String, kind: RouteKind) -> Self {
|
||||
Self {
|
||||
connect_host,
|
||||
websocket_host,
|
||||
path,
|
||||
kind,
|
||||
port: HTTPS_PORT,
|
||||
secure: true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct ConnectedRoute {
|
||||
pub route: Route,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
|
||||
struct DcKey {
|
||||
dc: u16,
|
||||
media: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
struct RouteHealth {
|
||||
failures: u32,
|
||||
retry_at: Instant,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct HealthState {
|
||||
routes: HashMap<Route, RouteHealth>,
|
||||
preferred: HashMap<DcKey, Route>,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct TransportEngine {
|
||||
health: Mutex<HealthState>,
|
||||
worker_domains: Mutex<Vec<String>>,
|
||||
#[cfg(test)]
|
||||
forced_routes: Mutex<Vec<Route>>,
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl TransportEngine {
|
||||
/// Point every data centre at a local plaintext WebSocket server so the
|
||||
/// whole tunnel can be exercised without reaching Telegram.
|
||||
pub(crate) fn force_local_route(&self, port: u16) {
|
||||
self.force_local_route_with(port, RouteKind::TelegramIp, "/apiws".to_owned());
|
||||
}
|
||||
|
||||
pub(crate) fn force_local_route_with(&self, port: u16, kind: RouteKind, path: String) {
|
||||
*self.forced_routes.lock().unwrap() = vec![Route {
|
||||
connect_host: "127.0.0.1".to_owned(),
|
||||
websocket_host: format!("127.0.0.1:{}", port),
|
||||
path,
|
||||
kind,
|
||||
port,
|
||||
secure: false,
|
||||
}];
|
||||
}
|
||||
}
|
||||
|
||||
impl TransportEngine {
|
||||
pub fn new() -> Self {
|
||||
Self::default()
|
||||
}
|
||||
|
||||
pub fn set_worker_domains(&self, domains: &[String]) {
|
||||
let mut normalized = Vec::new();
|
||||
for domain in domains {
|
||||
let domain = domain.trim().to_ascii_lowercase();
|
||||
if valid_domain(&domain) && !normalized.contains(&domain) {
|
||||
normalized.push(domain);
|
||||
}
|
||||
}
|
||||
*self.worker_domains.lock().unwrap() = normalized;
|
||||
}
|
||||
|
||||
pub async fn connect(
|
||||
&self,
|
||||
dc: u16,
|
||||
media: bool,
|
||||
) -> Result<(TelegramWebSocket, ConnectedRoute), String> {
|
||||
let key = DcKey { dc, media };
|
||||
let candidates = self.ordered_candidates(key);
|
||||
let mut errors = Vec::new();
|
||||
|
||||
for route in candidates {
|
||||
match connect_route(&route).await {
|
||||
Ok(websocket) => {
|
||||
self.record_success(key, &route);
|
||||
return Ok((websocket, ConnectedRoute { route }));
|
||||
}
|
||||
Err(error) => {
|
||||
self.record_failure(&route);
|
||||
errors.push(format!(
|
||||
"{} via {}: {}",
|
||||
route.websocket_host, route.connect_host, error
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Err(format!(
|
||||
"all Telegram routes for DC{}{} failed: {}",
|
||||
dc,
|
||||
if media { " media" } else { "" },
|
||||
errors.join("; ")
|
||||
))
|
||||
}
|
||||
|
||||
fn ordered_candidates(&self, key: DcKey) -> Vec<Route> {
|
||||
let now = Instant::now();
|
||||
let all_routes = self.routes_for_key(key);
|
||||
let health = self.health.lock().unwrap();
|
||||
let preferred = health.preferred.get(&key);
|
||||
let mut candidates: Vec<_> = all_routes
|
||||
.iter()
|
||||
.filter(|route| {
|
||||
health
|
||||
.routes
|
||||
.get(route)
|
||||
.is_none_or(|route_health| route_health.retry_at <= now)
|
||||
})
|
||||
.cloned()
|
||||
.collect();
|
||||
|
||||
candidates.sort_by_key(|route| {
|
||||
let preferred_rank = u8::from(preferred != Some(route));
|
||||
let kind_rank = match route.kind {
|
||||
RouteKind::TelegramIp => 0,
|
||||
RouteKind::AlternateTelegramIp => 1,
|
||||
RouteKind::SystemDns => 2,
|
||||
RouteKind::CloudflareWorker => 3,
|
||||
};
|
||||
(preferred_rank, kind_rank)
|
||||
});
|
||||
|
||||
// If every route is cooling down, retry the one that becomes available first.
|
||||
if candidates.is_empty() {
|
||||
if let Some((route, _)) = health
|
||||
.routes
|
||||
.iter()
|
||||
.filter(|(route, _)| all_routes.contains(route))
|
||||
.min_by_key(|(_, route_health)| route_health.retry_at)
|
||||
{
|
||||
candidates.push(route.clone());
|
||||
}
|
||||
}
|
||||
candidates
|
||||
}
|
||||
|
||||
fn routes_for_key(&self, key: DcKey) -> Vec<Route> {
|
||||
#[cfg(test)]
|
||||
{
|
||||
let forced = self.forced_routes.lock().unwrap();
|
||||
if !forced.is_empty() {
|
||||
return forced.clone();
|
||||
}
|
||||
}
|
||||
|
||||
let mut routes = routes_for_dc(key.dc, key.media);
|
||||
let Some(path) = worker_path(key.dc) else {
|
||||
return routes;
|
||||
};
|
||||
for domain in self.worker_domains.lock().unwrap().iter() {
|
||||
let path = path.clone();
|
||||
routes.push(Route::https(
|
||||
domain.clone(),
|
||||
domain.clone(),
|
||||
path,
|
||||
RouteKind::CloudflareWorker,
|
||||
));
|
||||
}
|
||||
routes
|
||||
}
|
||||
|
||||
fn record_success(&self, key: DcKey, route: &Route) {
|
||||
let mut health = self.health.lock().unwrap();
|
||||
health.routes.remove(route);
|
||||
health.preferred.insert(key, route.clone());
|
||||
}
|
||||
|
||||
fn record_failure(&self, route: &Route) {
|
||||
let mut health = self.health.lock().unwrap();
|
||||
let failures = health
|
||||
.routes
|
||||
.get(route)
|
||||
.map_or(1, |route_health| route_health.failures.saturating_add(1));
|
||||
let exponent = failures.saturating_sub(1).min(6);
|
||||
let delay = FAILURE_BACKOFF_INITIAL
|
||||
.saturating_mul(2_u32.pow(exponent))
|
||||
.min(FAILURE_BACKOFF_MAX);
|
||||
health.routes.insert(
|
||||
route.clone(),
|
||||
RouteHealth {
|
||||
failures,
|
||||
retry_at: Instant::now() + delay,
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Path a user's Cloudflare Worker must serve for the given data centre.
|
||||
///
|
||||
/// This is the contract documented in `docs/CLOUDFLARE_WORKER.md`; both the
|
||||
/// route builder and the tests derive the path from here so the documentation
|
||||
/// cannot drift away from what the client actually requests.
|
||||
pub(crate) fn worker_path(dc: u16) -> Option<String> {
|
||||
let destination = telegram_ips(dc).first()?;
|
||||
Some(format!("/apiws?dst={}&dc={}", destination, dc))
|
||||
}
|
||||
|
||||
/// Every address a Worker may be asked to reach, so a deployment can refuse
|
||||
/// anything else instead of becoming an open TCP proxy.
|
||||
pub fn worker_allowed_destinations() -> Vec<&'static str> {
|
||||
let mut all: Vec<_> = [1, 2, 3, 4, 5, 203]
|
||||
.into_iter()
|
||||
.flat_map(|dc| telegram_ips(dc).iter().copied())
|
||||
.collect();
|
||||
all.sort_unstable();
|
||||
all.dedup();
|
||||
all
|
||||
}
|
||||
|
||||
fn canonical_dc(dc: u16) -> u16 {
|
||||
if dc == 203 {
|
||||
2
|
||||
} else {
|
||||
dc
|
||||
}
|
||||
}
|
||||
|
||||
fn telegram_ips(dc: u16) -> &'static [&'static str] {
|
||||
match dc {
|
||||
1 => &["149.154.175.50"],
|
||||
2 => &["149.154.167.51", "149.154.167.220"],
|
||||
3 => &["149.154.175.100"],
|
||||
4 => &["149.154.167.91", "149.154.167.220"],
|
||||
5 => &["149.154.171.5"],
|
||||
203 => &["91.105.192.100"],
|
||||
_ => &[],
|
||||
}
|
||||
}
|
||||
|
||||
pub fn routes_for_dc(dc: u16, media: bool) -> Vec<Route> {
|
||||
let websocket_dc = canonical_dc(dc);
|
||||
let primary = format!("kws{}.web.telegram.org", websocket_dc);
|
||||
let secondary = format!("kws{}-1.web.telegram.org", websocket_dc);
|
||||
let websocket_hosts = if media {
|
||||
[secondary, primary]
|
||||
} else {
|
||||
[primary, secondary]
|
||||
};
|
||||
let ips = telegram_ips(dc);
|
||||
let mut routes = Vec::new();
|
||||
|
||||
for websocket_host in &websocket_hosts {
|
||||
for (index, ip) in ips.iter().enumerate() {
|
||||
routes.push(Route::https(
|
||||
(*ip).to_owned(),
|
||||
websocket_host.clone(),
|
||||
"/apiws".to_owned(),
|
||||
if index == 0 {
|
||||
RouteKind::TelegramIp
|
||||
} else {
|
||||
RouteKind::AlternateTelegramIp
|
||||
},
|
||||
));
|
||||
}
|
||||
routes.push(Route::https(
|
||||
websocket_host.clone(),
|
||||
websocket_host.clone(),
|
||||
"/apiws".to_owned(),
|
||||
RouteKind::SystemDns,
|
||||
));
|
||||
}
|
||||
routes
|
||||
}
|
||||
|
||||
async fn connect_route(route: &Route) -> Result<TelegramWebSocket, String> {
|
||||
let tcp = tokio::time::timeout(
|
||||
CONNECT_TIMEOUT,
|
||||
TcpStream::connect((route.connect_host.as_str(), route.port)),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| "TCP connect timeout".to_owned())?
|
||||
.map_err(|error| format!("TCP connect: {}", error))?;
|
||||
tcp.set_nodelay(true)
|
||||
.map_err(|error| format!("TCP_NODELAY: {}", error))?;
|
||||
|
||||
let scheme = if route.secure { "wss" } else { "ws" };
|
||||
let url = format!("{}://{}{}", scheme, route.websocket_host, route.path);
|
||||
let mut request = url
|
||||
.as_str()
|
||||
.into_client_request()
|
||||
.map_err(|error| format!("WebSocket request: {}", error))?;
|
||||
request.headers_mut().insert(
|
||||
"Sec-WebSocket-Protocol",
|
||||
"binary"
|
||||
.parse()
|
||||
.map_err(|error| format!("WebSocket protocol header: {}", error))?,
|
||||
);
|
||||
|
||||
if !route.secure {
|
||||
// Only reachable from tests, which run a local WebSocket server without
|
||||
// a certificate. Production routes are always built by `Route::https`.
|
||||
return tokio::time::timeout(
|
||||
CONNECT_TIMEOUT,
|
||||
tokio_tungstenite::client_async(request, MaybeTlsStream::Plain(tcp)),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| "WebSocket timeout".to_owned())?
|
||||
.map(|(websocket, _)| websocket)
|
||||
.map_err(|error| format!("WebSocket handshake: {}", error));
|
||||
}
|
||||
|
||||
// The URI host remains the real Telegram hostname even when the TCP socket
|
||||
// is opened to a pinned IP. Native TLS therefore validates Telegram's
|
||||
// certificate and sends the correct SNI.
|
||||
let tls = native_tls::TlsConnector::new().map_err(|error| format!("TLS setup: {}", error))?;
|
||||
let connector = tokio_tungstenite::Connector::NativeTls(tls);
|
||||
tokio::time::timeout(
|
||||
CONNECT_TIMEOUT,
|
||||
tokio_tungstenite::client_async_tls_with_config(request, tcp, None, Some(connector)),
|
||||
)
|
||||
.await
|
||||
.map_err(|_| "TLS/WebSocket timeout".to_owned())?
|
||||
.map(|(websocket, _)| websocket)
|
||||
.map_err(|error| format!("TLS/WebSocket handshake: {}", error))
|
||||
}
|
||||
|
||||
fn valid_domain(domain: &str) -> bool {
|
||||
if domain.is_empty() || domain.len() > 253 || !domain.contains('.') {
|
||||
return false;
|
||||
}
|
||||
domain.split('.').all(|label| {
|
||||
!label.is_empty()
|
||||
&& label.len() <= 63
|
||||
&& !label.starts_with('-')
|
||||
&& !label.ends_with('-')
|
||||
&& label
|
||||
.chars()
|
||||
.all(|character| character.is_ascii_alphanumeric() || character == '-')
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn media_prefers_dash_one_websocket_host() {
|
||||
let routes = routes_for_dc(2, true);
|
||||
assert_eq!(routes[0].websocket_host, "kws2-1.web.telegram.org");
|
||||
assert_eq!(routes[0].connect_host, "149.154.167.51");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dc203_uses_dc2_websocket_and_its_own_ip() {
|
||||
let routes = routes_for_dc(203, false);
|
||||
assert_eq!(routes[0].websocket_host, "kws2.web.telegram.org");
|
||||
assert_eq!(routes[0].connect_host, "91.105.192.100");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn successful_route_becomes_preferred() {
|
||||
let engine = TransportEngine::new();
|
||||
let key = DcKey {
|
||||
dc: 2,
|
||||
media: false,
|
||||
};
|
||||
let preferred = routes_for_dc(2, false)[2].clone();
|
||||
engine.record_success(key, &preferred);
|
||||
assert_eq!(engine.ordered_candidates(key)[0], preferred);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_route_enters_cooldown() {
|
||||
let engine = TransportEngine::new();
|
||||
let key = DcKey {
|
||||
dc: 2,
|
||||
media: false,
|
||||
};
|
||||
let failed = routes_for_dc(2, false)[0].clone();
|
||||
engine.record_failure(&failed);
|
||||
assert!(!engine.ordered_candidates(key).contains(&failed));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn worker_is_explicit_and_validated() {
|
||||
let engine = TransportEngine::new();
|
||||
engine.set_worker_domains(&[
|
||||
"Example.User.Workers.dev".to_owned(),
|
||||
"https://invalid.example/path".to_owned(),
|
||||
]);
|
||||
let routes = engine.routes_for_key(DcKey { dc: 4, media: true });
|
||||
let worker = routes
|
||||
.iter()
|
||||
.find(|route| route.kind == RouteKind::CloudflareWorker)
|
||||
.unwrap();
|
||||
assert_eq!(worker.websocket_host, "example.user.workers.dev");
|
||||
assert_eq!(worker.path, "/apiws?dst=149.154.167.91&dc=4");
|
||||
assert_eq!(
|
||||
routes
|
||||
.iter()
|
||||
.filter(|route| route.kind == RouteKind::CloudflareWorker)
|
||||
.count(),
|
||||
1
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_production_route_is_tls_on_443() {
|
||||
let engine = TransportEngine::new();
|
||||
engine.set_worker_domains(&["fallback.workers.dev".to_owned()]);
|
||||
for dc in [1, 2, 3, 4, 5, 203] {
|
||||
for media in [false, true] {
|
||||
let routes = engine.routes_for_key(DcKey { dc, media });
|
||||
assert!(!routes.is_empty(), "DC{dc} must have at least one route");
|
||||
for route in routes {
|
||||
assert_eq!(route.port, 443, "{route:?}");
|
||||
assert!(route.secure, "{route:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_data_center_offers_a_pinned_ip_and_a_dns_route() {
|
||||
for dc in [1, 2, 3, 4, 5, 203] {
|
||||
let routes = routes_for_dc(dc, false);
|
||||
assert!(
|
||||
routes
|
||||
.iter()
|
||||
.any(|route| route.kind == RouteKind::TelegramIp),
|
||||
"DC{dc} must keep a pinned-IP route so a poisoned DNS answer is survivable"
|
||||
);
|
||||
assert!(
|
||||
routes
|
||||
.iter()
|
||||
.any(|route| route.kind == RouteKind::SystemDns),
|
||||
"DC{dc} must keep a DNS route so a stale pinned IP is survivable"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn backoff_grows_with_each_failure_and_stops_at_the_ceiling() {
|
||||
let engine = TransportEngine::new();
|
||||
let route = routes_for_dc(2, false)[0].clone();
|
||||
|
||||
// 30s doubling per failure, flattening at the 30-minute ceiling.
|
||||
let expected_seconds = [30, 60, 120, 240, 480, 960, 1800, 1800, 1800, 1800];
|
||||
for (index, expected) in expected_seconds.iter().enumerate() {
|
||||
let attempt = u32::try_from(index).unwrap() + 1;
|
||||
let before = Instant::now();
|
||||
engine.record_failure(&route);
|
||||
|
||||
let health = engine.health.lock().unwrap();
|
||||
let entry = health.routes.get(&route).unwrap();
|
||||
assert_eq!(entry.failures, attempt);
|
||||
assert_eq!(
|
||||
entry.retry_at.saturating_duration_since(before).as_secs(),
|
||||
*expected,
|
||||
"attempt {attempt} must wait {expected}s"
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
*expected_seconds.last().unwrap(),
|
||||
FAILURE_BACKOFF_MAX.as_secs(),
|
||||
"the schedule must flatten at the declared ceiling"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn success_clears_the_penalty_accumulated_by_failures() {
|
||||
let engine = TransportEngine::new();
|
||||
let key = DcKey {
|
||||
dc: 2,
|
||||
media: false,
|
||||
};
|
||||
let route = routes_for_dc(2, false)[0].clone();
|
||||
|
||||
engine.record_failure(&route);
|
||||
engine.record_failure(&route);
|
||||
assert!(!engine.ordered_candidates(key).contains(&route));
|
||||
|
||||
engine.record_success(key, &route);
|
||||
assert!(!engine.health.lock().unwrap().routes.contains_key(&route));
|
||||
assert_eq!(engine.ordered_candidates(key)[0], route);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_routes_cooling_down_still_yields_the_soonest_retry() {
|
||||
let engine = TransportEngine::new();
|
||||
let key = DcKey {
|
||||
dc: 5,
|
||||
media: false,
|
||||
};
|
||||
let routes = routes_for_dc(5, false);
|
||||
|
||||
// Fail the first route once and the rest twice, so the first one is the
|
||||
// one that becomes available again soonest.
|
||||
engine.record_failure(&routes[0]);
|
||||
for route in &routes[1..] {
|
||||
engine.record_failure(route);
|
||||
engine.record_failure(route);
|
||||
}
|
||||
|
||||
let candidates = engine.ordered_candidates(key);
|
||||
assert_eq!(
|
||||
candidates.len(),
|
||||
1,
|
||||
"a fully cooling table must offer exactly one retry, not give up"
|
||||
);
|
||||
assert_eq!(candidates[0], routes[0]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn worker_domains_are_rejected_unless_they_are_plain_hostnames() {
|
||||
let engine = TransportEngine::new();
|
||||
engine.set_worker_domains(&[
|
||||
"https://scheme.workers.dev".to_owned(),
|
||||
"with.a/path".to_owned(),
|
||||
"no-dot".to_owned(),
|
||||
"-leading.workers.dev".to_owned(),
|
||||
"trailing-.workers.dev".to_owned(),
|
||||
"under_score.workers.dev".to_owned(),
|
||||
"spaces here.dev".to_owned(),
|
||||
String::new(),
|
||||
"good.workers.dev".to_owned(),
|
||||
]);
|
||||
|
||||
let workers: Vec<_> = engine
|
||||
.routes_for_key(DcKey {
|
||||
dc: 2,
|
||||
media: false,
|
||||
})
|
||||
.into_iter()
|
||||
.filter(|route| route.kind == RouteKind::CloudflareWorker)
|
||||
.collect();
|
||||
assert_eq!(workers.len(), 1, "only the valid hostname may survive");
|
||||
assert_eq!(workers[0].websocket_host, "good.workers.dev");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn worker_domains_are_replaced_not_appended() {
|
||||
let engine = TransportEngine::new();
|
||||
let key = DcKey {
|
||||
dc: 2,
|
||||
media: false,
|
||||
};
|
||||
engine.set_worker_domains(&["first.workers.dev".to_owned()]);
|
||||
engine.set_worker_domains(&["second.workers.dev".to_owned()]);
|
||||
|
||||
let workers: Vec<_> = engine
|
||||
.routes_for_key(key)
|
||||
.into_iter()
|
||||
.filter(|route| route.kind == RouteKind::CloudflareWorker)
|
||||
.collect();
|
||||
assert_eq!(workers.len(), 1);
|
||||
assert_eq!(workers[0].websocket_host, "second.workers.dev");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn worker_is_the_last_resort() {
|
||||
let engine = TransportEngine::new();
|
||||
engine.set_worker_domains(&["fallback.workers.dev".to_owned()]);
|
||||
let key = DcKey {
|
||||
dc: 2,
|
||||
media: false,
|
||||
};
|
||||
let candidates = engine.ordered_candidates(key);
|
||||
assert_eq!(
|
||||
candidates.last().unwrap().kind,
|
||||
RouteKind::CloudflareWorker,
|
||||
"third-party infrastructure must never be tried before Telegram itself"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn documented_worker_contract_matches_the_requested_path() {
|
||||
// docs/CLOUDFLARE_WORKER.md promises exactly this shape.
|
||||
assert_eq!(
|
||||
worker_path(2).unwrap(),
|
||||
"/apiws?dst=149.154.167.51&dc=2",
|
||||
"the documented contract must match what the client requests"
|
||||
);
|
||||
assert_eq!(
|
||||
worker_path(203).unwrap(),
|
||||
"/apiws?dst=91.105.192.100&dc=203"
|
||||
);
|
||||
assert_eq!(worker_path(42), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn worker_allowlist_covers_every_address_a_route_can_ask_for() {
|
||||
let allowed = worker_allowed_destinations();
|
||||
for dc in [1, 2, 3, 4, 5, 203] {
|
||||
for ip in telegram_ips(dc) {
|
||||
assert!(
|
||||
allowed.contains(ip),
|
||||
"{ip} is reachable via a route but missing from the Worker allowlist"
|
||||
);
|
||||
}
|
||||
}
|
||||
assert_eq!(
|
||||
allowed.len(),
|
||||
7,
|
||||
"the allowlist in worker/tglock-worker.js must be updated alongside this"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn route_codes_and_labels_round_trip() {
|
||||
for kind in [
|
||||
RouteKind::TelegramIp,
|
||||
RouteKind::AlternateTelegramIp,
|
||||
RouteKind::SystemDns,
|
||||
RouteKind::CloudflareWorker,
|
||||
] {
|
||||
assert_eq!(RouteKind::from_ui_code(kind.ui_code()), Some(kind));
|
||||
assert_eq!(route_label(kind.ui_code()), kind.label());
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn code_zero_is_never_reported_as_a_working_route() {
|
||||
assert_eq!(RouteKind::from_ui_code(0), None);
|
||||
assert_eq!(RouteKind::from_ui_code(9), None);
|
||||
for kind in [
|
||||
RouteKind::TelegramIp,
|
||||
RouteKind::AlternateTelegramIp,
|
||||
RouteKind::SystemDns,
|
||||
RouteKind::CloudflareWorker,
|
||||
] {
|
||||
assert_ne!(route_label(0), kind.label());
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires live Telegram network access"]
|
||||
async fn connects_to_all_production_data_centers() {
|
||||
let engine = TransportEngine::new();
|
||||
for dc in [1, 2, 3, 4, 5, 203] {
|
||||
let (mut websocket, connected) = engine.connect(dc, false).await.unwrap();
|
||||
assert!(!connected.route.websocket_host.is_empty());
|
||||
websocket.close(None).await.unwrap();
|
||||
}
|
||||
}
|
||||
}
|
||||
-306
@@ -1,306 +0,0 @@
|
||||
use std::net::Ipv4Addr;
|
||||
use std::sync::Arc;
|
||||
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
|
||||
use tokio::net::{TcpListener, TcpStream};
|
||||
use tokio::io::{AsyncReadExt, AsyncWriteExt};
|
||||
use tokio_tungstenite::tungstenite;
|
||||
use tungstenite::client::IntoClientRequest;
|
||||
|
||||
pub struct ProxyStats {
|
||||
pub running: AtomicBool,
|
||||
pub active_conn: AtomicU32,
|
||||
pub total_conn: AtomicU32,
|
||||
pub ws_active: AtomicU32,
|
||||
}
|
||||
|
||||
impl ProxyStats {
|
||||
pub fn new() -> Arc<Self> {
|
||||
Arc::new(Self {
|
||||
running: AtomicBool::new(false),
|
||||
active_conn: AtomicU32::new(0),
|
||||
total_conn: AtomicU32::new(0),
|
||||
ws_active: AtomicU32::new(0),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run_proxy(port: u16, stats: Arc<ProxyStats>) -> Result<(), String> {
|
||||
let addr = format!("127.0.0.1:{}", port);
|
||||
let listener = TcpListener::bind(&addr)
|
||||
.await
|
||||
.map_err(|e| format!("Не удалось занять порт {}: {}", port, e))?;
|
||||
|
||||
stats.running.store(true, Ordering::SeqCst);
|
||||
|
||||
loop {
|
||||
if !stats.running.load(Ordering::SeqCst) {
|
||||
break;
|
||||
}
|
||||
tokio::select! {
|
||||
result = listener.accept() => {
|
||||
if let Ok((stream, _)) = result {
|
||||
let st = stats.clone();
|
||||
st.active_conn.fetch_add(1, Ordering::Relaxed);
|
||||
st.total_conn.fetch_add(1, Ordering::Relaxed);
|
||||
tokio::spawn(async move {
|
||||
let _ = handle_socks5(stream, &st).await;
|
||||
st.active_conn.fetch_sub(1, Ordering::Relaxed);
|
||||
});
|
||||
}
|
||||
}
|
||||
_ = tokio::time::sleep(std::time::Duration::from_millis(200)) => {}
|
||||
}
|
||||
}
|
||||
|
||||
stats.running.store(false, Ordering::SeqCst);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// DC extraction from obfuscated2 init packet (same method as tg-ws-proxy)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn extract_dc_from_init(init: &[u8; 64]) -> Option<u8> {
|
||||
use aes::Aes256;
|
||||
use cipher::{KeyIvInit, StreamCipher};
|
||||
type Aes256Ctr = ctr::Ctr128BE<Aes256>;
|
||||
|
||||
let key = &init[8..40];
|
||||
let iv = &init[40..56];
|
||||
|
||||
let mut dec = [0u8; 64];
|
||||
dec.copy_from_slice(init);
|
||||
|
||||
let mut cipher = Aes256Ctr::new(key.into(), iv.into());
|
||||
cipher.apply_keystream(&mut dec);
|
||||
|
||||
let dc_id = i32::from_le_bytes([dec[60], dec[61], dec[62], dec[63]]);
|
||||
let dc = dc_id.unsigned_abs() as u8;
|
||||
if (1..=5).contains(&dc) {
|
||||
Some(dc)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn dc_from_ip(ip: Ipv4Addr) -> Option<u8> {
|
||||
let o = ip.octets();
|
||||
match (o[0], o[1]) {
|
||||
(149, 154) => Some(match o[2] {
|
||||
160..=163 => 1,
|
||||
164..=167 => 2,
|
||||
168..=171 => 3,
|
||||
172..=175 => 1,
|
||||
_ => 2,
|
||||
}),
|
||||
(91, 108) => Some(match o[2] {
|
||||
56..=59 => 5,
|
||||
8..=11 => 3,
|
||||
12..=15 => 4,
|
||||
_ => 2,
|
||||
}),
|
||||
(91, 105) | (185, 76) => Some(2),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn is_telegram_ip(addr: &str) -> bool {
|
||||
addr.parse::<Ipv4Addr>()
|
||||
.ok()
|
||||
.and_then(dc_from_ip)
|
||||
.is_some()
|
||||
}
|
||||
|
||||
/// Endpoint format used by the proven tg-ws-proxy project
|
||||
fn ws_url(dc: u8) -> String {
|
||||
format!("wss://kws{}.web.telegram.org/apiws", dc)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// SOCKS5 handler
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
async fn handle_socks5(
|
||||
mut stream: TcpStream,
|
||||
stats: &ProxyStats,
|
||||
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
||||
stream.set_nodelay(true)?;
|
||||
|
||||
// --- auth negotiation ---
|
||||
let mut buf = [0u8; 258];
|
||||
let n = stream.read(&mut buf).await?;
|
||||
if n < 2 || buf[0] != 0x05 {
|
||||
return Err("Not SOCKS5".into());
|
||||
}
|
||||
stream.write_all(&[0x05, 0x00]).await?;
|
||||
|
||||
// --- CONNECT request ---
|
||||
let n = stream.read(&mut buf).await?;
|
||||
if n < 7 || buf[0] != 0x05 || buf[1] != 0x01 {
|
||||
stream.write_all(&[0x05, 0x07, 0x00, 0x01, 0, 0, 0, 0, 0, 0]).await?;
|
||||
return Err("Bad CONNECT".into());
|
||||
}
|
||||
|
||||
let (dest_addr, dest_port) = parse_dest(&buf[3..n])?;
|
||||
let is_tg = is_telegram_ip(&dest_addr);
|
||||
|
||||
// SOCKS5 success (we handle the connection ourselves)
|
||||
stream
|
||||
.write_all(&[0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x04, 0x38])
|
||||
.await?;
|
||||
|
||||
if is_tg {
|
||||
// Read the first 64 bytes — obfuscated2 init packet
|
||||
let mut init = [0u8; 64];
|
||||
stream.read_exact(&mut init).await?;
|
||||
|
||||
// Extract DC from init packet (primary), fall back to IP-based
|
||||
let dc = extract_dc_from_init(&init).unwrap_or_else(|| {
|
||||
dest_addr
|
||||
.parse::<Ipv4Addr>()
|
||||
.ok()
|
||||
.and_then(dc_from_ip)
|
||||
.unwrap_or(2)
|
||||
});
|
||||
|
||||
stats.ws_active.fetch_add(1, Ordering::Relaxed);
|
||||
|
||||
// Try WebSocket tunnel; fall back to direct TCP on failure
|
||||
let ws_result = relay_via_ws(stream, dc, &init).await;
|
||||
|
||||
stats.ws_active.fetch_sub(1, Ordering::Relaxed);
|
||||
|
||||
if let Err(e) = ws_result {
|
||||
return Err(format!("DC{} tunnel: {}", dc, e).into());
|
||||
}
|
||||
} else {
|
||||
// Non-Telegram — direct TCP passthrough
|
||||
let target = format!("{}:{}", dest_addr, dest_port);
|
||||
match TcpStream::connect(&target).await {
|
||||
Ok(remote) => {
|
||||
let _ = remote.set_nodelay(true);
|
||||
relay_tcp(stream, remote).await;
|
||||
}
|
||||
Err(e) => {
|
||||
return Err(format!("TCP connect {}: {}", target, e).into());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn parse_dest(data: &[u8]) -> Result<(String, u16), Box<dyn std::error::Error + Send + Sync>> {
|
||||
match data[0] {
|
||||
0x01 => {
|
||||
if data.len() < 7 { return Err("short".into()); }
|
||||
let ip = format!("{}.{}.{}.{}", data[1], data[2], data[3], data[4]);
|
||||
let port = u16::from_be_bytes([data[5], data[6]]);
|
||||
Ok((ip, port))
|
||||
}
|
||||
0x03 => {
|
||||
let len = data[1] as usize;
|
||||
if data.len() < 2 + len + 2 { return Err("short".into()); }
|
||||
let domain = std::str::from_utf8(&data[2..2 + len])?.to_string();
|
||||
let port = u16::from_be_bytes([data[2 + len], data[3 + len]]);
|
||||
Ok((domain, port))
|
||||
}
|
||||
0x04 => {
|
||||
if data.len() < 19 { return Err("short".into()); }
|
||||
let port = u16::from_be_bytes([data[17], data[18]]);
|
||||
let mut segs = [0u16; 8];
|
||||
for i in 0..8 {
|
||||
segs[i] = u16::from_be_bytes([data[1 + i * 2], data[2 + i * 2]]);
|
||||
}
|
||||
let ip = std::net::Ipv6Addr::new(
|
||||
segs[0], segs[1], segs[2], segs[3], segs[4], segs[5], segs[6], segs[7],
|
||||
);
|
||||
Ok((ip.to_string(), port))
|
||||
}
|
||||
_ => Err("unknown addr type".into()),
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// WebSocket tunnel — reads init first, then relays
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
async fn relay_via_ws(
|
||||
tcp_stream: TcpStream,
|
||||
dc: u8,
|
||||
init: &[u8; 64],
|
||||
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
|
||||
use futures_util::{SinkExt, StreamExt};
|
||||
|
||||
let url = ws_url(dc);
|
||||
let mut request = url.as_str().into_client_request()?;
|
||||
|
||||
// Required by the Telegram WebSocket transport protocol
|
||||
request
|
||||
.headers_mut()
|
||||
.insert("Sec-WebSocket-Protocol", "binary".parse()?);
|
||||
|
||||
let connector = tokio_tungstenite::Connector::NativeTls(
|
||||
native_tls::TlsConnector::new().map_err(|e| format!("TLS: {}", e))?,
|
||||
);
|
||||
|
||||
let (ws, _resp) = tokio_tungstenite::connect_async_tls_with_config(
|
||||
request, None, false, Some(connector),
|
||||
)
|
||||
.await?;
|
||||
|
||||
let (mut ws_tx, mut ws_rx) = ws.split();
|
||||
let (mut tcp_rx, mut tcp_tx) = tokio::io::split(tcp_stream);
|
||||
|
||||
// Send the buffered 64-byte init as the first WebSocket message
|
||||
ws_tx
|
||||
.send(tungstenite::Message::Binary(init.to_vec()))
|
||||
.await?;
|
||||
|
||||
let up = async {
|
||||
let mut buf = vec![0u8; 32768];
|
||||
loop {
|
||||
match tcp_rx.read(&mut buf).await {
|
||||
Ok(0) => break,
|
||||
Ok(n) => {
|
||||
let msg = tungstenite::Message::Binary(buf[..n].to_vec());
|
||||
if ws_tx.send(msg).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
let _ = ws_tx.close().await;
|
||||
};
|
||||
|
||||
let down = async {
|
||||
while let Some(Ok(msg)) = ws_rx.next().await {
|
||||
match msg {
|
||||
tungstenite::Message::Binary(data) => {
|
||||
if tcp_tx.write_all(&data).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
tungstenite::Message::Close(_) => break,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
tokio::select! {
|
||||
_ = up => {}
|
||||
_ = down => {}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn relay_tcp(client: TcpStream, remote: TcpStream) {
|
||||
let (mut cr, mut cw) = tokio::io::split(client);
|
||||
let (mut rr, mut rw) = tokio::io::split(remote);
|
||||
tokio::select! {
|
||||
_ = tokio::io::copy(&mut cr, &mut rw) => {}
|
||||
_ = tokio::io::copy(&mut rr, &mut cw) => {}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
{
|
||||
"$schema": "https://schema.tauri.app/config/2",
|
||||
"productName": "TGLock",
|
||||
"version": "2.0.0-beta.4",
|
||||
"identifier": "com.bysonic.tglock",
|
||||
"mainBinaryName": "tglock",
|
||||
"build": {
|
||||
"beforeDevCommand": "npm run dev",
|
||||
"devUrl": "http://localhost:1420",
|
||||
"beforeBuildCommand": "npm run build",
|
||||
"frontendDist": "dist-ui"
|
||||
},
|
||||
"app": {
|
||||
"windows": [
|
||||
{
|
||||
"label": "main",
|
||||
"title": "TGLock",
|
||||
"width": 460,
|
||||
"height": 620,
|
||||
"minWidth": 460,
|
||||
"minHeight": 620,
|
||||
"resizable": false,
|
||||
"fullscreen": false,
|
||||
"center": true,
|
||||
"backgroundColor": "#070A10",
|
||||
"titleBarStyle": "Overlay",
|
||||
"hiddenTitle": true
|
||||
}
|
||||
],
|
||||
"security": {
|
||||
"csp": "default-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; connect-src ipc: http://ipc.localhost"
|
||||
}
|
||||
},
|
||||
"bundle": {
|
||||
"active": true,
|
||||
"targets": ["app", "dmg"],
|
||||
"icon": [
|
||||
"icons/32x32.png",
|
||||
"icons/128x128.png",
|
||||
"icons/128x128@2x.png",
|
||||
"icons/icon.icns",
|
||||
"icons/icon.ico"
|
||||
],
|
||||
"category": "Utility",
|
||||
"shortDescription": "Telegram connectivity through a local MTProto proxy",
|
||||
"longDescription": "TGLock restores Telegram connectivity through an adaptive WebSocket tunnel.",
|
||||
"macOS": {
|
||||
"minimumSystemVersion": "11.0"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,21 +0,0 @@
|
||||
91.108.56.0/22
|
||||
91.108.4.0/22
|
||||
91.108.8.0/22
|
||||
91.108.16.0/22
|
||||
91.108.12.0/22
|
||||
91.108.20.0/22
|
||||
149.154.160.0/20
|
||||
185.76.151.0/24
|
||||
91.105.192.0/23
|
||||
core.telegram.org
|
||||
web.telegram.org
|
||||
desktop.telegram.org
|
||||
macos.telegram.org
|
||||
updates.telegram.org
|
||||
venus.web.telegram.org
|
||||
pluto.web.telegram.org
|
||||
flora.web.telegram.org
|
||||
vesta.web.telegram.org
|
||||
telegram.org
|
||||
t.me
|
||||
telegram.me
|
||||
-852
@@ -1,852 +0,0 @@
|
||||
@echo off
|
||||
chcp 65001 >nul 2>&1
|
||||
setlocal enabledelayedexpansion
|
||||
|
||||
:: ============================================================
|
||||
:: TG Unblock — обход блокировки/замедления Telegram
|
||||
:: Требуется запуск от имени администратора
|
||||
:: ============================================================
|
||||
|
||||
:: --- Проверка прав администратора ---
|
||||
net session >nul 2>&1
|
||||
if %errorlevel% neq 0 (
|
||||
echo [!] Скрипт требует прав администратора.
|
||||
echo Перезапускаю с повышенными правами...
|
||||
powershell -Command "Start-Process -Verb RunAs -FilePath '%~f0'"
|
||||
exit /b
|
||||
)
|
||||
|
||||
set "SCRIPT_DIR=%~dp0"
|
||||
set "TOOLS_DIR=%SCRIPT_DIR%tools"
|
||||
set "GDPI_DIR=%TOOLS_DIR%\goodbyedpi-0.2.3rc3-2"
|
||||
set "GDPI_EXE=%GDPI_DIR%\x86_64\goodbyedpi.exe"
|
||||
set "BLACKLIST=%SCRIPT_DIR%tg_blacklist.txt"
|
||||
set "GDPI_URL=https://github.com/ValdikSS/GoodbyeDPI/releases/download/0.2.3rc3/goodbyedpi-0.2.3rc3-2.zip"
|
||||
set "GDPI_ZIP=%TOOLS_DIR%\goodbyedpi.zip"
|
||||
|
||||
title TG Unblock — Обход блокировки Telegram
|
||||
|
||||
:MENU
|
||||
cls
|
||||
echo ============================================================
|
||||
echo TG Unblock — Обход блокировки Telegram
|
||||
echo ============================================================
|
||||
echo.
|
||||
echo [*] ЗАПУСТИТЬ ОБХОД (авто) — нажмите 7
|
||||
echo.
|
||||
echo [1] Сменить DNS (Cloudflare / Google)
|
||||
echo [2] Запустить GoodbyeDPI (обход DPI)
|
||||
echo [3] Комбинированный режим (DNS + GoodbyeDPI)
|
||||
echo [4] Тест соединения с Telegram
|
||||
echo [5] Сбросить настройки (вернуть DNS, остановить GoodbyeDPI)
|
||||
echo [6] Показать текущие настройки сети
|
||||
echo [7] === АВТО-ОБХОД (одна кнопка) ===
|
||||
echo [0] Выход
|
||||
echo.
|
||||
echo ============================================================
|
||||
set /p "choice=Выберите действие [0-7]: "
|
||||
|
||||
if "%choice%"=="1" goto DNS_MENU
|
||||
if "%choice%"=="2" goto DPI_START
|
||||
if "%choice%"=="3" goto COMBINED
|
||||
if "%choice%"=="4" goto TEST
|
||||
if "%choice%"=="5" goto RESET
|
||||
if "%choice%"=="6" goto SHOW_NET
|
||||
if "%choice%"=="7" goto AUTO_BYPASS
|
||||
if "%choice%"=="0" goto EXIT
|
||||
echo [!] Неверный выбор.
|
||||
timeout /t 2 >nul
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: 1. СМЕНА DNS
|
||||
:: ============================================================
|
||||
:DNS_MENU
|
||||
cls
|
||||
echo ============================================================
|
||||
echo Смена DNS
|
||||
echo ============================================================
|
||||
echo.
|
||||
echo [1] Cloudflare DNS (1.1.1.1 / 1.0.0.1)
|
||||
echo [2] Google DNS (8.8.8.8 / 8.8.4.4)
|
||||
echo [3] Quad9 DNS (9.9.9.9 / 149.112.112.112)
|
||||
echo [4] Cloudflare DoH (1.1.1.1 + DNS-over-HTTPS)
|
||||
echo [0] Назад
|
||||
echo.
|
||||
set /p "dns_choice=Выберите DNS провайдера [0-4]: "
|
||||
|
||||
if "%dns_choice%"=="1" (
|
||||
set "DNS1=1.1.1.1"
|
||||
set "DNS2=1.0.0.1"
|
||||
set "DNS_NAME=Cloudflare"
|
||||
)
|
||||
if "%dns_choice%"=="2" (
|
||||
set "DNS1=8.8.8.8"
|
||||
set "DNS2=8.8.4.4"
|
||||
set "DNS_NAME=Google"
|
||||
)
|
||||
if "%dns_choice%"=="3" (
|
||||
set "DNS1=9.9.9.9"
|
||||
set "DNS2=149.112.112.112"
|
||||
set "DNS_NAME=Quad9"
|
||||
)
|
||||
if "%dns_choice%"=="4" (
|
||||
set "DNS1=1.1.1.1"
|
||||
set "DNS2=1.0.0.1"
|
||||
set "DNS_NAME=Cloudflare DoH"
|
||||
goto SET_DNS_DOH
|
||||
)
|
||||
if "%dns_choice%"=="0" goto MENU
|
||||
|
||||
if not defined DNS1 (
|
||||
echo [!] Неверный выбор.
|
||||
timeout /t 2 >nul
|
||||
goto DNS_MENU
|
||||
)
|
||||
|
||||
:SET_DNS
|
||||
echo.
|
||||
echo [*] Определяю активный сетевой адаптер...
|
||||
|
||||
for /f "tokens=1,2,3,4,*" %%a in ('netsh interface ipv4 show interfaces ^| findstr /i "connected"') do (
|
||||
set "ADAPTER_NAME=%%e"
|
||||
)
|
||||
|
||||
if not defined ADAPTER_NAME (
|
||||
for /f "tokens=*" %%a in ('powershell -Command "(Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Select-Object -First 1).Name"') do (
|
||||
set "ADAPTER_NAME=%%a"
|
||||
)
|
||||
)
|
||||
|
||||
if not defined ADAPTER_NAME (
|
||||
echo [!] Не удалось определить сетевой адаптер.
|
||||
echo Введите имя адаптера вручную (например: Ethernet, Wi-Fi):
|
||||
set /p "ADAPTER_NAME="
|
||||
)
|
||||
|
||||
echo [*] Адаптер: !ADAPTER_NAME!
|
||||
echo [*] Устанавливаю DNS: %DNS_NAME% (%DNS1%, %DNS2%)...
|
||||
|
||||
netsh interface ipv4 set dnsservers "!ADAPTER_NAME!" static %DNS1% primary validate=no >nul 2>&1
|
||||
netsh interface ipv4 add dnsservers "!ADAPTER_NAME!" %DNS2% index=2 validate=no >nul 2>&1
|
||||
|
||||
echo [*] Очищаю DNS-кеш...
|
||||
ipconfig /flushdns >nul 2>&1
|
||||
|
||||
echo.
|
||||
echo [OK] DNS успешно изменён на %DNS_NAME% (%DNS1%, %DNS2%)
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:SET_DNS_DOH
|
||||
echo.
|
||||
echo [*] Определяю активный сетевой адаптер...
|
||||
|
||||
for /f "tokens=*" %%a in ('powershell -Command "(Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Select-Object -First 1).Name"') do (
|
||||
set "ADAPTER_NAME=%%a"
|
||||
)
|
||||
|
||||
if not defined ADAPTER_NAME (
|
||||
echo [!] Не удалось определить адаптер. Введите имя вручную:
|
||||
set /p "ADAPTER_NAME="
|
||||
)
|
||||
|
||||
echo [*] Адаптер: !ADAPTER_NAME!
|
||||
echo [*] Устанавливаю DNS: Cloudflare (1.1.1.1, 1.0.0.1)...
|
||||
|
||||
netsh interface ipv4 set dnsservers "!ADAPTER_NAME!" static 1.1.1.1 primary validate=no >nul 2>&1
|
||||
netsh interface ipv4 add dnsservers "!ADAPTER_NAME!" 1.0.0.1 index=2 validate=no >nul 2>&1
|
||||
ipconfig /flushdns >nul 2>&1
|
||||
|
||||
echo [*] Включаю DNS-over-HTTPS в системе (Windows 11+)...
|
||||
powershell -Command "try { Set-DnsClientDohServerAddress -ServerAddress '1.1.1.1' -DohTemplate 'https://cloudflare-dns.com/dns-query' -AllowFallbackToUdp $true -AutoUpgrade $true -ErrorAction Stop; Set-DnsClientDohServerAddress -ServerAddress '1.0.0.1' -DohTemplate 'https://cloudflare-dns.com/dns-query' -AllowFallbackToUdp $true -AutoUpgrade $true -ErrorAction Stop; Write-Host '[OK] DoH активирован' } catch { Write-Host '[!] DoH недоступен на этой версии Windows, DNS установлен без DoH' }"
|
||||
|
||||
echo.
|
||||
echo [OK] DNS установлен на Cloudflare с DoH.
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: 2. ЗАПУСК GoodbyeDPI
|
||||
:: ============================================================
|
||||
:DPI_START
|
||||
cls
|
||||
echo ============================================================
|
||||
echo GoodbyeDPI — обход DPI
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
:: Проверяем наличие GoodbyeDPI
|
||||
if not exist "%GDPI_EXE%" (
|
||||
echo [!] GoodbyeDPI не найден.
|
||||
goto DOWNLOAD_GDPI
|
||||
)
|
||||
|
||||
:DPI_MODE_MENU
|
||||
echo.
|
||||
echo Выберите режим GoodbyeDPI:
|
||||
echo.
|
||||
echo [1] Режим -9 (максимальная защита, рекомендуется)
|
||||
echo [2] Режим -5 (средний)
|
||||
echo [3] Режим -1 (базовый, совместимый)
|
||||
echo [4] Кастомный (-e 2 -f 2 -q -r -m)
|
||||
echo [5] Авто-перебор (попробует все режимы)
|
||||
echo [0] Назад
|
||||
echo.
|
||||
set /p "dpi_mode=Выберите режим [0-5]: "
|
||||
|
||||
if "%dpi_mode%"=="0" goto MENU
|
||||
|
||||
:: Убиваем старый процесс если запущен
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
|
||||
if "%dpi_mode%"=="1" (
|
||||
echo [*] Запускаю GoodbyeDPI в режиме -9 (максимальная защита)...
|
||||
start "" /B "%GDPI_EXE%" -9 --blacklist "%BLACKLIST%"
|
||||
goto DPI_STARTED
|
||||
)
|
||||
if "%dpi_mode%"=="2" (
|
||||
echo [*] Запускаю GoodbyeDPI в режиме -5 (средний)...
|
||||
start "" /B "%GDPI_EXE%" -5 --blacklist "%BLACKLIST%"
|
||||
goto DPI_STARTED
|
||||
)
|
||||
if "%dpi_mode%"=="3" (
|
||||
echo [*] Запускаю GoodbyeDPI в режиме -1 (базовый)...
|
||||
start "" /B "%GDPI_EXE%" -1 --blacklist "%BLACKLIST%"
|
||||
goto DPI_STARTED
|
||||
)
|
||||
if "%dpi_mode%"=="4" (
|
||||
echo [*] Запускаю GoodbyeDPI в кастомном режиме...
|
||||
start "" /B "%GDPI_EXE%" -e 2 -f 2 -q -r -m --blacklist "%BLACKLIST%"
|
||||
goto DPI_STARTED
|
||||
)
|
||||
if "%dpi_mode%"=="5" goto DPI_AUTO
|
||||
|
||||
echo [!] Неверный выбор.
|
||||
timeout /t 2 >nul
|
||||
goto DPI_MODE_MENU
|
||||
|
||||
:DPI_STARTED
|
||||
timeout /t 2 >nul
|
||||
tasklist /fi "imagename eq goodbyedpi.exe" 2>nul | findstr /i "goodbyedpi" >nul
|
||||
if %errorlevel%==0 (
|
||||
echo.
|
||||
echo [OK] GoodbyeDPI запущен успешно!
|
||||
echo Работает в фоне. Для остановки используйте пункт 5 (Сброс).
|
||||
) else (
|
||||
echo.
|
||||
echo [!] GoodbyeDPI не удалось запустить.
|
||||
echo Проверьте что антивирус не блокирует WinDivert.
|
||||
)
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: АВТО-ПЕРЕБОР РЕЖИМОВ
|
||||
:: ============================================================
|
||||
:DPI_AUTO
|
||||
echo.
|
||||
echo [*] Авто-перебор режимов GoodbyeDPI...
|
||||
echo [*] Буду пробовать каждый режим и тестировать соединение.
|
||||
echo.
|
||||
|
||||
set "MODES=-9;-5;-1;-e 2 -f 2 -q -r -m;-e 1 -f 1 -q -r -m -s;-p -f 2 -e 2 -q"
|
||||
set "MODE_NAMES=Режим -9 (макс);Режим -5 (средний);Режим -1 (базовый);Кастом1 (-e2 -f2 -q -r -m);Кастом2 (-e1 -f1 -q -r -m -s);Кастом3 (-p -f2 -e2 -q)"
|
||||
set "mode_idx=0"
|
||||
set "best_mode="
|
||||
|
||||
for %%m in ("-9" "-5" "-1") do (
|
||||
set /a mode_idx+=1
|
||||
echo --- Тест !mode_idx!: GoodbyeDPI %%~m ---
|
||||
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
|
||||
start "" /B "%GDPI_EXE%" %%~m --blacklist "%BLACKLIST%"
|
||||
timeout /t 3 >nul
|
||||
|
||||
tasklist /fi "imagename eq goodbyedpi.exe" 2>nul | findstr /i "goodbyedpi" >nul
|
||||
if !errorlevel! neq 0 (
|
||||
echo [FAIL] Не запустился
|
||||
) else (
|
||||
powershell -Command "$r = try { (Invoke-WebRequest -Uri 'https://web.telegram.org' -TimeoutSec 10 -UseBasicParsing).StatusCode } catch { 0 }; if ($r -eq 200) { Write-Host ' [OK] web.telegram.org доступен!'; exit 0 } else { Write-Host ' [FAIL] web.telegram.org недоступен'; exit 1 }"
|
||||
if !errorlevel!==0 (
|
||||
set "best_mode=%%~m"
|
||||
echo [***] Рабочий режим найден: %%~m
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
:: Пробуем кастомные режимы
|
||||
for %%p in (
|
||||
"-e 2 -f 2 -q -r -m"
|
||||
"-e 1 -f 1 -q -r -m -s"
|
||||
"-p -f 2 -e 2 -q"
|
||||
) do (
|
||||
set /a mode_idx+=1
|
||||
echo --- Тест !mode_idx!: GoodbyeDPI %%~p ---
|
||||
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
|
||||
start "" /B "%GDPI_EXE%" %%~p --blacklist "%BLACKLIST%"
|
||||
timeout /t 3 >nul
|
||||
|
||||
tasklist /fi "imagename eq goodbyedpi.exe" 2>nul | findstr /i "goodbyedpi" >nul
|
||||
if !errorlevel! neq 0 (
|
||||
echo [FAIL] Не запустился
|
||||
) else (
|
||||
powershell -Command "$r = try { (Invoke-WebRequest -Uri 'https://web.telegram.org' -TimeoutSec 10 -UseBasicParsing).StatusCode } catch { 0 }; if ($r -eq 200) { Write-Host ' [OK] web.telegram.org доступен!'; exit 0 } else { Write-Host ' [FAIL] web.telegram.org недоступен'; exit 1 }"
|
||||
if !errorlevel!==0 (
|
||||
if not defined best_mode (
|
||||
set "best_mode=%%~p"
|
||||
echo [***] Рабочий режим найден: %%~p
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
echo.
|
||||
if defined best_mode (
|
||||
echo ============================================================
|
||||
echo [OK] Лучший рабочий режим: !best_mode!
|
||||
echo Перезапускаю GoodbyeDPI с этим режимом...
|
||||
echo ============================================================
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" !best_mode! --blacklist "%BLACKLIST%"
|
||||
) else (
|
||||
echo ============================================================
|
||||
echo [!] Ни один режим GoodbyeDPI не помог.
|
||||
echo Возможно, нужен VPN или MTProxy.
|
||||
echo ============================================================
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
)
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: 3. КОМБИНИРОВАННЫЙ РЕЖИМ
|
||||
:: ============================================================
|
||||
:COMBINED
|
||||
cls
|
||||
echo ============================================================
|
||||
echo Комбинированный режим (DNS + GoodbyeDPI)
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
:: --- DNS ---
|
||||
echo [*] Устанавливаю DNS Cloudflare (1.1.1.1)...
|
||||
for /f "tokens=*" %%a in ('powershell -Command "(Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Select-Object -First 1).Name"') do (
|
||||
set "ADAPTER_NAME=%%a"
|
||||
)
|
||||
if defined ADAPTER_NAME (
|
||||
netsh interface ipv4 set dnsservers "!ADAPTER_NAME!" static 1.1.1.1 primary validate=no >nul 2>&1
|
||||
netsh interface ipv4 add dnsservers "!ADAPTER_NAME!" 1.0.0.1 index=2 validate=no >nul 2>&1
|
||||
ipconfig /flushdns >nul 2>&1
|
||||
echo [OK] DNS установлен: Cloudflare (1.1.1.1, 1.0.0.1)
|
||||
) else (
|
||||
echo [!] Не удалось определить сетевой адаптер для DNS.
|
||||
)
|
||||
|
||||
:: --- GoodbyeDPI ---
|
||||
if not exist "%GDPI_EXE%" (
|
||||
echo.
|
||||
echo [!] GoodbyeDPI не найден. Скачиваю...
|
||||
call :DO_DOWNLOAD_GDPI
|
||||
if not exist "%GDPI_EXE%" (
|
||||
echo [!] Не удалось скачать GoodbyeDPI. Работаю только с DNS.
|
||||
pause
|
||||
goto MENU
|
||||
)
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [*] Запускаю GoodbyeDPI в режиме -9...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -9 --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
|
||||
tasklist /fi "imagename eq goodbyedpi.exe" 2>nul | findstr /i "goodbyedpi" >nul
|
||||
if %errorlevel%==0 (
|
||||
echo [OK] GoodbyeDPI запущен.
|
||||
) else (
|
||||
echo [!] GoodbyeDPI не запустился. Пробую режим -5...
|
||||
start "" /B "%GDPI_EXE%" -5 --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
)
|
||||
|
||||
echo.
|
||||
echo ============================================================
|
||||
echo [OK] Комбинированный режим активирован:
|
||||
echo DNS: Cloudflare 1.1.1.1
|
||||
echo DPI: GoodbyeDPI
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
:: Быстрый тест
|
||||
echo [*] Проверяю доступность Telegram...
|
||||
powershell -Command "$r = try { $sw = [System.Diagnostics.Stopwatch]::StartNew(); $resp = Invoke-WebRequest -Uri 'https://web.telegram.org' -TimeoutSec 15 -UseBasicParsing; $sw.Stop(); Write-Host \"[OK] web.telegram.org доступен (${($sw.ElapsedMilliseconds)}ms)\"; } catch { Write-Host '[!] web.telegram.org пока недоступен, подождите немного...' }"
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: 4. ТЕСТ СОЕДИНЕНИЯ
|
||||
:: ============================================================
|
||||
:TEST
|
||||
cls
|
||||
echo ============================================================
|
||||
echo Тест соединения с Telegram
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
echo [*] Проверяю GoodbyeDPI...
|
||||
tasklist /fi "imagename eq goodbyedpi.exe" 2>nul | findstr /i "goodbyedpi" >nul
|
||||
if %errorlevel%==0 (
|
||||
echo GoodbyeDPI: ЗАПУЩЕН
|
||||
) else (
|
||||
echo GoodbyeDPI: не запущен
|
||||
)
|
||||
echo.
|
||||
|
||||
echo [*] Текущий DNS:
|
||||
powershell -Command "Get-DnsClientServerAddress -AddressFamily IPv4 | Where-Object {$_.ServerAddresses.Count -gt 0} | Format-Table InterfaceAlias, ServerAddresses -AutoSize"
|
||||
echo.
|
||||
|
||||
echo [*] Пинг серверов Telegram (DC1-DC5)...
|
||||
echo.
|
||||
|
||||
set "TG_IPS=149.154.175.50 149.154.167.51 149.154.175.100 149.154.167.91 91.108.56.100 91.108.4.100"
|
||||
|
||||
for %%i in (%TG_IPS%) do (
|
||||
echo Пинг %%i...
|
||||
ping -n 1 -w 3000 %%i >nul 2>&1
|
||||
if !errorlevel!==0 (
|
||||
for /f "tokens=*" %%t in ('ping -n 1 -w 3000 %%i ^| findstr /i "time="') do (
|
||||
echo [OK] %%i — %%t
|
||||
)
|
||||
) else (
|
||||
echo [FAIL] %%i — недоступен
|
||||
)
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [*] Проверяю TCP-соединение (порт 443)...
|
||||
echo.
|
||||
|
||||
for %%i in (149.154.175.50 149.154.167.51 91.108.56.100) do (
|
||||
powershell -Command "$tcp = New-Object System.Net.Sockets.TcpClient; try { $tcp.ConnectAsync('%%i', 443).Wait(5000) | Out-Null; if ($tcp.Connected) { Write-Host ' [OK] %%i:443 — TCP доступен' } else { Write-Host ' [FAIL] %%i:443 — таймаут' } } catch { Write-Host ' [FAIL] %%i:443 — отказано' } finally { $tcp.Dispose() }"
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [*] Проверяю HTTPS доступность...
|
||||
echo.
|
||||
|
||||
for %%u in (
|
||||
"https://web.telegram.org"
|
||||
"https://core.telegram.org"
|
||||
"https://t.me"
|
||||
) do (
|
||||
powershell -Command "$url = '%%~u'; try { $sw = [System.Diagnostics.Stopwatch]::StartNew(); $r = Invoke-WebRequest -Uri $url -TimeoutSec 10 -UseBasicParsing; $sw.Stop(); $ms = $sw.ElapsedMilliseconds; Write-Host \" [OK] $url — HTTP $($r.StatusCode) (${ms}ms)\" } catch { Write-Host \" [FAIL] $url — недоступен\" }"
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [*] Проверяю DNS резолвинг...
|
||||
echo.
|
||||
|
||||
for %%d in (web.telegram.org core.telegram.org t.me telegram.org) do (
|
||||
powershell -Command "try { $ip = [System.Net.Dns]::GetHostAddresses('%%d') | Select-Object -First 1; Write-Host \" [OK] %%d -> $($ip.IPAddressToString)\" } catch { Write-Host ' [FAIL] %%d — DNS не резолвится' }"
|
||||
)
|
||||
|
||||
echo.
|
||||
echo ============================================================
|
||||
echo Тест завершён
|
||||
echo ============================================================
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: 5. СБРОС НАСТРОЕК
|
||||
:: ============================================================
|
||||
:RESET
|
||||
cls
|
||||
echo ============================================================
|
||||
echo Сброс настроек
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
echo [*] Останавливаю GoodbyeDPI...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
echo [OK] GoodbyeDPI остановлен.
|
||||
|
||||
echo.
|
||||
echo [*] Возвращаю DNS к автоматическому (DHCP)...
|
||||
for /f "tokens=*" %%a in ('powershell -Command "(Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Select-Object -First 1).Name"') do (
|
||||
set "ADAPTER_NAME=%%a"
|
||||
)
|
||||
if defined ADAPTER_NAME (
|
||||
netsh interface ipv4 set dnsservers "!ADAPTER_NAME!" dhcp >nul 2>&1
|
||||
ipconfig /flushdns >nul 2>&1
|
||||
echo [OK] DNS сброшен на DHCP (автоматический).
|
||||
) else (
|
||||
echo [!] Не удалось определить адаптер. Сбросьте DNS вручную.
|
||||
)
|
||||
|
||||
echo.
|
||||
echo [OK] Все настройки сброшены.
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: 6. ПОКАЗАТЬ ТЕКУЩИЕ НАСТРОЙКИ
|
||||
:: ============================================================
|
||||
:SHOW_NET
|
||||
cls
|
||||
echo ============================================================
|
||||
echo Текущие сетевые настройки
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
echo [*] Сетевые адаптеры:
|
||||
powershell -Command "Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Format-Table Name, InterfaceDescription, Status, LinkSpeed -AutoSize"
|
||||
|
||||
echo [*] DNS серверы:
|
||||
powershell -Command "Get-DnsClientServerAddress -AddressFamily IPv4 | Where-Object {$_.ServerAddresses.Count -gt 0} | Format-Table InterfaceAlias, ServerAddresses -AutoSize"
|
||||
|
||||
echo [*] IP-конфигурация:
|
||||
ipconfig | findstr /i "IPv4 Subnet Gateway DNS"
|
||||
|
||||
echo.
|
||||
echo [*] GoodbyeDPI:
|
||||
tasklist /fi "imagename eq goodbyedpi.exe" 2>nul | findstr /i "goodbyedpi" >nul
|
||||
if %errorlevel%==0 (
|
||||
echo Статус: ЗАПУЩЕН
|
||||
for /f "tokens=2" %%p in ('tasklist /fi "imagename eq goodbyedpi.exe" /fo list ^| findstr "PID"') do (
|
||||
echo PID: %%p
|
||||
)
|
||||
) else (
|
||||
echo Статус: не запущен
|
||||
)
|
||||
|
||||
echo.
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: СКАЧИВАНИЕ GoodbyeDPI
|
||||
:: ============================================================
|
||||
:DOWNLOAD_GDPI
|
||||
echo.
|
||||
echo [*] GoodbyeDPI необходим для обхода DPI.
|
||||
echo Скачать автоматически с GitHub?
|
||||
echo.
|
||||
echo [1] Да, скачать
|
||||
echo [0] Нет, назад
|
||||
echo.
|
||||
set /p "dl_choice=Выбор [0-1]: "
|
||||
if "%dl_choice%"=="0" goto MENU
|
||||
if "%dl_choice%"=="1" (
|
||||
call :DO_DOWNLOAD_GDPI
|
||||
if exist "%GDPI_EXE%" goto DPI_MODE_MENU
|
||||
pause
|
||||
goto MENU
|
||||
)
|
||||
goto MENU
|
||||
|
||||
:DO_DOWNLOAD_GDPI
|
||||
echo.
|
||||
echo [*] Создаю папку tools...
|
||||
if not exist "%TOOLS_DIR%" mkdir "%TOOLS_DIR%"
|
||||
|
||||
echo [*] Скачиваю GoodbyeDPI с GitHub...
|
||||
echo URL: %GDPI_URL%
|
||||
echo.
|
||||
|
||||
powershell -Command "[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; try { Invoke-WebRequest -Uri '%GDPI_URL%' -OutFile '%GDPI_ZIP%' -UseBasicParsing; Write-Host '[OK] Скачано успешно' } catch { Write-Host \"[!] Ошибка скачивания: $($_.Exception.Message)\"; exit 1 }"
|
||||
|
||||
if not exist "%GDPI_ZIP%" (
|
||||
echo [!] Не удалось скачать файл.
|
||||
echo Попробуйте скачать вручную:
|
||||
echo %GDPI_URL%
|
||||
echo и распаковать в %GDPI_DIR%
|
||||
exit /b 1
|
||||
)
|
||||
|
||||
echo [*] Распаковываю...
|
||||
powershell -Command "try { Expand-Archive -Path '%GDPI_ZIP%' -DestinationPath '%TOOLS_DIR%' -Force; Write-Host '[OK] Распаковано' } catch { Write-Host \"[!] Ошибка распаковки: $($_.Exception.Message)\"; exit 1 }"
|
||||
|
||||
:: Ищем goodbyedpi.exe рекурсивно
|
||||
if not exist "%GDPI_EXE%" (
|
||||
echo [*] Ищу goodbyedpi.exe...
|
||||
for /f "tokens=*" %%f in ('powershell -Command "Get-ChildItem -Path '%TOOLS_DIR%' -Recurse -Filter 'goodbyedpi.exe' | Select-Object -First 1 | ForEach-Object { $_.DirectoryName }"') do (
|
||||
set "FOUND_DIR=%%f"
|
||||
)
|
||||
if defined FOUND_DIR (
|
||||
echo [*] Найден в: !FOUND_DIR!
|
||||
set "GDPI_DIR=!FOUND_DIR!"
|
||||
set "GDPI_EXE=!FOUND_DIR!\goodbyedpi.exe"
|
||||
|
||||
:: Обновим путь для x86_64
|
||||
if not exist "!FOUND_DIR!\goodbyedpi.exe" (
|
||||
for /f "tokens=*" %%f in ('powershell -Command "Get-ChildItem -Path '%TOOLS_DIR%' -Recurse -Filter 'goodbyedpi.exe' | Select-Object -First 1 | ForEach-Object { $_.FullName }"') do (
|
||||
set "GDPI_EXE=%%f"
|
||||
echo [*] Путь к exe: %%f
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
if exist "%GDPI_EXE%" (
|
||||
echo.
|
||||
echo [OK] GoodbyeDPI установлен: %GDPI_EXE%
|
||||
del "%GDPI_ZIP%" >nul 2>&1
|
||||
) else (
|
||||
echo.
|
||||
echo [!] goodbyedpi.exe не найден после распаковки.
|
||||
echo Проверьте папку: %TOOLS_DIR%
|
||||
)
|
||||
exit /b 0
|
||||
|
||||
:: ============================================================
|
||||
:: 7. АВТО-ОБХОД (одна кнопка) — замеряет ВСЕ режимы,
|
||||
:: выбирает самый быстрый
|
||||
:: ============================================================
|
||||
:AUTO_BYPASS
|
||||
cls
|
||||
echo ============================================================
|
||||
echo АВТО-ОБХОД — тестирую ВСЕ режимы, выбираю лучший...
|
||||
echo Это займёт 2-3 минуты.
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
:: --- Шаг 1: Определяю адаптер ---
|
||||
echo [1] Определяю сетевой адаптер...
|
||||
set "ADAPTER_NAME="
|
||||
for /f "tokens=*" %%a in ('powershell -Command "(Get-NetAdapter | Where-Object {$_.Status -eq 'Up'} | Select-Object -First 1).Name"') do (
|
||||
set "ADAPTER_NAME=%%a"
|
||||
)
|
||||
if not defined ADAPTER_NAME (
|
||||
echo [!] Не удалось определить адаптер.
|
||||
pause
|
||||
goto MENU
|
||||
)
|
||||
echo Адаптер: !ADAPTER_NAME!
|
||||
|
||||
:: --- Шаг 2: DNS ---
|
||||
echo.
|
||||
echo [2] Устанавливаю DNS Cloudflare (1.1.1.1)...
|
||||
netsh interface ipv4 set dnsservers "!ADAPTER_NAME!" static 1.1.1.1 primary validate=no >nul 2>&1
|
||||
netsh interface ipv4 add dnsservers "!ADAPTER_NAME!" 1.0.0.1 index=2 validate=no >nul 2>&1
|
||||
ipconfig /flushdns >nul 2>&1
|
||||
echo OK
|
||||
|
||||
:: --- Шаг 3: GoodbyeDPI ---
|
||||
echo.
|
||||
echo [3] Ищу GoodbyeDPI...
|
||||
if not exist "%GDPI_EXE%" (
|
||||
echo Не найден, скачиваю...
|
||||
call :DO_DOWNLOAD_GDPI
|
||||
if not exist "%GDPI_EXE%" (
|
||||
echo [!] Не удалось скачать GoodbyeDPI.
|
||||
pause
|
||||
goto MENU
|
||||
)
|
||||
)
|
||||
echo OK: %GDPI_EXE%
|
||||
|
||||
:: --- Шаг 4: Бенчмарк каждого режима ---
|
||||
echo.
|
||||
echo ============================================================
|
||||
echo Замеряю скорость каждого режима...
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
set "BEST_MODE="
|
||||
set "BEST_SCORE=99999"
|
||||
set "BEST_LABEL="
|
||||
set "MODE_NUM=0"
|
||||
|
||||
:: Benchmark function is a powershell one-liner that does
|
||||
:: 2x TCP + 1x HTTPS, returns average ms (lower=better), 99999 if fail
|
||||
set "BENCH_CMD=powershell -Command "$total=0; $ok=0; foreach($ip in @('149.154.167.51','149.154.175.50','91.108.56.100')) { foreach($i in 1..2) { $tcp=New-Object Net.Sockets.TcpClient; $sw=[Diagnostics.Stopwatch]::StartNew(); try { [void]$tcp.ConnectAsync($ip,443).Wait(4000); if($tcp.Connected){$sw.Stop();$total+=$sw.ElapsedMilliseconds;$ok++} } catch {} finally {$tcp.Dispose()} } }; try { $sw2=[Diagnostics.Stopwatch]::StartNew(); $r=Invoke-WebRequest 'https://web.telegram.org' -TimeoutSec 8 -UseBasicParsing; $sw2.Stop(); $total+=$sw2.ElapsedMilliseconds*3; $ok+=3 } catch {}; if($ok -eq 0){Write-Host 99999}else{Write-Host([math]::Floor($total/$ok))}""
|
||||
|
||||
:: Mode 1: без GoodbyeDPI (только DNS)
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] Только DNS (без GoodbyeDPI)...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=dns_only"
|
||||
set "BEST_LABEL=Только DNS"
|
||||
)
|
||||
|
||||
:: Mode 2: -9
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -9 (максимальная защита)...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -9 --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-9"
|
||||
set "BEST_LABEL=GoodbyeDPI -9"
|
||||
)
|
||||
|
||||
:: Mode 3: -5
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -5 (средний)...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -5 --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-5"
|
||||
set "BEST_LABEL=GoodbyeDPI -5"
|
||||
)
|
||||
|
||||
:: Mode 4: -1
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -1 (базовый)...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -1 --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-1"
|
||||
set "BEST_LABEL=GoodbyeDPI -1"
|
||||
)
|
||||
|
||||
:: Mode 5: custom -e2 -f2 -q -r -m
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -e2 -f2 -q -r -m...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -e 2 -f 2 -q -r -m --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-e 2 -f 2 -q -r -m"
|
||||
set "BEST_LABEL=GoodbyeDPI -e2 -f2 -q -r -m"
|
||||
)
|
||||
|
||||
:: Mode 6: custom -p -f2 -e2 -q
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -p -f2 -e2 -q...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -p -f 2 -e 2 -q --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-p -f 2 -e 2 -q"
|
||||
set "BEST_LABEL=GoodbyeDPI -p -f2 -e2 -q"
|
||||
)
|
||||
|
||||
:: Mode 7: custom -e40 -f2 -q -r -m
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -e40 -f2 -q -r -m...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -e 40 -f 2 -q -r -m --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-e 40 -f 2 -q -r -m"
|
||||
set "BEST_LABEL=GoodbyeDPI -e40 -f2 -q -r -m"
|
||||
)
|
||||
|
||||
:: Mode 8: -9 --set-ttl 5
|
||||
set /a MODE_NUM+=1
|
||||
echo [%MODE_NUM%/8] GoodbyeDPI -9 --set-ttl 5...
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
start "" /B "%GDPI_EXE%" -9 --set-ttl 5 --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
for /f "tokens=*" %%s in ('%BENCH_CMD%') do set "SCORE=%%s"
|
||||
echo Скорость: !SCORE!ms
|
||||
if !SCORE! LSS !BEST_SCORE! (
|
||||
set "BEST_SCORE=!SCORE!"
|
||||
set "BEST_MODE=-9 --set-ttl 5"
|
||||
set "BEST_LABEL=GoodbyeDPI -9 --set-ttl 5"
|
||||
)
|
||||
|
||||
:: --- Применяем лучший ---
|
||||
echo.
|
||||
echo ============================================================
|
||||
|
||||
if "!BEST_SCORE!"=="99999" (
|
||||
echo [!] Ни один режим не сработал. Попробуйте VPN или MTProxy.
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
pause
|
||||
goto MENU
|
||||
)
|
||||
|
||||
echo ЛУЧШИЙ РЕЖИМ: !BEST_LABEL!
|
||||
echo СКОРОСТЬ: !BEST_SCORE!ms
|
||||
echo ============================================================
|
||||
echo.
|
||||
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
timeout /t 1 >nul
|
||||
|
||||
if "!BEST_MODE!"=="dns_only" (
|
||||
echo [OK] DNS Cloudflare достаточно, GoodbyeDPI не нужен.
|
||||
) else (
|
||||
echo [*] Запускаю GoodbyeDPI с лучшими параметрами...
|
||||
start "" /B "%GDPI_EXE%" !BEST_MODE! --blacklist "%BLACKLIST%"
|
||||
timeout /t 2 >nul
|
||||
echo [OK] GoodbyeDPI запущен: !BEST_MODE!
|
||||
)
|
||||
|
||||
echo.
|
||||
echo ============================================================
|
||||
echo [OK] ОБХОД АКТИВИРОВАН!
|
||||
echo DNS: Cloudflare 1.1.1.1
|
||||
echo Режим: !BEST_LABEL! (!BEST_SCORE!ms)
|
||||
echo Для остановки — пункт 5 в меню.
|
||||
echo ============================================================
|
||||
pause
|
||||
goto MENU
|
||||
|
||||
:: ============================================================
|
||||
:: ВЫХОД
|
||||
:: ============================================================
|
||||
:EXIT
|
||||
echo.
|
||||
echo [*] GoodbyeDPI будет остановлен при выходе? (y/n)
|
||||
set /p "exit_choice="
|
||||
if /i "%exit_choice%"=="y" (
|
||||
taskkill /f /im goodbyedpi.exe >nul 2>&1
|
||||
echo [OK] GoodbyeDPI остановлен.
|
||||
)
|
||||
echo.
|
||||
echo Bye!
|
||||
endlocal
|
||||
exit /b 0
|
||||
@@ -0,0 +1,16 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2022",
|
||||
"useDefineForClassFields": true,
|
||||
"module": "ESNext",
|
||||
"lib": ["ES2022", "DOM", "DOM.Iterable"],
|
||||
"skipLibCheck": true,
|
||||
"moduleResolution": "Bundler",
|
||||
"allowImportingTsExtensions": false,
|
||||
"isolatedModules": true,
|
||||
"moduleDetection": "force",
|
||||
"noEmit": true,
|
||||
"strict": true
|
||||
},
|
||||
"include": ["ui"]
|
||||
}
|
||||
+383
@@ -0,0 +1,383 @@
|
||||
import { invoke } from "@tauri-apps/api/core";
|
||||
import "./styles.css";
|
||||
|
||||
type View = "home" | "settings" | "diagnostics";
|
||||
|
||||
type Status = {
|
||||
running: boolean;
|
||||
activeConnections: number;
|
||||
tunnels: number;
|
||||
dataCenter: number | null;
|
||||
route: string;
|
||||
failures: number;
|
||||
uptimeSeconds: number;
|
||||
port: number;
|
||||
logs: LogLine[];
|
||||
};
|
||||
|
||||
type LogLine = {
|
||||
timestamp: string;
|
||||
message: string;
|
||||
error: boolean;
|
||||
};
|
||||
|
||||
type Settings = {
|
||||
lanMode: boolean;
|
||||
port: number;
|
||||
workerDomain: string;
|
||||
};
|
||||
|
||||
const root = document.querySelector<HTMLDivElement>("#app")!;
|
||||
|
||||
let view: View = "home";
|
||||
let status: Status = {
|
||||
running: false,
|
||||
activeConnections: 0,
|
||||
tunnels: 0,
|
||||
dataCenter: null,
|
||||
route: "Маршрут ещё не выбран",
|
||||
failures: 0,
|
||||
uptimeSeconds: 0,
|
||||
port: 1080,
|
||||
logs: [],
|
||||
};
|
||||
let settings: Settings = { lanMode: false, port: 1080, workerDomain: "" };
|
||||
let busy = false;
|
||||
let toastTimer: number | undefined;
|
||||
|
||||
const icons = {
|
||||
arrowLeft: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="m15 18-6-6 6-6"/></svg>`,
|
||||
settings: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M12 15.5a3.5 3.5 0 1 0 0-7 3.5 3.5 0 0 0 0 7Z"/><path d="M19.4 15a1.7 1.7 0 0 0 .34 1.88l.06.06-2.86 2.86-.06-.06A1.7 1.7 0 0 0 15 19.4a1.7 1.7 0 0 0-1 .6 1.7 1.7 0 0 0-.4 1.1V21H9.6v-.1A1.7 1.7 0 0 0 8.5 19.4a1.7 1.7 0 0 0-1.88.34l-.06.06L3.7 16.94l.06-.06A1.7 1.7 0 0 0 4.1 15a1.7 1.7 0 0 0-.6-1 1.7 1.7 0 0 0-1.1-.4H2.3V9.6h.1A1.7 1.7 0 0 0 4.1 8.5a1.7 1.7 0 0 0-.34-1.88l-.06-.06L6.56 3.7l.06.06A1.7 1.7 0 0 0 8.5 4.1a1.7 1.7 0 0 0 1-.6 1.7 1.7 0 0 0 .4-1.1V2.3h4v.1A1.7 1.7 0 0 0 15 4.1a1.7 1.7 0 0 0 1.88-.34l.06-.06 2.86 2.86-.06.06A1.7 1.7 0 0 0 19.4 8.5a1.7 1.7 0 0 0 .6 1 1.7 1.7 0 0 0 1.1.4h.1v4h-.1a1.7 1.7 0 0 0-1.7 1.1Z"/></svg>`,
|
||||
activity: `<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M3 12h4l2.4-7 5.1 14 2.4-7H21"/></svg>`,
|
||||
plane: `<svg viewBox="0 0 64 64" aria-hidden="true"><path fill="currentColor" d="M52.4 11.7 8.2 28.8c-3 1.2-3 2.8-.6 3.5l11.3 3.5 4.4 13.4c.5 1.5.3 2.1 1.8 2.1 1.2 0 1.7-.5 2.4-1.2l5.5-5.3 11.5 8.5c2.1 1.2 3.7.6 4.2-2l7.6-35.8c.8-3.1-1.2-4.5-3.9-3.8ZM22.7 35l22.1-13.9c1.1-.7 2.1-.3 1.3.4L27.9 38l-.7 7.4L22.7 35Z"/></svg>`,
|
||||
};
|
||||
|
||||
function escapeHtml(value: string): string {
|
||||
return value
|
||||
.replaceAll("&", "&")
|
||||
.replaceAll("<", "<")
|
||||
.replaceAll(">", ">")
|
||||
.replaceAll('"', """);
|
||||
}
|
||||
|
||||
function formatUptime(seconds: number): string {
|
||||
const hours = Math.floor(seconds / 3600);
|
||||
const minutes = Math.floor((seconds % 3600) / 60);
|
||||
const rest = seconds % 60;
|
||||
return [hours, minutes, rest].map((value) => value.toString().padStart(2, "0")).join(":");
|
||||
}
|
||||
|
||||
function connectionState(): { title: string; subtitle: string; className: string } {
|
||||
if (!status.running) {
|
||||
return {
|
||||
title: "Защита выключена",
|
||||
subtitle: "Нажмите кнопку, чтобы подключить Telegram",
|
||||
className: "offline",
|
||||
};
|
||||
}
|
||||
if (status.failures > 0 && status.tunnels === 0) {
|
||||
return {
|
||||
title: "Ищем новый маршрут",
|
||||
subtitle: "Переключаемся на резервное подключение",
|
||||
className: "warning",
|
||||
};
|
||||
}
|
||||
if (status.tunnels > 0) {
|
||||
return {
|
||||
title: "Telegram на связи",
|
||||
subtitle: "Соединение защищено и работает",
|
||||
className: "online",
|
||||
};
|
||||
}
|
||||
return {
|
||||
title: "Защита включена",
|
||||
subtitle: "Откройте Telegram — маршрут готов",
|
||||
className: "online",
|
||||
};
|
||||
}
|
||||
|
||||
function shell(content: string, pageClass = ""): string {
|
||||
return `
|
||||
<main class="app-shell ${pageClass}">
|
||||
<div class="drag-region" data-tauri-drag-region></div>
|
||||
${content}
|
||||
<div id="toast" class="toast" role="status"></div>
|
||||
</main>
|
||||
`;
|
||||
}
|
||||
|
||||
function renderHome(): void {
|
||||
const connection = connectionState();
|
||||
root.innerHTML = shell(`
|
||||
<section class="home">
|
||||
<header class="brand">
|
||||
<div class="wordmark"><span>TG</span>Lock</div>
|
||||
<p>Свободный Telegram. В один клик.</p>
|
||||
</header>
|
||||
|
||||
<div class="hero ${connection.className}">
|
||||
<div class="orb-field">
|
||||
<div class="orbit orbit-one"></div>
|
||||
<div class="orbit orbit-two"></div>
|
||||
<div class="orb">
|
||||
<div class="orb-shine"></div>
|
||||
${icons.plane}
|
||||
</div>
|
||||
</div>
|
||||
<div class="connection-copy">
|
||||
<div class="status-line">
|
||||
<span class="status-dot"></span>
|
||||
<h1>${connection.title}</h1>
|
||||
</div>
|
||||
<p>${connection.subtitle}</p>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<button id="power" class="power-button ${status.running ? "stop" : ""}" ${busy ? "disabled" : ""}>
|
||||
<span>${busy ? "Подождите…" : status.running ? "Выключить" : "Включить защиту"}</span>
|
||||
<span class="button-arrow">→</span>
|
||||
</button>
|
||||
|
||||
<div class="route-pill">
|
||||
<span class="route-pulse"></span>
|
||||
<span>${escapeHtml(status.route)}</span>
|
||||
<span class="route-separator">·</span>
|
||||
<span>порт ${status.port}</span>
|
||||
</div>
|
||||
|
||||
<nav class="bottom-nav" aria-label="Разделы">
|
||||
<button id="settings-nav" class="nav-button">
|
||||
<span class="nav-icon">${icons.settings}</span>
|
||||
<span>Настройки</span>
|
||||
</button>
|
||||
<div class="nav-divider"></div>
|
||||
<button id="diagnostics-nav" class="nav-button">
|
||||
<span class="nav-icon">${icons.activity}</span>
|
||||
<span>Диагностика</span>
|
||||
</button>
|
||||
</nav>
|
||||
</section>
|
||||
`, "home-page");
|
||||
|
||||
document.querySelector("#power")?.addEventListener("click", toggleProtection);
|
||||
document.querySelector("#settings-nav")?.addEventListener("click", () => navigate("settings"));
|
||||
document.querySelector("#diagnostics-nav")?.addEventListener("click", () => navigate("diagnostics"));
|
||||
}
|
||||
|
||||
function pageHeader(title: string, subtitle: string): string {
|
||||
return `
|
||||
<header class="page-header">
|
||||
<button class="back-button" id="back" aria-label="Назад">${icons.arrowLeft}</button>
|
||||
<div>
|
||||
<h1>${title}</h1>
|
||||
<p>${subtitle}</p>
|
||||
</div>
|
||||
</header>
|
||||
`;
|
||||
}
|
||||
|
||||
function renderSettings(): void {
|
||||
root.innerHTML = shell(`
|
||||
<section class="subpage">
|
||||
${pageHeader("Настройки", "Подключение и локальная сеть")}
|
||||
|
||||
<form id="settings-form" class="settings-form">
|
||||
<div class="setting-card">
|
||||
<label class="field-label" for="worker">Cloudflare Worker</label>
|
||||
<input
|
||||
id="worker"
|
||||
name="worker"
|
||||
type="text"
|
||||
value="${escapeHtml(settings.workerDomain)}"
|
||||
placeholder="example.workers.dev"
|
||||
autocomplete="off"
|
||||
${status.running ? "disabled" : ""}
|
||||
/>
|
||||
<p class="field-hint">Необязательно. Используется как резервный маршрут.</p>
|
||||
</div>
|
||||
|
||||
<div class="setting-list">
|
||||
<label class="setting-row" for="lan-mode">
|
||||
<span>
|
||||
<strong>Доступ из локальной сети</strong>
|
||||
<small>Подключение других устройств</small>
|
||||
</span>
|
||||
<span class="switch">
|
||||
<input id="lan-mode" type="checkbox" ${settings.lanMode ? "checked" : ""} ${status.running ? "disabled" : ""}/>
|
||||
<span class="switch-track"></span>
|
||||
</span>
|
||||
</label>
|
||||
<div class="setting-rule"></div>
|
||||
<label class="setting-row compact" for="port">
|
||||
<span>
|
||||
<strong>Локальный порт</strong>
|
||||
<small>SOCKS5 и MTProto</small>
|
||||
</span>
|
||||
<input id="port" class="port-input" type="number" min="1" max="65535" value="${settings.port}" ${status.running ? "disabled" : ""}/>
|
||||
</label>
|
||||
</div>
|
||||
|
||||
${status.running ? `<div class="locked-note"><span></span>Выключите защиту, чтобы изменить настройки</div>` : ""}
|
||||
|
||||
<button class="save-button" type="submit" ${status.running || busy ? "disabled" : ""}>
|
||||
${busy ? "Сохраняю…" : "Сохранить настройки"}
|
||||
</button>
|
||||
</form>
|
||||
</section>
|
||||
`, "subpage-shell");
|
||||
|
||||
document.querySelector("#back")?.addEventListener("click", () => navigate("home"));
|
||||
document.querySelector("#settings-form")?.addEventListener("submit", saveSettings);
|
||||
}
|
||||
|
||||
function renderDiagnostics(): void {
|
||||
const recentLogs = status.logs.slice(-4).reverse();
|
||||
root.innerHTML = shell(`
|
||||
<section class="subpage">
|
||||
${pageHeader("Диагностика", "Состояние маршрута в реальном времени")}
|
||||
|
||||
<div class="connection-banner ${status.running ? "active" : ""}">
|
||||
<span class="banner-icon">${icons.activity}</span>
|
||||
<div>
|
||||
<strong>${status.running ? "Сервис работает" : "Сервис остановлен"}</strong>
|
||||
<small>${status.running ? "Локальный прокси принимает подключения" : "Включите защиту на главном экране"}</small>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="metrics-grid">
|
||||
<article class="metric-card">
|
||||
<span>Соединения</span>
|
||||
<strong>${status.activeConnections}</strong>
|
||||
</article>
|
||||
<article class="metric-card">
|
||||
<span>Туннели</span>
|
||||
<strong>${status.tunnels}</strong>
|
||||
</article>
|
||||
<article class="metric-card">
|
||||
<span>Дата-центр</span>
|
||||
<strong>${status.dataCenter ? `DC${status.dataCenter}` : "—"}</strong>
|
||||
</article>
|
||||
<article class="metric-card">
|
||||
<span>Время работы</span>
|
||||
<strong class="time">${formatUptime(status.uptimeSeconds)}</strong>
|
||||
</article>
|
||||
</div>
|
||||
|
||||
<div class="log-panel">
|
||||
<div class="log-heading">
|
||||
<span>Последние события</span>
|
||||
<span class="live-label"><i></i>LIVE</span>
|
||||
</div>
|
||||
<div class="logs">
|
||||
${recentLogs.length
|
||||
? recentLogs
|
||||
.map(
|
||||
(line) => `
|
||||
<div class="log-line ${line.error ? "error" : ""}">
|
||||
<time>${line.timestamp}</time>
|
||||
<span>${escapeHtml(line.message)}</span>
|
||||
</div>`,
|
||||
)
|
||||
.join("")
|
||||
: `<div class="empty-log">События появятся после включения защиты</div>`}
|
||||
</div>
|
||||
</div>
|
||||
</section>
|
||||
`, "subpage-shell");
|
||||
|
||||
document.querySelector("#back")?.addEventListener("click", () => navigate("home"));
|
||||
}
|
||||
|
||||
function render(): void {
|
||||
if (view === "settings") renderSettings();
|
||||
else if (view === "diagnostics") renderDiagnostics();
|
||||
else renderHome();
|
||||
}
|
||||
|
||||
function navigate(next: View): void {
|
||||
view = next;
|
||||
render();
|
||||
}
|
||||
|
||||
async function refreshStatus(): Promise<void> {
|
||||
try {
|
||||
status = await invoke<Status>("get_status");
|
||||
if (view !== "settings") render();
|
||||
} catch (error) {
|
||||
showToast(String(error), true);
|
||||
}
|
||||
}
|
||||
|
||||
async function toggleProtection(): Promise<void> {
|
||||
if (busy) return;
|
||||
busy = true;
|
||||
renderHome();
|
||||
try {
|
||||
status = status.running
|
||||
? await invoke<Status>("stop_proxy")
|
||||
: await invoke<Status>("start_proxy");
|
||||
} catch (error) {
|
||||
showToast(String(error), true);
|
||||
} finally {
|
||||
busy = false;
|
||||
await refreshStatus();
|
||||
}
|
||||
}
|
||||
|
||||
async function saveSettings(event: Event): Promise<void> {
|
||||
event.preventDefault();
|
||||
if (busy || status.running) return;
|
||||
const worker = document.querySelector<HTMLInputElement>("#worker");
|
||||
const lanMode = document.querySelector<HTMLInputElement>("#lan-mode");
|
||||
const port = document.querySelector<HTMLInputElement>("#port");
|
||||
if (!worker || !lanMode || !port) return;
|
||||
|
||||
const parsedPort = Number(port.value);
|
||||
if (!Number.isInteger(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
|
||||
showToast("Порт должен быть от 1 до 65535", true);
|
||||
return;
|
||||
}
|
||||
|
||||
busy = true;
|
||||
settings = {
|
||||
workerDomain: worker.value.trim(),
|
||||
lanMode: lanMode.checked,
|
||||
port: parsedPort,
|
||||
};
|
||||
renderSettings();
|
||||
try {
|
||||
settings = await invoke<Settings>("save_settings", { settings });
|
||||
showToast("Настройки сохранены");
|
||||
window.setTimeout(() => navigate("home"), 350);
|
||||
} catch (error) {
|
||||
showToast(String(error), true);
|
||||
} finally {
|
||||
busy = false;
|
||||
}
|
||||
}
|
||||
|
||||
function showToast(message: string, error = false): void {
|
||||
window.clearTimeout(toastTimer);
|
||||
window.requestAnimationFrame(() => {
|
||||
const toast = document.querySelector<HTMLDivElement>("#toast");
|
||||
if (!toast) return;
|
||||
toast.textContent = message.replace(/^["']|["']$/g, "");
|
||||
toast.className = `toast visible${error ? " error" : ""}`;
|
||||
toastTimer = window.setTimeout(() => toast.classList.remove("visible"), 2800);
|
||||
});
|
||||
}
|
||||
|
||||
async function bootstrap(): Promise<void> {
|
||||
try {
|
||||
[status, settings] = await Promise.all([
|
||||
invoke<Status>("get_status"),
|
||||
invoke<Settings>("get_settings"),
|
||||
]);
|
||||
} catch {
|
||||
// The browser preview intentionally uses the initial local state.
|
||||
}
|
||||
render();
|
||||
window.setInterval(refreshStatus, 1000);
|
||||
}
|
||||
|
||||
void bootstrap();
|
||||
+849
@@ -0,0 +1,849 @@
|
||||
:root {
|
||||
color-scheme: dark;
|
||||
font-family:
|
||||
Inter, ui-sans-serif, -apple-system, BlinkMacSystemFont, "SF Pro Display",
|
||||
"Segoe UI", sans-serif;
|
||||
font-synthesis: none;
|
||||
text-rendering: geometricPrecision;
|
||||
--bg: #070a10;
|
||||
--panel: rgba(18, 24, 36, 0.78);
|
||||
--panel-strong: #111827;
|
||||
--line: rgba(148, 163, 184, 0.12);
|
||||
--text: #f4f8ff;
|
||||
--muted: #7e8ca3;
|
||||
--blue: #45a9ff;
|
||||
--blue-strong: #168dff;
|
||||
--green: #55e7a6;
|
||||
--red: #ff6b7d;
|
||||
}
|
||||
|
||||
* {
|
||||
box-sizing: border-box;
|
||||
}
|
||||
|
||||
html,
|
||||
body,
|
||||
#app {
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
margin: 0;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
body {
|
||||
color: var(--text);
|
||||
background: var(--bg);
|
||||
user-select: none;
|
||||
}
|
||||
|
||||
button,
|
||||
input {
|
||||
font: inherit;
|
||||
}
|
||||
|
||||
button {
|
||||
color: inherit;
|
||||
}
|
||||
|
||||
.app-shell {
|
||||
position: relative;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
overflow: hidden;
|
||||
background:
|
||||
radial-gradient(circle at 50% 31%, rgba(19, 116, 220, 0.16), transparent 34%),
|
||||
radial-gradient(circle at 88% 4%, rgba(71, 119, 255, 0.08), transparent 30%),
|
||||
linear-gradient(165deg, #0b1019 0%, #070a10 58%, #090d15 100%);
|
||||
}
|
||||
|
||||
.app-shell::before {
|
||||
content: "";
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
opacity: 0.13;
|
||||
pointer-events: none;
|
||||
background-image: url("data:image/svg+xml,%3Csvg viewBox='0 0 140 140' xmlns='http://www.w3.org/2000/svg'%3E%3Cfilter id='n'%3E%3CfeTurbulence type='fractalNoise' baseFrequency='.8' numOctaves='3' stitchTiles='stitch'/%3E%3C/filter%3E%3Crect width='100%25' height='100%25' filter='url(%23n)' opacity='.18'/%3E%3C/svg%3E");
|
||||
}
|
||||
|
||||
.drag-region {
|
||||
position: absolute;
|
||||
z-index: 10;
|
||||
top: 0;
|
||||
left: 0;
|
||||
right: 0;
|
||||
height: 38px;
|
||||
}
|
||||
|
||||
.home,
|
||||
.subpage {
|
||||
position: relative;
|
||||
z-index: 1;
|
||||
height: 100%;
|
||||
}
|
||||
|
||||
.home {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
padding: 48px 34px 24px;
|
||||
}
|
||||
|
||||
.brand {
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.wordmark {
|
||||
font-size: 27px;
|
||||
font-weight: 760;
|
||||
letter-spacing: -1.1px;
|
||||
}
|
||||
|
||||
.wordmark span {
|
||||
color: var(--blue);
|
||||
}
|
||||
|
||||
.brand p {
|
||||
margin: 5px 0 0;
|
||||
color: var(--muted);
|
||||
font-size: 12px;
|
||||
font-weight: 480;
|
||||
letter-spacing: 0.08px;
|
||||
}
|
||||
|
||||
.hero {
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
margin-top: 24px;
|
||||
}
|
||||
|
||||
.orb-field {
|
||||
position: relative;
|
||||
display: grid;
|
||||
width: 184px;
|
||||
height: 184px;
|
||||
place-items: center;
|
||||
}
|
||||
|
||||
.orb-field::before {
|
||||
content: "";
|
||||
position: absolute;
|
||||
width: 108px;
|
||||
height: 108px;
|
||||
border-radius: 50%;
|
||||
background: rgba(35, 126, 221, 0.26);
|
||||
filter: blur(30px);
|
||||
transform: scale(1.25);
|
||||
transition: background 500ms ease;
|
||||
}
|
||||
|
||||
.online .orb-field::before {
|
||||
background: rgba(33, 203, 149, 0.28);
|
||||
}
|
||||
|
||||
.orbit {
|
||||
position: absolute;
|
||||
border: 1px solid rgba(83, 174, 255, 0.15);
|
||||
border-radius: 50%;
|
||||
}
|
||||
|
||||
.orbit-one {
|
||||
inset: 10px;
|
||||
border-left-color: rgba(79, 172, 255, 0.48);
|
||||
transform: rotate(-30deg);
|
||||
}
|
||||
|
||||
.orbit-two {
|
||||
inset: 22px;
|
||||
border-right-color: rgba(79, 172, 255, 0.34);
|
||||
transform: rotate(22deg);
|
||||
}
|
||||
|
||||
.orb {
|
||||
position: relative;
|
||||
display: grid;
|
||||
width: 112px;
|
||||
height: 112px;
|
||||
overflow: hidden;
|
||||
color: white;
|
||||
border: 1px solid rgba(137, 204, 255, 0.66);
|
||||
border-radius: 50%;
|
||||
place-items: center;
|
||||
background:
|
||||
linear-gradient(145deg, rgba(255, 255, 255, 0.16), transparent 40%),
|
||||
linear-gradient(145deg, #269fff, #0d5fbd);
|
||||
box-shadow:
|
||||
inset 0 1px 1px rgba(255, 255, 255, 0.38),
|
||||
inset 0 -14px 28px rgba(1, 21, 56, 0.28),
|
||||
0 0 0 8px rgba(34, 129, 223, 0.06),
|
||||
0 18px 45px rgba(2, 90, 183, 0.34);
|
||||
transition: filter 300ms ease, background 500ms ease;
|
||||
}
|
||||
|
||||
.offline .orb {
|
||||
filter: saturate(0.44) brightness(0.72);
|
||||
}
|
||||
|
||||
.online .orb {
|
||||
border-color: rgba(112, 245, 192, 0.72);
|
||||
background:
|
||||
linear-gradient(145deg, rgba(255, 255, 255, 0.16), transparent 40%),
|
||||
linear-gradient(145deg, #29c995, #087e78);
|
||||
box-shadow:
|
||||
inset 0 1px 1px rgba(255, 255, 255, 0.38),
|
||||
inset 0 -14px 28px rgba(1, 46, 54, 0.28),
|
||||
0 0 0 8px rgba(34, 220, 157, 0.06),
|
||||
0 18px 45px rgba(9, 182, 133, 0.3);
|
||||
}
|
||||
|
||||
.orb svg {
|
||||
z-index: 1;
|
||||
width: 55px;
|
||||
height: 55px;
|
||||
transform: translate(-1px, 1px);
|
||||
filter: drop-shadow(0 5px 10px rgba(0, 32, 75, 0.3));
|
||||
}
|
||||
|
||||
.orb-shine {
|
||||
position: absolute;
|
||||
top: -34px;
|
||||
left: 6px;
|
||||
width: 96px;
|
||||
height: 72px;
|
||||
border-radius: 50%;
|
||||
background: rgba(255, 255, 255, 0.11);
|
||||
transform: rotate(-20deg);
|
||||
filter: blur(5px);
|
||||
}
|
||||
|
||||
.connection-copy {
|
||||
margin-top: 11px;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.status-line {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 9px;
|
||||
}
|
||||
|
||||
.status-line h1 {
|
||||
margin: 0;
|
||||
font-size: 19px;
|
||||
font-weight: 680;
|
||||
letter-spacing: -0.3px;
|
||||
}
|
||||
|
||||
.status-dot {
|
||||
width: 7px;
|
||||
height: 7px;
|
||||
border-radius: 50%;
|
||||
background: #526177;
|
||||
box-shadow: 0 0 0 4px rgba(82, 97, 119, 0.11);
|
||||
}
|
||||
|
||||
.online .status-dot {
|
||||
background: var(--green);
|
||||
box-shadow: 0 0 12px rgba(85, 231, 166, 0.8);
|
||||
}
|
||||
|
||||
.warning .status-dot {
|
||||
background: #ffbf5b;
|
||||
}
|
||||
|
||||
.connection-copy p {
|
||||
margin: 6px 0 0;
|
||||
color: var(--muted);
|
||||
font-size: 11.5px;
|
||||
}
|
||||
|
||||
.power-button {
|
||||
display: flex;
|
||||
width: 100%;
|
||||
height: 54px;
|
||||
margin-top: 24px;
|
||||
padding: 0 21px 0 25px;
|
||||
cursor: pointer;
|
||||
border: 1px solid rgba(118, 196, 255, 0.5);
|
||||
border-radius: 16px;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
background:
|
||||
linear-gradient(180deg, rgba(255, 255, 255, 0.14), transparent),
|
||||
linear-gradient(135deg, #3eaaff, #1685ee);
|
||||
box-shadow:
|
||||
inset 0 1px 0 rgba(255, 255, 255, 0.26),
|
||||
0 12px 28px rgba(7, 103, 204, 0.28);
|
||||
font-size: 14px;
|
||||
font-weight: 690;
|
||||
transition: transform 150ms ease, filter 150ms ease, box-shadow 150ms ease;
|
||||
}
|
||||
|
||||
.power-button:hover {
|
||||
filter: brightness(1.08);
|
||||
box-shadow:
|
||||
inset 0 1px 0 rgba(255, 255, 255, 0.26),
|
||||
0 14px 34px rgba(7, 103, 204, 0.38);
|
||||
}
|
||||
|
||||
.power-button:active {
|
||||
transform: scale(0.985);
|
||||
}
|
||||
|
||||
.power-button.stop {
|
||||
color: #c9d6e8;
|
||||
border-color: rgba(148, 163, 184, 0.18);
|
||||
background: rgba(26, 34, 48, 0.8);
|
||||
box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
|
||||
}
|
||||
|
||||
.power-button:disabled {
|
||||
cursor: default;
|
||||
opacity: 0.62;
|
||||
}
|
||||
|
||||
.button-arrow {
|
||||
font-size: 20px;
|
||||
font-weight: 400;
|
||||
}
|
||||
|
||||
.route-pill {
|
||||
display: flex;
|
||||
height: 30px;
|
||||
margin-top: 12px;
|
||||
padding: 0 12px;
|
||||
color: #78879e;
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 999px;
|
||||
align-items: center;
|
||||
gap: 7px;
|
||||
background: rgba(17, 24, 37, 0.54);
|
||||
font-size: 10px;
|
||||
}
|
||||
|
||||
.route-pulse {
|
||||
width: 5px;
|
||||
height: 5px;
|
||||
border-radius: 50%;
|
||||
background: var(--blue);
|
||||
box-shadow: 0 0 8px rgba(69, 169, 255, 0.7);
|
||||
}
|
||||
|
||||
.route-separator {
|
||||
opacity: 0.45;
|
||||
}
|
||||
|
||||
.bottom-nav {
|
||||
display: flex;
|
||||
width: 100%;
|
||||
margin-top: auto;
|
||||
padding: 11px 8px 3px;
|
||||
border-top: 1px solid var(--line);
|
||||
justify-content: center;
|
||||
}
|
||||
|
||||
.nav-button {
|
||||
display: flex;
|
||||
min-width: 134px;
|
||||
height: 38px;
|
||||
padding: 0 14px;
|
||||
cursor: pointer;
|
||||
color: #8694aa;
|
||||
border: 0;
|
||||
border-radius: 11px;
|
||||
align-items: center;
|
||||
justify-content: center;
|
||||
gap: 8px;
|
||||
background: transparent;
|
||||
font-size: 11px;
|
||||
transition: color 150ms ease, background 150ms ease;
|
||||
}
|
||||
|
||||
.nav-button:hover {
|
||||
color: #cbd8ea;
|
||||
background: rgba(255, 255, 255, 0.035);
|
||||
}
|
||||
|
||||
.nav-icon,
|
||||
.banner-icon {
|
||||
display: grid;
|
||||
place-items: center;
|
||||
}
|
||||
|
||||
.nav-icon svg {
|
||||
width: 17px;
|
||||
height: 17px;
|
||||
fill: none;
|
||||
stroke: currentColor;
|
||||
stroke-width: 1.6;
|
||||
stroke-linecap: round;
|
||||
stroke-linejoin: round;
|
||||
}
|
||||
|
||||
.nav-divider {
|
||||
width: 1px;
|
||||
height: 20px;
|
||||
margin: 9px 5px;
|
||||
background: var(--line);
|
||||
}
|
||||
|
||||
.subpage {
|
||||
padding: 54px 30px 26px;
|
||||
}
|
||||
|
||||
.subpage-shell {
|
||||
background:
|
||||
radial-gradient(circle at 100% 0, rgba(32, 123, 220, 0.13), transparent 35%),
|
||||
linear-gradient(165deg, #0b1019, #070a10);
|
||||
}
|
||||
|
||||
.page-header {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 14px;
|
||||
}
|
||||
|
||||
.back-button {
|
||||
display: grid;
|
||||
width: 38px;
|
||||
height: 38px;
|
||||
padding: 0;
|
||||
cursor: pointer;
|
||||
color: #bdc9da;
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 12px;
|
||||
place-items: center;
|
||||
background: rgba(18, 26, 40, 0.72);
|
||||
transition: background 150ms ease, border-color 150ms ease;
|
||||
}
|
||||
|
||||
.back-button:hover {
|
||||
border-color: rgba(92, 174, 255, 0.3);
|
||||
background: rgba(28, 42, 61, 0.82);
|
||||
}
|
||||
|
||||
.back-button svg {
|
||||
width: 18px;
|
||||
fill: none;
|
||||
stroke: currentColor;
|
||||
stroke-width: 1.8;
|
||||
stroke-linecap: round;
|
||||
stroke-linejoin: round;
|
||||
}
|
||||
|
||||
.page-header h1 {
|
||||
margin: 0;
|
||||
font-size: 22px;
|
||||
font-weight: 720;
|
||||
letter-spacing: -0.5px;
|
||||
}
|
||||
|
||||
.page-header p {
|
||||
margin: 4px 0 0;
|
||||
color: var(--muted);
|
||||
font-size: 11px;
|
||||
}
|
||||
|
||||
.settings-form {
|
||||
margin-top: 27px;
|
||||
}
|
||||
|
||||
.setting-card,
|
||||
.setting-list,
|
||||
.connection-banner,
|
||||
.metric-card,
|
||||
.log-panel {
|
||||
border: 1px solid var(--line);
|
||||
background:
|
||||
linear-gradient(145deg, rgba(255, 255, 255, 0.025), transparent),
|
||||
rgba(15, 22, 34, 0.76);
|
||||
box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.025);
|
||||
}
|
||||
|
||||
.setting-card {
|
||||
padding: 18px;
|
||||
border-radius: 16px;
|
||||
}
|
||||
|
||||
.field-label {
|
||||
display: block;
|
||||
margin-bottom: 10px;
|
||||
color: #dfe8f5;
|
||||
font-size: 12px;
|
||||
font-weight: 630;
|
||||
}
|
||||
|
||||
.setting-card input,
|
||||
.port-input {
|
||||
color: var(--text);
|
||||
outline: none;
|
||||
border: 1px solid rgba(125, 154, 190, 0.18);
|
||||
background: rgba(6, 10, 17, 0.72);
|
||||
transition: border-color 150ms ease, box-shadow 150ms ease;
|
||||
}
|
||||
|
||||
.setting-card input {
|
||||
width: 100%;
|
||||
height: 42px;
|
||||
padding: 0 13px;
|
||||
border-radius: 11px;
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
.setting-card input:focus,
|
||||
.port-input:focus {
|
||||
border-color: rgba(69, 169, 255, 0.65);
|
||||
box-shadow: 0 0 0 3px rgba(69, 169, 255, 0.1);
|
||||
}
|
||||
|
||||
input::placeholder {
|
||||
color: #4f5b6d;
|
||||
}
|
||||
|
||||
input:disabled {
|
||||
cursor: not-allowed;
|
||||
opacity: 0.55;
|
||||
}
|
||||
|
||||
.field-hint {
|
||||
margin: 8px 0 0;
|
||||
color: #66758b;
|
||||
font-size: 9.5px;
|
||||
}
|
||||
|
||||
.setting-list {
|
||||
margin-top: 13px;
|
||||
padding: 4px 18px;
|
||||
border-radius: 16px;
|
||||
}
|
||||
|
||||
.setting-row {
|
||||
display: flex;
|
||||
min-height: 68px;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
}
|
||||
|
||||
.setting-row strong {
|
||||
display: block;
|
||||
font-size: 12px;
|
||||
font-weight: 620;
|
||||
}
|
||||
|
||||
.setting-row small {
|
||||
display: block;
|
||||
margin-top: 4px;
|
||||
color: var(--muted);
|
||||
font-size: 9.5px;
|
||||
}
|
||||
|
||||
.setting-rule {
|
||||
height: 1px;
|
||||
background: var(--line);
|
||||
}
|
||||
|
||||
.switch {
|
||||
position: relative;
|
||||
width: 42px;
|
||||
height: 24px;
|
||||
}
|
||||
|
||||
.switch input {
|
||||
position: absolute;
|
||||
opacity: 0;
|
||||
}
|
||||
|
||||
.switch-track {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
cursor: pointer;
|
||||
border: 1px solid rgba(148, 163, 184, 0.2);
|
||||
border-radius: 999px;
|
||||
background: #202a39;
|
||||
transition: background 180ms ease;
|
||||
}
|
||||
|
||||
.switch-track::after {
|
||||
content: "";
|
||||
position: absolute;
|
||||
top: 3px;
|
||||
left: 3px;
|
||||
width: 16px;
|
||||
height: 16px;
|
||||
border-radius: 50%;
|
||||
background: #8e9bad;
|
||||
box-shadow: 0 2px 5px rgba(0, 0, 0, 0.3);
|
||||
transition: transform 180ms ease, background 180ms ease;
|
||||
}
|
||||
|
||||
.switch input:checked + .switch-track {
|
||||
border-color: rgba(69, 169, 255, 0.5);
|
||||
background: var(--blue-strong);
|
||||
}
|
||||
|
||||
.switch input:checked + .switch-track::after {
|
||||
background: white;
|
||||
transform: translateX(18px);
|
||||
}
|
||||
|
||||
.port-input {
|
||||
width: 78px;
|
||||
height: 34px;
|
||||
text-align: center;
|
||||
border-radius: 10px;
|
||||
font-size: 12px;
|
||||
appearance: textfield;
|
||||
}
|
||||
|
||||
.locked-note {
|
||||
display: flex;
|
||||
margin: 13px 2px 0;
|
||||
color: #8d9aab;
|
||||
align-items: center;
|
||||
gap: 8px;
|
||||
font-size: 10px;
|
||||
}
|
||||
|
||||
.locked-note span {
|
||||
width: 6px;
|
||||
height: 6px;
|
||||
border-radius: 50%;
|
||||
background: #ffb84f;
|
||||
}
|
||||
|
||||
.save-button {
|
||||
width: 100%;
|
||||
height: 48px;
|
||||
margin-top: 18px;
|
||||
cursor: pointer;
|
||||
color: white;
|
||||
border: 1px solid rgba(100, 186, 255, 0.45);
|
||||
border-radius: 14px;
|
||||
background: linear-gradient(135deg, #36a8ff, #147fe8);
|
||||
box-shadow: 0 10px 24px rgba(6, 94, 185, 0.22);
|
||||
font-size: 12px;
|
||||
font-weight: 680;
|
||||
}
|
||||
|
||||
.save-button:disabled {
|
||||
cursor: not-allowed;
|
||||
opacity: 0.45;
|
||||
box-shadow: none;
|
||||
}
|
||||
|
||||
.connection-banner {
|
||||
display: flex;
|
||||
margin-top: 27px;
|
||||
padding: 16px;
|
||||
border-radius: 16px;
|
||||
align-items: center;
|
||||
gap: 13px;
|
||||
}
|
||||
|
||||
.connection-banner.active {
|
||||
border-color: rgba(68, 219, 159, 0.18);
|
||||
background:
|
||||
linear-gradient(145deg, rgba(44, 207, 151, 0.055), transparent),
|
||||
rgba(15, 22, 34, 0.76);
|
||||
}
|
||||
|
||||
.banner-icon {
|
||||
width: 38px;
|
||||
height: 38px;
|
||||
color: #7c8da5;
|
||||
border-radius: 12px;
|
||||
background: rgba(112, 129, 153, 0.1);
|
||||
}
|
||||
|
||||
.active .banner-icon {
|
||||
color: var(--green);
|
||||
background: rgba(65, 221, 159, 0.1);
|
||||
}
|
||||
|
||||
.banner-icon svg {
|
||||
width: 19px;
|
||||
fill: none;
|
||||
stroke: currentColor;
|
||||
stroke-width: 1.7;
|
||||
stroke-linecap: round;
|
||||
stroke-linejoin: round;
|
||||
}
|
||||
|
||||
.connection-banner strong,
|
||||
.connection-banner small {
|
||||
display: block;
|
||||
}
|
||||
|
||||
.connection-banner strong {
|
||||
font-size: 12px;
|
||||
}
|
||||
|
||||
.connection-banner small {
|
||||
margin-top: 4px;
|
||||
color: var(--muted);
|
||||
font-size: 9.5px;
|
||||
}
|
||||
|
||||
.metrics-grid {
|
||||
display: grid;
|
||||
margin-top: 13px;
|
||||
grid-template-columns: repeat(2, 1fr);
|
||||
gap: 10px;
|
||||
}
|
||||
|
||||
.metric-card {
|
||||
height: 84px;
|
||||
padding: 16px;
|
||||
border-radius: 15px;
|
||||
}
|
||||
|
||||
.metric-card span {
|
||||
display: block;
|
||||
color: var(--muted);
|
||||
font-size: 9.5px;
|
||||
}
|
||||
|
||||
.metric-card strong {
|
||||
display: block;
|
||||
margin-top: 9px;
|
||||
font-size: 21px;
|
||||
letter-spacing: -0.5px;
|
||||
}
|
||||
|
||||
.metric-card strong.time {
|
||||
font-family: "SF Mono", ui-monospace, monospace;
|
||||
font-size: 17px;
|
||||
letter-spacing: -0.7px;
|
||||
}
|
||||
|
||||
.log-panel {
|
||||
margin-top: 13px;
|
||||
padding: 16px;
|
||||
border-radius: 16px;
|
||||
}
|
||||
|
||||
.log-heading {
|
||||
display: flex;
|
||||
color: #dbe5f3;
|
||||
align-items: center;
|
||||
justify-content: space-between;
|
||||
font-size: 10px;
|
||||
font-weight: 640;
|
||||
}
|
||||
|
||||
.live-label {
|
||||
display: flex;
|
||||
color: #65748a;
|
||||
align-items: center;
|
||||
gap: 5px;
|
||||
font-size: 8px;
|
||||
letter-spacing: 0.7px;
|
||||
}
|
||||
|
||||
.live-label i {
|
||||
width: 5px;
|
||||
height: 5px;
|
||||
border-radius: 50%;
|
||||
background: var(--green);
|
||||
box-shadow: 0 0 7px rgba(85, 231, 166, 0.75);
|
||||
}
|
||||
|
||||
.logs {
|
||||
min-height: 96px;
|
||||
margin-top: 13px;
|
||||
}
|
||||
|
||||
.log-line {
|
||||
display: grid;
|
||||
padding: 6px 0;
|
||||
color: #8c9ab0;
|
||||
grid-template-columns: 58px 1fr;
|
||||
gap: 6px;
|
||||
font-family: "SF Mono", ui-monospace, monospace;
|
||||
font-size: 8.7px;
|
||||
line-height: 1.35;
|
||||
}
|
||||
|
||||
.log-line.error {
|
||||
color: var(--red);
|
||||
}
|
||||
|
||||
.log-line time {
|
||||
color: #556276;
|
||||
}
|
||||
|
||||
.empty-log {
|
||||
display: grid;
|
||||
height: 92px;
|
||||
color: #59677b;
|
||||
place-items: center;
|
||||
font-size: 9px;
|
||||
}
|
||||
|
||||
.toast {
|
||||
position: absolute;
|
||||
z-index: 20;
|
||||
left: 50%;
|
||||
bottom: 22px;
|
||||
max-width: calc(100% - 48px);
|
||||
padding: 10px 14px;
|
||||
pointer-events: none;
|
||||
color: #dff9ed;
|
||||
border: 1px solid rgba(73, 222, 161, 0.25);
|
||||
border-radius: 10px;
|
||||
opacity: 0;
|
||||
background: rgba(16, 44, 38, 0.94);
|
||||
box-shadow: 0 10px 30px rgba(0, 0, 0, 0.3);
|
||||
font-size: 10px;
|
||||
text-align: center;
|
||||
transform: translate(-50%, 8px);
|
||||
transition: opacity 160ms ease, transform 160ms ease;
|
||||
}
|
||||
|
||||
.toast.error {
|
||||
color: #ffe0e4;
|
||||
border-color: rgba(255, 107, 125, 0.25);
|
||||
background: rgba(60, 23, 32, 0.96);
|
||||
}
|
||||
|
||||
.toast.visible {
|
||||
opacity: 1;
|
||||
transform: translate(-50%, 0);
|
||||
}
|
||||
|
||||
@media (prefers-reduced-motion: no-preference) {
|
||||
.online .orbit-one {
|
||||
animation: orbit-spin 12s linear infinite;
|
||||
}
|
||||
|
||||
.online .orbit-two {
|
||||
animation: orbit-spin-reverse 16s linear infinite;
|
||||
}
|
||||
|
||||
.online .orb {
|
||||
animation: orb-breathe 3.6s ease-in-out infinite;
|
||||
}
|
||||
}
|
||||
|
||||
@keyframes orbit-spin {
|
||||
to {
|
||||
transform: rotate(330deg);
|
||||
}
|
||||
}
|
||||
|
||||
@keyframes orbit-spin-reverse {
|
||||
to {
|
||||
transform: rotate(-338deg);
|
||||
}
|
||||
}
|
||||
|
||||
@keyframes orb-breathe {
|
||||
50% {
|
||||
box-shadow:
|
||||
inset 0 1px 1px rgba(255, 255, 255, 0.38),
|
||||
inset 0 -14px 28px rgba(1, 46, 54, 0.28),
|
||||
0 0 0 11px rgba(34, 220, 157, 0.04),
|
||||
0 19px 52px rgba(9, 182, 133, 0.4);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
import { defineConfig } from "vite";
|
||||
|
||||
export default defineConfig({
|
||||
clearScreen: false,
|
||||
build: {
|
||||
outDir: "dist-ui",
|
||||
},
|
||||
server: {
|
||||
strictPort: true,
|
||||
watch: {
|
||||
ignored: ["**/target/**"],
|
||||
},
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,104 @@
|
||||
// Резервный маршрут TGLock через Cloudflare Worker.
|
||||
//
|
||||
// Нужен в одном случае: провайдер заблокировал саму веб-инфраструктуру
|
||||
// Telegram, и все обычные маршруты TGLock перестали отвечать. Тогда соединение
|
||||
// идёт на твой домен *.workers.dev, а воркер доводит его до Telegram.
|
||||
//
|
||||
// Инструкция по установке: docs/CLOUDFLARE_WORKER.md
|
||||
//
|
||||
// Контракт, который ожидает клиент (src/transport.rs):
|
||||
// wss://<домен>/apiws?dst=<telegram-ip>&dc=<номер-dc>
|
||||
// заголовок Sec-WebSocket-Protocol: binary — его обязательно нужно
|
||||
// подтвердить в ответе, иначе клиент разорвёт рукопожатие;
|
||||
// бинарные frames в обе стороны, без обёрток.
|
||||
|
||||
import { connect } from "cloudflare:sockets";
|
||||
|
||||
// Только те адреса, которые запрашивает сам TGLock. Без этого списка любой,
|
||||
// кто узнает адрес воркера, получит через твой аккаунт произвольный
|
||||
// TCP-прокси.
|
||||
const ALLOWED_DESTINATIONS = new Set([
|
||||
"91.105.192.100",
|
||||
"149.154.167.51",
|
||||
"149.154.167.91",
|
||||
"149.154.167.220",
|
||||
"149.154.171.5",
|
||||
"149.154.175.50",
|
||||
"149.154.175.100",
|
||||
]);
|
||||
|
||||
const TELEGRAM_PORT = 443;
|
||||
|
||||
export default {
|
||||
async fetch(request, env) {
|
||||
const url = new URL(request.url);
|
||||
|
||||
if (url.pathname !== "/apiws") {
|
||||
return new Response("not found", { status: 404 });
|
||||
}
|
||||
if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
|
||||
return new Response("expected a websocket upgrade", { status: 426 });
|
||||
}
|
||||
// Необязательный общий секрет: задай переменную TGLOCK_TOKEN в настройках
|
||||
// воркера, и посторонние подключиться не смогут.
|
||||
if (env.TGLOCK_TOKEN && url.searchParams.get("token") !== env.TGLOCK_TOKEN) {
|
||||
return new Response("forbidden", { status: 403 });
|
||||
}
|
||||
|
||||
const destination = url.searchParams.get("dst");
|
||||
if (!destination || !ALLOWED_DESTINATIONS.has(destination)) {
|
||||
return new Response("destination not allowed", { status: 403 });
|
||||
}
|
||||
|
||||
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 = () => {
|
||||
if (closed) return;
|
||||
closed = true;
|
||||
writer.close().catch(() => {});
|
||||
try {
|
||||
server.close();
|
||||
} catch {
|
||||
// соединение уже закрыто
|
||||
}
|
||||
};
|
||||
|
||||
server.addEventListener("message", (event) => {
|
||||
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);
|
||||
|
||||
// Обратное направление: всё, что приходит от Telegram, уходит клиенту.
|
||||
(async () => {
|
||||
const reader = upstream.readable.getReader();
|
||||
try {
|
||||
for (;;) {
|
||||
const { value, done } = await reader.read();
|
||||
if (done) break;
|
||||
server.send(value);
|
||||
}
|
||||
} catch {
|
||||
// разрыв соединения — обычная ситуация, не ошибка
|
||||
}
|
||||
shutdown();
|
||||
})();
|
||||
|
||||
return new Response(null, {
|
||||
status: 101,
|
||||
webSocket: client,
|
||||
// Обязательно: клиент запрашивает подпротокол binary и без
|
||||
// подтверждения рвёт рукопожатие.
|
||||
headers: { "Sec-WebSocket-Protocol": "binary" },
|
||||
});
|
||||
},
|
||||
};
|
||||
-418
@@ -1,418 +0,0 @@
|
||||
# Решения задач по теории вероятностей
|
||||
## Формулы Бернулли, местная и интегральная теоремы Муавра–Лапласа, формула Пуассона
|
||||
|
||||
---
|
||||
|
||||
## Задача 3
|
||||
|
||||
**Условие:** В среднем каждое второе малое предприятие имеет нарушение финансовой дисциплины. Из **n = 1000** предприятий найти вероятность того, что нарушения имеют:
|
||||
|
||||
Дано: n = 1000, p = 1/2 = 0,5, q = 0,5
|
||||
npq = 1000 · 0,5 · 0,5 = 250, √(npq) = √250 ≈ 15,81
|
||||
|
||||
---
|
||||
|
||||
### а) Ровно 480 предприятий
|
||||
|
||||
Используем **местную теорему Муавра–Лапласа**:
|
||||
|
||||
$$P_n(k) \approx \frac{1}{\sqrt{npq}} \cdot \varphi(x), \quad x = \frac{k - np}{\sqrt{npq}}$$
|
||||
|
||||
$$x = \frac{480 - 500}{15{,}81} = \frac{-20}{15{,}81} \approx -1{,}26$$
|
||||
|
||||
φ(1,26) = 0,1826 (по таблице функции Гаусса)
|
||||
|
||||
$$P_{1000}(480) \approx \frac{0{,}1826}{15{,}81} \approx \mathbf{0{,}0116}$$
|
||||
|
||||
---
|
||||
|
||||
### б) Наивероятнейшее число предприятий
|
||||
|
||||
По формуле: **np − q ≤ k₀ ≤ np + p**
|
||||
|
||||
499,5 ≤ k₀ ≤ 500,5 → **k₀ = 500**
|
||||
|
||||
---
|
||||
|
||||
### в) Не менее 480 предприятий
|
||||
|
||||
Используем **интегральную теорему Муавра–Лапласа**:
|
||||
|
||||
$$P(k \geq 480) = 0{,}5 + \Phi\!\left(\frac{np - k_1}{\sqrt{npq}}\right)$$
|
||||
|
||||
$$= 0{,}5 + \Phi(1{,}26) = 0{,}5 + 0{,}3962 \approx \mathbf{0{,}8962}$$
|
||||
|
||||
---
|
||||
|
||||
### г) От 480 до 520 предприятий
|
||||
|
||||
$$x_1 = \frac{480 - 500}{15{,}81} \approx -1{,}26, \quad x_2 = \frac{520 - 500}{15{,}81} \approx 1{,}26$$
|
||||
|
||||
$$P(480 \leq k \leq 520) = \Phi(1{,}26) - \Phi(-1{,}26) = 2\Phi(1{,}26) = 2 \cdot 0{,}3962 \approx \mathbf{0{,}7924}$$
|
||||
|
||||
---
|
||||
|
||||
## Задача 4
|
||||
|
||||
**Условие:** Вероятность банкротства предприятия за время t равна 0,2. Из **n = 6** предприятий найти вероятность того, что **сохранятся**:
|
||||
|
||||
Дано: n = 6, p(сохранится) = 1 − 0,2 = **0,8**, q = 0,2
|
||||
|
||||
Используем **формулу Бернулли**: P_n(k) = C(n,k) · pᵏ · qⁿ⁻ᵏ
|
||||
|
||||
---
|
||||
|
||||
### а) Два предприятия (k = 2)
|
||||
|
||||
$$P_6(2) = C_6^2 \cdot (0{,}8)^2 \cdot (0{,}2)^4 = 15 \cdot 0{,}64 \cdot 0{,}0016 = \mathbf{0{,}0154}$$
|
||||
|
||||
---
|
||||
|
||||
### б) Более двух предприятий (k > 2)
|
||||
|
||||
$$P(k > 2) = 1 - P(k \leq 2) = 1 - [P(0) + P(1) + P(2)]$$
|
||||
|
||||
- P₆(0) = C(6,0) · (0,8)⁰ · (0,2)⁶ = 1 · 1 · 0,000064 = 0,000064
|
||||
- P₆(1) = C(6,1) · (0,8)¹ · (0,2)⁵ = 6 · 0,8 · 0,00032 = 0,001536
|
||||
- P₆(2) = 0,0154 (вычислено выше)
|
||||
|
||||
$$P(k > 2) = 1 - (0{,}000064 + 0{,}001536 + 0{,}0154) \approx 1 - 0{,}0170 = \mathbf{0{,}983}$$
|
||||
|
||||
---
|
||||
|
||||
## Задача 5
|
||||
|
||||
**Условие:** В банк отправлено **n = 4000** пакетов. Вероятность ошибки в комплектации **p = 0,0001**. Найти вероятность обнаружения:
|
||||
|
||||
λ = np = 4000 · 0,0001 = **0,4**
|
||||
|
||||
Используем **формулу Пуассона**: P(k) = (λᵏ / k!) · e⁻λ
|
||||
|
||||
e⁻⁰·⁴ ≈ 0,6703
|
||||
|
||||
---
|
||||
|
||||
### а) Три ошибочно укомплектованных пакета (k = 3)
|
||||
|
||||
$$P(3) = \frac{(0{,}4)^3}{3!} \cdot e^{-0{,}4} = \frac{0{,}064}{6} \cdot 0{,}6703 \approx \mathbf{0{,}00715}$$
|
||||
|
||||
---
|
||||
|
||||
### б) Не более трёх пакетов (k ≤ 3)
|
||||
|
||||
$$P(k \leq 3) = P(0) + P(1) + P(2) + P(3)$$
|
||||
|
||||
- P(0) = e⁻⁰·⁴ = 0,6703
|
||||
- P(1) = 0,4 · e⁻⁰·⁴ = 0,2681
|
||||
- P(2) = (0,4²/2) · e⁻⁰·⁴ = 0,0536
|
||||
- P(3) = 0,00715
|
||||
|
||||
$$P(k \leq 3) = 0{,}6703 + 0{,}2681 + 0{,}0536 + 0{,}00715 \approx \mathbf{0{,}9992}$$
|
||||
|
||||
---
|
||||
|
||||
---
|
||||
|
||||
## Домашняя работа
|
||||
|
||||
---
|
||||
|
||||
## Задача 1 (ДЗ)
|
||||
|
||||
**Условие:** Вероятность попадания в цель р = 0,7. Из **n = 80** выстрелов — найти вероятность различных исходов.
|
||||
|
||||
Дано: n = 80, p = 0,7, q = 0,3
|
||||
np = 56, npq = 16,8, √(npq) ≈ 4,10
|
||||
|
||||
---
|
||||
|
||||
### а) Ровно 75 попаданий
|
||||
|
||||
$$x = \frac{75 - 56}{4{,}10} \approx 4{,}63$$
|
||||
|
||||
φ(4,63) ≈ 0,00002 (крайне малое значение)
|
||||
|
||||
$$P_{80}(75) \approx \frac{0{,}00002}{4{,}10} \approx \mathbf{0{,}000005} \approx 0$$
|
||||
|
||||
---
|
||||
|
||||
### б) Не менее 75 попаданий
|
||||
|
||||
$$x_1 = \frac{75 - 56}{4{,}10} \approx 4{,}63$$
|
||||
|
||||
$$P(k \geq 75) = 0{,}5 - \Phi(4{,}63) \approx 0{,}5 - 0{,}5 \approx \mathbf{0}$$
|
||||
|
||||
---
|
||||
|
||||
### в) Менее 75 попаданий
|
||||
|
||||
$$P(k < 75) = 1 - P(k \geq 75) \approx \mathbf{1}$$
|
||||
|
||||
---
|
||||
|
||||
### г) Не более 75 попаданий
|
||||
|
||||
$$P(k \leq 75) = P(k < 75) + P(k = 75) \approx 1 + 0 \approx \mathbf{1}$$
|
||||
|
||||
---
|
||||
|
||||
### д) Более 75 попаданий
|
||||
|
||||
$$P(k > 75) \approx \mathbf{0}$$
|
||||
|
||||
---
|
||||
|
||||
### е) Все 80 выстрелов
|
||||
|
||||
$$P_{80}(80) = (0{,}7)^{80} = e^{80 \ln 0{,}7} = e^{-28{,}5} \approx \mathbf{4{,}4 \times 10^{-13}}$$
|
||||
|
||||
---
|
||||
|
||||
## Задача 2 (ДЗ)
|
||||
|
||||
**Условие:** Вероятность выпуска сверла с браком p = 0,02. Сверла укладываются по 100 штук. Найти наименьшее количество добавочных сверл, чтобы с вероятностью **не менее 0,9** в коробке было **не менее 100 исправных**.
|
||||
|
||||
Пусть в коробке **n** сверл, p(исправное) = 0,98. Нужно: P(X ≥ 100) ≥ 0,9
|
||||
|
||||
$$P(X \geq 100) = 0{,}5 + \Phi\!\left(\frac{np - 100}{\sqrt{np \cdot 0{,}02}}\right) \geq 0{,}9$$
|
||||
|
||||
$$\Rightarrow \frac{0{,}98n - 100}{0{,}14\sqrt{n}} \geq 1{,}28$$
|
||||
|
||||
Подстановка t = √n: 0,98t² − 0,1792t − 100 ≥ 0
|
||||
|
||||
$$t = \frac{0{,}1792 + \sqrt{0{,}1792^2 + 4 \cdot 0{,}98 \cdot 100}}{2 \cdot 0{,}98} = \frac{0{,}179 + 19{,}80}{1{,}96} \approx 10{,}19$$
|
||||
|
||||
$$n \geq (10{,}19)^2 \approx 103{,}9 \Rightarrow n = 104$$
|
||||
|
||||
**Ответ:** нужно добавить **m = 104 − 100 = 4 сверла**
|
||||
|
||||
---
|
||||
|
||||
## Задача 3 (ДЗ)
|
||||
|
||||
**Условие:** Сколько изюминок в среднем должна содержать булочка, чтобы вероятность хотя бы одной изюминки была **не менее 0,99**?
|
||||
|
||||
Используем формулу Пуассона: P(X ≥ 1) = 1 − P(X = 0) = 1 − e⁻λ ≥ 0,99
|
||||
|
||||
$$e^{-\lambda} \leq 0{,}01 \Rightarrow \lambda \geq -\ln(0{,}01) = \ln 100 \approx 4{,}61$$
|
||||
|
||||
**Ответ:** в среднем в булочке должно быть **не менее 5 изюминок** (λ ≥ 4,61)
|
||||
|
||||
---
|
||||
|
||||
---
|
||||
|
||||
## Задача (Картофель)
|
||||
|
||||
**Условие:** В складе 20% клубней с пятнами. Отобрано **n = 9** клубней. p(без пятен) = 0,8, q = 0,2.
|
||||
|
||||
---
|
||||
|
||||
### а) Наивероятнейшее число клубней без пятен
|
||||
|
||||
np − q ≤ k₀ ≤ np + p
|
||||
9·0,8 − 0,2 ≤ k₀ ≤ 9·0,8 + 0,8
|
||||
**7,0 ≤ k₀ ≤ 8,0**
|
||||
|
||||
Так как оба конца — целые числа, оба значения k₀ = 7 и k₀ = 8 являются наивероятнейшими (с одинаковой вероятностью).
|
||||
|
||||
---
|
||||
|
||||
### б) Вероятность наивероятнейшего числа
|
||||
|
||||
$$P_9(7) = C_9^7 \cdot (0{,}8)^7 \cdot (0{,}2)^2 = 36 \cdot 0{,}2097 \cdot 0{,}04 \approx \mathbf{0{,}302}$$
|
||||
|
||||
$$P_9(8) = C_9^8 \cdot (0{,}8)^8 \cdot (0{,}2)^1 = 9 \cdot 0{,}1678 \cdot 0{,}2 \approx \mathbf{0{,}302}$$
|
||||
|
||||
P(7) = P(8) ≈ **0,302** — подтверждает, что оба значения равновероятны
|
||||
|
||||
---
|
||||
|
||||
## Задача (Событие А, k₀ = 20)
|
||||
|
||||
**Условие:** Вероятность события А в каждом испытании p = 0,7. Сколько испытаний нужно провести, чтобы **наивероятнейшее число** равнялось **20**?
|
||||
|
||||
np − q ≤ k₀ ≤ np + p, то есть при k₀ = 20:
|
||||
|
||||
$$0{,}7n - 0{,}3 \leq 20 \leq 0{,}7n + 0{,}7$$
|
||||
|
||||
Из левого неравенства: 0,7n ≤ 20,3 → **n ≤ 29**
|
||||
|
||||
Из правого неравенства: 0,7n ≥ 19,3 → **n ≥ 27,57 → n ≥ 28**
|
||||
|
||||
Проверка:
|
||||
- n = 28: np−q = 19,3, np+p = 20,3 → единственное целое k₀ = **20** ✓
|
||||
- n = 29: np−q = 20,0, np+p = 21,0 → k₀ = 20 или 21 (два наивероятнейших)
|
||||
|
||||
**Ответ: n = 28** (или n = 29, если допустимо два наивероятнейших значения)
|
||||
|
||||
---
|
||||
|
||||
---
|
||||
|
||||
## Задача 1 (Лотерея)
|
||||
|
||||
**Условие:** Вероятность выигрыша по одному билету p = 1/7. Имея **n = 7** билетов, найти вероятность выигрыша:
|
||||
|
||||
Используем **формулу Бернулли**
|
||||
|
||||
---
|
||||
|
||||
### а) По двум билетам (k = 2)
|
||||
|
||||
$$P_7(2) = C_7^2 \cdot \left(\frac{1}{7}\right)^2 \cdot \left(\frac{6}{7}\right)^5 = 21 \cdot \frac{1}{49} \cdot \frac{7776}{16807} = \frac{163296}{823543} \approx \mathbf{0{,}198}$$
|
||||
|
||||
---
|
||||
|
||||
### б) По трём билетам (k = 3)
|
||||
|
||||
$$P_7(3) = C_7^3 \cdot \left(\frac{1}{7}\right)^3 \cdot \left(\frac{6}{7}\right)^4 = 35 \cdot \frac{1}{343} \cdot \frac{1296}{2401} = \frac{45360}{823543} \approx \mathbf{0{,}055}$$
|
||||
|
||||
---
|
||||
|
||||
## Задача 2 (Мята, гербициды)
|
||||
|
||||
**Условие:** Повреждены гербицидами 15% растений мяты. Отобрано **n = 20** растений. p = 0,15, q = 0,85.
|
||||
|
||||
np − q ≤ k₀ ≤ np + p
|
||||
3 − 0,85 ≤ k₀ ≤ 3 + 0,15
|
||||
2,15 ≤ k₀ ≤ 3,15
|
||||
|
||||
**k₀ = 3** — наивероятнейшее число повреждённых растений
|
||||
|
||||
---
|
||||
|
||||
## Задача 3 (Сбербанк)
|
||||
|
||||
**Условие:** Два филиала. Филиал 1: n₁ = 120, p₁ = 0,94. Филиал 2: n₂ = 140, p₂ = 0,8. Найти наивероятнейшее число клиентов, снявших деньги.
|
||||
|
||||
**Филиал 1:** np₁ = 112,8; np₁ − q₁ = 112,74; np₁ + p₁ = 113,74 → **k₀₁ = 113**
|
||||
|
||||
**Филиал 2:** np₂ = 112,0; np₂ − q₂ = 111,8; np₂ + p₂ = 112,8 → **k₀₂ = 112**
|
||||
|
||||
**Ответ:** Первый филиал обслуживает больше клиентов, снявших деньги: **113 > 112**
|
||||
|
||||
---
|
||||
|
||||
---
|
||||
|
||||
## Задача (Событие А, 400 испытаний)
|
||||
|
||||
**Условие:** Найти вероятность того, что событие А наступит **ровно 80 раз** в 400 испытаниях, если p = 0,2.
|
||||
|
||||
Дано: n = 400, k = 80, p = 0,2, q = 0,8
|
||||
np = 80, npq = 64, √(npq) = 8
|
||||
|
||||
$$x = \frac{k - np}{\sqrt{npq}} = \frac{80 - 80}{8} = 0$$
|
||||
|
||||
$$\varphi(0) = \frac{1}{\sqrt{2\pi}} \approx 0{,}3989$$
|
||||
|
||||
$$P_{400}(80) \approx \frac{\varphi(0)}{\sqrt{npq}} = \frac{0{,}3989}{8} \approx \mathbf{0{,}0499}$$
|
||||
|
||||
---
|
||||
|
||||
## Задача (Стрелок)
|
||||
|
||||
**Условие:** Вероятность поражения мишени p = 0,75. При **n = 10** выстрелах найти вероятность **ровно 8 попаданий**.
|
||||
|
||||
$$P_{10}(8) = C_{10}^8 \cdot (0{,}75)^8 \cdot (0{,}25)^2$$
|
||||
|
||||
$$= 45 \cdot \frac{6561}{65536} \cdot \frac{1}{16} = \frac{295245}{1048576} \approx \mathbf{0{,}2816}$$
|
||||
|
||||
---
|
||||
|
||||
---
|
||||
|
||||
## Задача (Кинескопы — Интегральная теорема Лапласа)
|
||||
|
||||
**Условие:** 12% кинескопов не проработают гарантийный срок. Из **n = 50** наугад выбранных — найти вероятность того, что проработают гарантийный срок:
|
||||
|
||||
Дано: n = 50, p(проработает) = 1 − 0,12 = **0,88**, q = 0,12
|
||||
np = 44, npq = 50 · 0,88 · 0,12 = 5,28, √(npq) ≈ 2,298
|
||||
|
||||
---
|
||||
|
||||
### а) Ровно 47 кинескопов
|
||||
|
||||
Местная теорема:
|
||||
|
||||
$$x = \frac{47 - 44}{2{,}298} \approx 1{,}305, \quad \varphi(1{,}305) \approx 0{,}1714$$
|
||||
|
||||
$$P_{50}(47) \approx \frac{0{,}1714}{2{,}298} \approx \mathbf{0{,}0745}$$
|
||||
|
||||
---
|
||||
|
||||
### б) Не менее 47 кинескопов
|
||||
|
||||
$$x_1 = \frac{47 - 44}{2{,}298} \approx 1{,}305$$
|
||||
|
||||
$$P(k \geq 47) \approx 0{,}5 - \Phi(1{,}305) = 0{,}5 - 0{,}4040 \approx \mathbf{0{,}0960}$$
|
||||
|
||||
---
|
||||
|
||||
### в) Менее 47 кинескопов
|
||||
|
||||
$$P(k < 47) = 1 - P(k \geq 47) \approx 1 - 0{,}0960 = \mathbf{0{,}9040}$$
|
||||
|
||||
---
|
||||
|
||||
### г) Более 47 кинескопов
|
||||
|
||||
$$x = \frac{48 - 44}{2{,}298} \approx 1{,}740$$
|
||||
|
||||
$$P(k > 47) = P(k \geq 48) \approx 0{,}5 - \Phi(1{,}74) = 0{,}5 - 0{,}4591 \approx \mathbf{0{,}0409}$$
|
||||
|
||||
---
|
||||
|
||||
### д) Не более 47 кинескопов
|
||||
|
||||
$$P(k \leq 47) = 1 - P(k > 47) \approx 1 - 0{,}0409 = \mathbf{0{,}9591}$$
|
||||
|
||||
---
|
||||
|
||||
### е) Все 50 кинескопов
|
||||
|
||||
$$P_{50}(50) = (0{,}88)^{50} \approx \mathbf{0{,}00167}$$
|
||||
|
||||
(Для проверки по местной теореме: x = (50−44)/2,298 ≈ 2,61; φ(2,61) ≈ 0,0136; P ≈ 0,006 — приближение менее точно из-за удалённости от центра)
|
||||
|
||||
---
|
||||
|
||||
---
|
||||
|
||||
## Домашнее задание (Интегральная теорема Лапласа)
|
||||
|
||||
---
|
||||
|
||||
## Задача 1 (ДЗ — Новорождённые)
|
||||
|
||||
**Условие:** Среди **n = 1000** новорождённых. Вероятность рождения мальчика p = 0,51. Найти вероятность того, что мальчиков будет:
|
||||
|
||||
np = 510, npq = 1000 · 0,51 · 0,49 = 249,9, √(npq) ≈ 15,81
|
||||
|
||||
---
|
||||
|
||||
### а) Не менее половины (m ≥ 500)
|
||||
|
||||
$$x_1 = \frac{500 - 510}{15{,}81} \approx -0{,}63, \quad x_2 \to +\infty$$
|
||||
|
||||
$$P_{1000}(500 \leq m \leq 1000) \approx \Phi(+\infty) - \Phi(-0{,}63) = 0{,}5 - (-0{,}2357) = \mathbf{0{,}7357}$$
|
||||
|
||||
---
|
||||
|
||||
### б) Менее половины (m < 500, то есть m ≤ 499)
|
||||
|
||||
$$P_{1000}(0 \leq m \leq 499) = 1 - 0{,}7357 = \mathbf{0{,}2643}$$
|
||||
|
||||
---
|
||||
|
||||
## Задача 2 (ДЗ — Картофель при уборке)
|
||||
|
||||
**Условие:** При уборке повреждается в среднем 10% клубней. Из **n = 200** клубней найти вероятность того, что повреждено от 15 до 50 клубней.
|
||||
|
||||
Дано: n = 200, p = 0,10, q = 0,90
|
||||
np = 20, npq = 18, √(npq) ≈ 4,243
|
||||
|
||||
$$x_1 = \frac{15 - 20}{4{,}243} \approx -1{,}18, \quad x_2 = \frac{50 - 20}{4{,}243} \approx 7{,}07$$
|
||||
|
||||
$$P_{200}(15 \leq m \leq 50) \approx \Phi(7{,}07) - \Phi(-1{,}18) \approx 0{,}5 - (-0{,}3810) = 0{,}5 + 0{,}3810 \approx \mathbf{0{,}881}$$
|
||||
Reference in New Issue
Block a user