astelm/tglock
1
0
Fork 0
mirror of https://github.com/by-sonic/tglock.git synced 2026-08-02 08:35:51 +03:00
Code Issues Packages Projects Releases Wiki Activity

v1.0.0: Clean rewrite — cross-platform, dark UI, stable WS tunnel

Browse Source 
Made-with: Cursor:
This commit is contained in:
by-sonic
2026-04-08 14:56:50 +03:00
parent c40ad94e11
commit 09b7a03a0a
13 changed files with 594 additions and 2733 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bypass.rs
-201
View File
@@ -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())
}
src/main.rs
+249 -274
View File
@@ -1,356 +1,331 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
mod bypass;
mod network;
mod ws_proxy;
mod proxy;
use std::sync::atomic::Ordering;
use std::sync::{Arc, Mutex};
use std::time::Instant;
use eframe::egui;
const PROXY_PORT: u16 = 1080;
// -- Colors (GitHub Dark inspired) ------------------------------------------
const BG: egui::Color32 = egui::Color32::from_rgb(13, 17, 23);
const SURFACE: egui::Color32 = egui::Color32::from_rgb(22, 27, 34);
const BORDER: egui::Color32 = egui::Color32::from_rgb(48, 54, 61);
const ACCENT: egui::Color32 = egui::Color32::from_rgb(88, 166, 255);
const GREEN: egui::Color32 = egui::Color32::from_rgb(63, 185, 80);
const RED: egui::Color32 = egui::Color32::from_rgb(248, 81, 73);
const TEXT: egui::Color32 = egui::Color32::from_rgb(230, 237, 243);
const TEXT2: egui::Color32 = egui::Color32::from_rgb(139, 148, 158);
const AD_BG: egui::Color32 = egui::Color32::from_rgb(17, 21, 28);
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()
};
eframe::run_native(
"TG Unblock",
options,
"TGLock",
eframe::NativeOptions {
viewport: egui::ViewportBuilder::default()
.with_inner_size([520.0, 620.0])
.with_min_inner_size([420.0, 500.0])
.with_title("TGLock"),
..Default::default()
},
Box::new(|cc| {
setup_fonts(&cc.egui_ctx);
apply_theme(&cc.egui_ctx);
Ok(Box::new(App::new()))
}),
)
}
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);
fn apply_theme(ctx: &egui::Context) {
let mut v = egui::Visuals::dark();
v.panel_fill = BG;
v.window_fill = SURFACE;
v.extreme_bg_color = BG;
v.faint_bg_color = SURFACE;
v.override_text_color = Some(TEXT);
v.widgets.noninteractive.bg_fill = SURFACE;
v.widgets.noninteractive.fg_stroke = egui::Stroke::new(1.0, TEXT2);
v.widgets.noninteractive.bg_stroke = egui::Stroke::new(1.0, BORDER);
v.widgets.inactive.bg_fill = egui::Color32::from_rgb(33, 38, 45);
v.widgets.inactive.fg_stroke = egui::Stroke::new(1.0, TEXT);
v.widgets.inactive.bg_stroke = egui::Stroke::new(1.0, BORDER);
v.widgets.hovered.bg_fill = egui::Color32::from_rgb(48, 54, 61);
v.widgets.hovered.fg_stroke = egui::Stroke::new(1.0, TEXT);
v.widgets.active.bg_fill = ACCENT;
v.widgets.active.fg_stroke = egui::Stroke::new(1.0, BG);
ctx.set_visuals(v);
}
// -- Log --------------------------------------------------------------------
#[derive(Clone)]
struct LogEntry {
text: String,
is_error: bool,
struct LogLine {
ts: String,
msg: String,
err: bool,
}
fn now_ts() -> String {
let s = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
format!("{:02}:{:02}:{:02}", (s / 3600) % 24, (s / 60) % 60, s % 60)
}
fn log(log: &Arc<Mutex<Vec<LogLine>>>, msg: &str, err: bool) {
log.lock().unwrap().push(LogLine {
ts: now_ts(),
msg: msg.into(),
err,
});
}
// -- App --------------------------------------------------------------------
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>>,
stats: Arc<proxy::Stats>,
log: Arc<Mutex<Vec<LogLine>>>,
started_at: Option<Instant>,
}
impl App {
fn new() -> Self {
let is_admin = bypass::check_admin();
let app = Self {
Self {
stats: proxy::Stats::new(),
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)),
};
log_msg(&app.log, "Запущено", false);
if !is_admin {
log_msg(&app.log, "Нет прав администратора — DNS менять не получится", true);
started_at: None,
}
{
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
}
fn proxy_running(&self) -> bool {
self.proxy_stats.running.load(Ordering::SeqCst)
fn running(&self) -> bool {
self.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;
fn start(&mut self) {
if self.running() { return; }
self.started_at = Some(Instant::now());
let stats = self.stats.clone();
let lg = self.log.clone();
log(&lg, "Запускаю прокси...", false);
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);
let r = rt.block_on(proxy::run(stats));
if let Err(e) = r {
log(&lg, &format!("Ошибка: {}", e), true);
}
});
std::thread::sleep(std::time::Duration::from_millis(300));
if self.proxy_running() {
log_msg(&self.log, "Прокси запущен! Настройте Telegram.", false);
std::thread::sleep(std::time::Duration::from_millis(250));
if self.running() {
log(&self.log, &format!("SOCKS5 на 127.0.0.1:{}", proxy::PORT), false);
}
}
fn stop_proxy(&self) {
self.proxy_stats.running.store(false, Ordering::SeqCst);
log_msg(&self.log, "Прокси остановлен", false);
fn stop(&mut self) {
self.stats.running.store(false, Ordering::SeqCst);
self.started_at = None;
log(&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 uptime_str(&self) -> String {
match self.started_at {
Some(t) => {
let s = t.elapsed().as_secs();
format!("{:02}:{:02}:{:02}", s / 3600, (s / 60) % 60, s % 60)
}
None => "--:--:--".into(),
}
}
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);
}
}
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,
});
}
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));
ctx.request_repaint_after(std::time::Duration::from_millis(300));
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 on = self.running();
let active = self.stats.active.load(Ordering::Relaxed);
let total = self.stats.total.load(Ordering::Relaxed);
let ws = self.stats.ws.load(Ordering::Relaxed);
let dc = self.stats.last_dc.load(Ordering::Relaxed);
// --- 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("Прокси не запущен");
}
});
// === Ad bar (top) ===
egui::TopBottomPanel::top("ad").show(ctx, |ui| {
egui::Frame::new()
.fill(AD_BG)
.inner_margin(egui::Margin::symmetric(12, 6))
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.colored_label(ACCENT, egui::RichText::new("by sonic VPN").size(12.0).strong());
ui.colored_label(TEXT2, egui::RichText::new("Обход для всех приложений").size(11.0));
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
if ui.add(egui::Button::new(
egui::RichText::new("@bysonicvpn_bot").size(11.0).strong().color(ACCENT)
).frame(false)).clicked() {
let _ = open::that("https://t.me/bysonicvpn_bot");
}
});
});
});
});
// --- Log panel ---
// === Log (bottom) ===
egui::TopBottomPanel::bottom("log")
.min_height(130.0)
.min_height(120.0)
.show(ctx, |ui| {
ui.label(egui::RichText::new("Лог").strong());
ui.add_space(4.0);
ui.colored_label(TEXT2, egui::RichText::new("LOG").size(11.0));
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));
for e in self.log.lock().unwrap().iter() {
let c = if e.err { RED } else { TEXT2 };
ui.colored_label(c, egui::RichText::new(
format!("{} {}", e.ts, e.msg)
).size(11.5).monospace());
}
});
});
// --- 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");
}
});
// === Stats bar ===
egui::TopBottomPanel::bottom("stats").show(ctx, |ui| {
egui::Frame::new()
.fill(SURFACE)
.inner_margin(egui::Margin::symmetric(16, 8))
.show(ui, |ui| {
ui.horizontal(|ui| {
stat(ui, "Соединения", &active.to_string());
ui.add_space(20.0);
stat(ui, "WS-туннели", &ws.to_string());
ui.add_space(20.0);
stat(ui, "DC", &if dc > 0 { dc.to_string() } else { "—".into() });
ui.add_space(20.0);
stat(ui, "Всего", &total.to_string());
ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
stat(ui, "Аптайм", &self.uptime_str());
});
});
});
ui.add_space(12.0);
});
});
// === Main ===
egui::CentralPanel::default().show(ctx, |ui| {
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);
ui.add_space(30.0);
// Title
ui.colored_label(TEXT, egui::RichText::new("TGLock").size(32.0).strong());
ui.add_space(4.0);
ui.colored_label(TEXT2, egui::RichText::new("WebSocket-туннель для Telegram").size(13.0));
ui.add_space(24.0);
// Status indicator
let (dot_color, status_text) = if on {
(GREEN, "Подключено")
} else {
(egui::Color32::from_rgb(80, 80, 80), "Отключено")
};
ui.horizontal(|ui| {
let center = ui.available_width() / 2.0 - 50.0;
ui.add_space(center);
let (r, _) = ui.allocate_exact_size(egui::vec2(10.0, 10.0), egui::Sense::hover());
ui.painter().circle_filled(r.center(), 5.0, dot_color);
ui.colored_label(
if on { GREEN } else { TEXT2 },
egui::RichText::new(status_text).size(14.0).strong(),
);
});
ui.add_space(20.0);
// Big button
if !on {
let btn = ui.add_sized(
[340.0, 55.0],
egui::Button::new(egui::RichText::new("Запустить обход").size(20.0).strong()),
[260.0, 52.0],
egui::Button::new(
egui::RichText::new("ПОДКЛЮЧИТЬ").size(18.0).strong().color(BG)
).fill(ACCENT).corner_radius(8.0),
);
if btn.clicked() {
self.start_proxy();
self.start();
}
} else {
ui.colored_label(
egui::Color32::from_rgb(80, 220, 120),
egui::RichText::new("Обход работает").size(22.0).strong(),
let btn = ui.add_sized(
[260.0, 52.0],
egui::Button::new(
egui::RichText::new("ОТКЛЮЧИТЬ").size(18.0).strong().color(TEXT)
).fill(egui::Color32::from_rgb(40, 45, 52)).corner_radius(8.0),
);
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();
if btn.clicked() {
self.stop();
}
}
ui.add_space(24.0);
// Setup section
egui::Frame::new()
.fill(SURFACE)
.corner_radius(8.0)
.inner_margin(16.0)
.show(ui, |ui| {
ui.set_width(360.0);
ui.colored_label(TEXT, egui::RichText::new("Настройка Telegram").size(14.0).strong());
ui.add_space(6.0);
if on {
if ui.add(egui::Button::new(
egui::RichText::new("Настроить автоматически").size(13.0).color(ACCENT)
).frame(false)).clicked() {
let _ = open::that(format!("tg://socks?server=127.0.0.1&port={}", proxy::PORT));
log(&self.log, "Открываю настройку Telegram...", false);
}
ui.add_space(4.0);
}
ui.colored_label(TEXT2, egui::RichText::new("Настройки → Продвинутые → Тип соединения → SOCKS5").size(11.5));
ui.add_space(4.0);
egui::Grid::new("cfg").num_columns(2).spacing([12.0, 3.0]).show(ui, |ui| {
ui.colored_label(TEXT2, "Сервер");
ui.monospace("127.0.0.1");
ui.end_row();
ui.colored_label(TEXT2, "Порт");
ui.monospace(format!("{}", proxy::PORT));
ui.end_row();
});
});
ui.add_space(16.0);
// How it works (compact)
ui.colored_label(TEXT2, egui::RichText::new(
"Трафик Telegram → SOCKS5 → WSS → web.telegram.org → DC"
).size(11.0));
ui.colored_label(TEXT2, egui::RichText::new(
"Провайдер видит обычный HTTPS. Остальной трафик не затрагивается."
).size(11.0));
});
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 stat(ui: &mut egui::Ui, label: &str, value: &str) {
ui.vertical(|ui| {
ui.colored_label(TEXT2, egui::RichText::new(label).size(10.0));
ui.colored_label(TEXT, egui::RichText::new(value).size(13.0).strong().monospace());
});
}
src/network.rs
-176
View File
@@ -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)
}
src/proxy.rs
+232
View File
@@ -0,0 +1,232 @@
use std::net::Ipv4Addr;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU8, Ordering};
use std::time::Duration;
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio_tungstenite::tungstenite;
use tungstenite::client::IntoClientRequest;
pub const PORT: u16 = 1080;
pub struct Stats {
pub running: AtomicBool,
pub active: AtomicU32,
pub total: AtomicU32,
pub ws: AtomicU32,
pub last_dc: AtomicU8,
}
impl Stats {
pub fn new() -> Arc<Self> {
Arc::new(Self {
running: AtomicBool::new(false),
active: AtomicU32::new(0),
total: AtomicU32::new(0),
ws: AtomicU32::new(0),
last_dc: AtomicU8::new(0),
})
}
}
pub async fn run(stats: Arc<Stats>) -> Result<(), String> {
let addr = format!("127.0.0.1:{}", PORT);
let listener = TcpListener::bind(&addr)
.await
.map_err(|e| format!("Port {} busy: {}", PORT, e))?;
stats.running.store(true, Ordering::SeqCst);
loop {
if !stats.running.load(Ordering::SeqCst) {
break;
}
tokio::select! {
Ok((stream, _)) = listener.accept() => {
let s = stats.clone();
s.active.fetch_add(1, Ordering::Relaxed);
s.total.fetch_add(1, Ordering::Relaxed);
tokio::spawn(async move {
let _ = handle(stream, &s).await;
s.active.fetch_sub(1, Ordering::Relaxed);
});
}
_ = tokio::time::sleep(Duration::from_millis(150)) => {}
}
}
stats.running.store(false, Ordering::SeqCst);
Ok(())
}
// -- SOCKS5 -----------------------------------------------------------------
async fn handle(
mut s: TcpStream,
stats: &Stats,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
s.set_nodelay(true)?;
let mut buf = [0u8; 258];
let n = s.read(&mut buf).await?;
if n < 2 || buf[0] != 0x05 {
return Err("not socks5".into());
}
s.write_all(&[0x05, 0x00]).await?;
let n = s.read(&mut buf).await?;
if n < 7 || buf[0] != 0x05 || buf[1] != 0x01 {
s.write_all(&[0x05, 0x07, 0x00, 0x01, 0, 0, 0, 0, 0, 0]).await?;
return Err("bad connect".into());
}
let (addr, port) = parse_addr(&buf[3..n])?;
let tg = addr.parse::<Ipv4Addr>().ok().and_then(dc_from_ip).is_some();
// success reply
s.write_all(&[0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x04, 0x38]).await?;
if tg {
// Read 64-byte obfuscated2 init → extract real DC
let mut init = [0u8; 64];
s.read_exact(&mut init).await?;
let dc = dc_from_init(&init).unwrap_or_else(|| {
addr.parse::<Ipv4Addr>().ok().and_then(dc_from_ip).unwrap_or(2)
});
stats.last_dc.store(dc, Ordering::Relaxed);
stats.ws.fetch_add(1, Ordering::Relaxed);
let r = ws_tunnel(s, dc, &init).await;
stats.ws.fetch_sub(1, Ordering::Relaxed);
r?;
} else {
let remote = TcpStream::connect(format!("{}:{}", addr, port)).await?;
let _ = remote.set_nodelay(true);
tcp_relay(s, remote).await;
}
Ok(())
}
fn parse_addr(d: &[u8]) -> Result<(String, u16), Box<dyn std::error::Error + Send + Sync>> {
match d[0] {
0x01 if d.len() >= 7 => {
Ok((format!("{}.{}.{}.{}", d[1], d[2], d[3], d[4]),
u16::from_be_bytes([d[5], d[6]])))
}
0x03 => {
let l = d[1] as usize;
if d.len() < 2 + l + 2 { return Err("short".into()); }
Ok((std::str::from_utf8(&d[2..2 + l])?.into(),
u16::from_be_bytes([d[2 + l], d[3 + l]])))
}
0x04 if d.len() >= 19 => {
let mut seg = [0u16; 8];
for i in 0..8 { seg[i] = u16::from_be_bytes([d[1 + i * 2], d[2 + i * 2]]); }
let ip = std::net::Ipv6Addr::new(seg[0],seg[1],seg[2],seg[3],seg[4],seg[5],seg[6],seg[7]);
Ok((ip.to_string(), u16::from_be_bytes([d[17], d[18]])))
}
_ => Err("bad addr".into()),
}
}
// -- DC detection -----------------------------------------------------------
fn dc_from_init(init: &[u8; 64]) -> Option<u8> {
use aes::Aes256;
use cipher::{KeyIvInit, StreamCipher};
type Ctr = ctr::Ctr128BE<Aes256>;
let mut dec = *init;
let mut c = Ctr::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)
}
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 ws_url(dc: u8) -> String {
format!("wss://kws{}.web.telegram.org/apiws", dc)
}
// -- WebSocket tunnel -------------------------------------------------------
async fn ws_tunnel(
tcp: TcpStream,
dc: u8,
init: &[u8; 64],
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use futures_util::{SinkExt, StreamExt};
let mut req = ws_url(dc).as_str().into_client_request()?;
req.headers_mut().insert("Sec-WebSocket-Protocol", "binary".parse()?);
let tls = native_tls::TlsConnector::new().map_err(|e| format!("tls: {}", e))?;
let connector = tokio_tungstenite::Connector::NativeTls(tls);
let (mut ws, _) = tokio::time::timeout(
Duration::from_secs(10),
tokio_tungstenite::connect_async_tls_with_config(req, None, false, Some(connector)),
)
.await
.map_err(|_| "WS connect timeout")?
.map_err(|e| format!("WS: {}", e))?;
let (mut tcp_r, mut tcp_w) = tokio::io::split(tcp);
// Send buffered init as first frame
ws.send(tungstenite::Message::Binary(init.to_vec())).await?;
let mut buf = vec![0u8; 65536];
loop {
tokio::select! {
biased;
msg = ws.next() => match msg {
Some(Ok(tungstenite::Message::Binary(data))) => {
tcp_w.write_all(data.as_ref()).await?;
tcp_w.flush().await?;
}
Some(Ok(tungstenite::Message::Ping(p))) => {
let _ = ws.send(tungstenite::Message::Pong(p)).await;
}
Some(Ok(tungstenite::Message::Close(_))) | None => break,
Some(Err(_)) => break,
_ => {}
},
n = tcp_r.read(&mut buf) => match n {
Ok(0) | Err(_) => break,
Ok(n) => {
ws.send(tungstenite::Message::Binary(buf[..n].to_vec())).await?;
}
},
}
}
let _ = ws.close(None).await;
Ok(())
}
async fn tcp_relay(a: TcpStream, b: TcpStream) {
let (mut ar, mut aw) = tokio::io::split(a);
let (mut br, mut bw) = tokio::io::split(b);
tokio::select! {
_ = tokio::io::copy(&mut ar, &mut bw) => {}
_ = tokio::io::copy(&mut br, &mut aw) => {}
}
}
src/ws_proxy.rs
-306
View File
@@ -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()?;
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 (mut ws, _resp) = tokio_tungstenite::connect_async_tls_with_config(
request, None, false, Some(connector),
)
.await?;
let (mut tcp_rx, mut tcp_tx) = tokio::io::split(tcp_stream);
// Send the buffered 64-byte init as the first WebSocket message
ws.send(tungstenite::Message::Binary(init.to_vec())).await?;
// Single loop: handles TCP→WS, WS→TCP, and Ping/Pong in one place.
// This ensures Pong replies are sent immediately so the server
// doesn't kill the connection after a timeout.
let mut buf = vec![0u8; 32768];
loop {
tokio::select! {
biased;
ws_msg = ws.next() => {
match ws_msg {
Some(Ok(tungstenite::Message::Binary(data))) => {
if tcp_tx.write_all(data.as_ref()).await.is_err() {
break;
}
}
Some(Ok(tungstenite::Message::Ping(payload))) => {
let _ = ws.send(tungstenite::Message::Pong(payload)).await;
}
Some(Ok(tungstenite::Message::Close(_))) | None => break,
Some(Err(_)) => break,
_ => {}
}
}
n = tcp_rx.read(&mut buf) => {
match n {
Ok(0) | Err(_) => break,
Ok(n) => {
let msg = tungstenite::Message::Binary(buf[..n].to_vec());
if ws.send(msg).await.is_err() {
break;
}
}
}
}
}
}
let _ = ws.close(None).await;
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) => {}
}
}