1.0.0

Tschuss Status Quo - Hallo, Zukunft!

src/proxy/client.rs

@@ -0,0 +1,378 @@
+//! Client Handler
+
+use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::net::TcpStream;
+use tokio::io::{AsyncRead, AsyncWrite, AsyncReadExt, AsyncWriteExt};
+use tokio::time::timeout;
+use tracing::{debug, info, warn, error, trace};
+
+use crate::config::ProxyConfig;
+use crate::error::{ProxyError, Result, HandshakeResult};
+use crate::protocol::constants::*;
+use crate::protocol::tls;
+use crate::stats::{Stats, ReplayChecker};
+use crate::transport::{ConnectionPool, configure_client_socket};
+use crate::stream::{CryptoReader, CryptoWriter, FakeTlsReader, FakeTlsWriter};
+use crate::crypto::AesCtr;
+
+use super::handshake::{
+    handle_tls_handshake, handle_mtproto_handshake, 
+    HandshakeSuccess, generate_tg_nonce, encrypt_tg_nonce,
+};
+use super::relay::relay_bidirectional;
+use super::masking::handle_bad_client;
+
+/// Client connection handler
+pub struct ClientHandler {
+    config: Arc<ProxyConfig>,
+    stats: Arc<Stats>,
+    replay_checker: Arc<ReplayChecker>,
+    pool: Arc<ConnectionPool>,
+}
+
+impl ClientHandler {
+    /// Create new client handler
+    pub fn new(
+        config: Arc<ProxyConfig>,
+        stats: Arc<Stats>,
+        replay_checker: Arc<ReplayChecker>,
+        pool: Arc<ConnectionPool>,
+    ) -> Self {
+        Self {
+            config,
+            stats,
+            replay_checker,
+            pool,
+        }
+    }
+    
+    /// Handle a client connection
+    pub async fn handle(&self, stream: TcpStream, peer: SocketAddr) {
+        self.stats.increment_connects_all();
+        
+        debug!(peer = %peer, "New connection");
+        
+        // Configure socket
+        if let Err(e) = configure_client_socket(
+            &stream,
+            self.config.client_keepalive,
+            self.config.client_ack_timeout,
+        ) {
+            debug!(peer = %peer, error = %e, "Failed to configure client socket");
+        }
+        
+        // Perform handshake with timeout
+        let handshake_timeout = Duration::from_secs(self.config.client_handshake_timeout);
+        
+        let result = timeout(
+            handshake_timeout,
+            self.do_handshake(stream, peer)
+        ).await;
+        
+        match result {
+            Ok(Ok(())) => {
+                debug!(peer = %peer, "Connection handled successfully");
+            }
+            Ok(Err(e)) => {
+                debug!(peer = %peer, error = %e, "Handshake failed");
+            }
+            Err(_) => {
+                self.stats.increment_handshake_timeouts();
+                debug!(peer = %peer, "Handshake timeout");
+            }
+        }
+    }
+    
+    /// Perform handshake and relay
+    async fn do_handshake(&self, mut stream: TcpStream, peer: SocketAddr) -> Result<()> {
+        // Read first bytes to determine handshake type
+        let mut first_bytes = [0u8; 5];
+        stream.read_exact(&mut first_bytes).await?;
+        
+        let is_tls = tls::is_tls_handshake(&first_bytes[..3]);
+        
+        debug!(peer = %peer, is_tls = is_tls, first_bytes = %hex::encode(&first_bytes), "Handshake type detected");
+        
+        if is_tls {
+            self.handle_tls_client(stream, peer, first_bytes).await
+        } else {
+            self.handle_direct_client(stream, peer, first_bytes).await
+        }
+    }
+    
+    /// Handle TLS-wrapped client
+    async fn handle_tls_client(
+        &self,
+        mut stream: TcpStream,
+        peer: SocketAddr,
+        first_bytes: [u8; 5],
+    ) -> Result<()> {
+        // Read TLS handshake length
+        let tls_len = u16::from_be_bytes([first_bytes[3], first_bytes[4]]) as usize;
+        
+        debug!(peer = %peer, tls_len = tls_len, "Reading TLS handshake");
+        
+        if tls_len < 512 {
+            debug!(peer = %peer, tls_len = tls_len, "TLS handshake too short");
+            self.stats.increment_connects_bad();
+            handle_bad_client(stream, &first_bytes, &self.config).await;
+            return Ok(());
+        }
+        
+        // Read full TLS handshake
+        let mut handshake = vec![0u8; 5 + tls_len];
+        handshake[..5].copy_from_slice(&first_bytes);
+        stream.read_exact(&mut handshake[5..]).await?;
+        
+        // Split stream for reading/writing
+        let (read_half, write_half) = stream.into_split();
+        
+        // Handle TLS handshake
+        let (mut tls_reader, tls_writer, _tls_user) = match handle_tls_handshake(
+            &handshake,
+            read_half,
+            write_half,
+            peer,
+            &self.config,
+            &self.replay_checker,
+        ).await {
+            HandshakeResult::Success(result) => result,
+            HandshakeResult::BadClient => {
+                self.stats.increment_connects_bad();
+                return Ok(());
+            }
+            HandshakeResult::Error(e) => return Err(e),
+        };
+        
+        // Read MTProto handshake through TLS
+        debug!(peer = %peer, "Reading MTProto handshake through TLS");
+        let mtproto_data = tls_reader.read_exact(HANDSHAKE_LEN).await?;
+        let mtproto_handshake: [u8; HANDSHAKE_LEN] = mtproto_data[..].try_into()
+            .map_err(|_| ProxyError::InvalidHandshake("Short MTProto handshake".into()))?;
+        
+        // Handle MTProto handshake
+        let (crypto_reader, crypto_writer, success) = match handle_mtproto_handshake(
+            &mtproto_handshake,
+            tls_reader,
+            tls_writer,
+            peer,
+            &self.config,
+            &self.replay_checker,
+            true,
+        ).await {
+            HandshakeResult::Success(result) => result,
+            HandshakeResult::BadClient => {
+                self.stats.increment_connects_bad();
+                return Ok(());
+            }
+            HandshakeResult::Error(e) => return Err(e),
+        };
+        
+        // Handle authenticated client
+        self.handle_authenticated_inner(crypto_reader, crypto_writer, success).await
+    }
+    
+    /// Handle direct (non-TLS) client
+    async fn handle_direct_client(
+        &self,
+        mut stream: TcpStream,
+        peer: SocketAddr,
+        first_bytes: [u8; 5],
+    ) -> Result<()> {
+        // Check if non-TLS modes are enabled
+        if !self.config.modes.classic && !self.config.modes.secure {
+            debug!(peer = %peer, "Non-TLS modes disabled");
+            self.stats.increment_connects_bad();
+            handle_bad_client(stream, &first_bytes, &self.config).await;
+            return Ok(());
+        }
+        
+        // Read rest of handshake
+        let mut handshake = [0u8; HANDSHAKE_LEN];
+        handshake[..5].copy_from_slice(&first_bytes);
+        stream.read_exact(&mut handshake[5..]).await?;
+        
+        // Split stream
+        let (read_half, write_half) = stream.into_split();
+        
+        // Handle MTProto handshake
+        let (crypto_reader, crypto_writer, success) = match handle_mtproto_handshake(
+            &handshake,
+            read_half,
+            write_half,
+            peer,
+            &self.config,
+            &self.replay_checker,
+            false,
+        ).await {
+            HandshakeResult::Success(result) => result,
+            HandshakeResult::BadClient => {
+                self.stats.increment_connects_bad();
+                return Ok(());
+            }
+            HandshakeResult::Error(e) => return Err(e),
+        };
+        
+        self.handle_authenticated_inner(crypto_reader, crypto_writer, success).await
+    }
+    
+    /// Handle authenticated client - connect to Telegram and relay
+    async fn handle_authenticated_inner<R, W>(
+        &self,
+        client_reader: CryptoReader<R>,
+        client_writer: CryptoWriter<W>,
+        success: HandshakeSuccess,
+    ) -> Result<()>
+    where
+        R: AsyncRead + Unpin + Send + 'static,
+        W: AsyncWrite + Unpin + Send + 'static,
+    {
+        let user = &success.user;
+        
+        // Check user limits
+        if let Err(e) = self.check_user_limits(user) {
+            warn!(user = %user, error = %e, "User limit exceeded");
+            return Err(e);
+        }
+        
+        // Get datacenter address
+        let dc_addr = self.get_dc_addr(success.dc_idx)?;
+        
+        info!(
+            user = %user,
+            peer = %success.peer,
+            dc = success.dc_idx,
+            dc_addr = %dc_addr,
+            proto = ?success.proto_tag,
+            fast_mode = self.config.fast_mode,
+            "Connecting to Telegram"
+        );
+        
+        // Connect to Telegram
+        let tg_stream = self.pool.get(dc_addr).await?;
+        
+        debug!(peer = %success.peer, dc_addr = %dc_addr, "Connected to Telegram, performing handshake");
+        
+        // Perform Telegram handshake and get crypto streams
+        let (tg_reader, tg_writer) = self.do_tg_handshake(
+            tg_stream, 
+            &success,
+        ).await?;
+        
+        debug!(peer = %success.peer, "Telegram handshake complete, starting relay");
+        
+        // Update stats
+        self.stats.increment_user_connects(user);
+        self.stats.increment_user_curr_connects(user);
+        
+        // Relay traffic - передаём Arc::clone(&self.stats)
+        let relay_result = relay_bidirectional(
+            client_reader,
+            client_writer,
+            tg_reader,
+            tg_writer,
+            user,
+            Arc::clone(&self.stats),
+        ).await;
+        
+        // Update stats
+        self.stats.decrement_user_curr_connects(user);
+        
+        match &relay_result {
+            Ok(()) => debug!(user = %user, peer = %success.peer, "Relay completed normally"),
+            Err(e) => debug!(user = %user, peer = %success.peer, error = %e, "Relay ended with error"),
+        }
+        
+        relay_result
+    }
+    
+    /// Check user limits (expiration, connection count, data quota)
+    fn check_user_limits(&self, user: &str) -> Result<()> {
+        // Check expiration
+        if let Some(expiration) = self.config.user_expirations.get(user) {
+            if chrono::Utc::now() > *expiration {
+                return Err(ProxyError::UserExpired { user: user.to_string() });
+            }
+        }
+        
+        // Check connection limit
+        if let Some(limit) = self.config.user_max_tcp_conns.get(user) {
+            let current = self.stats.get_user_curr_connects(user);
+            if current >= *limit as u64 {
+                return Err(ProxyError::ConnectionLimitExceeded { user: user.to_string() });
+            }
+        }
+        
+        // Check data quota
+        if let Some(quota) = self.config.user_data_quota.get(user) {
+            let used = self.stats.get_user_total_octets(user);
+            if used >= *quota {
+                return Err(ProxyError::DataQuotaExceeded { user: user.to_string() });
+            }
+        }
+        
+        Ok(())
+    }
+    
+    /// Get datacenter address by index
+    fn get_dc_addr(&self, dc_idx: i16) -> Result<SocketAddr> {
+        let idx = (dc_idx.abs() - 1) as usize;
+        
+        let datacenters = if self.config.prefer_ipv6 {
+            &*TG_DATACENTERS_V6
+        } else {
+            &*TG_DATACENTERS_V4
+        };
+        
+        datacenters.get(idx)
+            .map(|ip| SocketAddr::new(*ip, TG_DATACENTER_PORT))
+            .ok_or_else(|| ProxyError::InvalidHandshake(
+                format!("Invalid DC index: {}", dc_idx)
+            ))
+    }
+    
+    /// Perform handshake with Telegram server
+    /// Returns crypto reader and writer for TG connection
+    async fn do_tg_handshake(
+        &self,
+        mut stream: TcpStream,
+        success: &HandshakeSuccess,
+    ) -> Result<(CryptoReader<tokio::net::tcp::OwnedReadHalf>, CryptoWriter<tokio::net::tcp::OwnedWriteHalf>)> {
+        // Generate nonce with keys for TG
+        let (nonce, tg_enc_key, tg_enc_iv, tg_dec_key, tg_dec_iv) = generate_tg_nonce(
+            success.proto_tag,
+            &success.dec_key,  // Client's dec key
+            success.dec_iv,
+            self.config.fast_mode,
+        );
+        
+        // Encrypt nonce
+        let encrypted_nonce = encrypt_tg_nonce(&nonce);
+        
+        debug!(
+            peer = %success.peer,
+            nonce_head = %hex::encode(&nonce[..16]),
+            encrypted_head = %hex::encode(&encrypted_nonce[..16]),
+            "Sending nonce to Telegram"
+        );
+        
+        // Send to Telegram
+        stream.write_all(&encrypted_nonce).await?;
+        stream.flush().await?;
+        
+        debug!(peer = %success.peer, "Nonce sent to Telegram");
+        
+        // Split stream and wrap with crypto
+        let (read_half, write_half) = stream.into_split();
+        
+        let decryptor = AesCtr::new(&tg_dec_key, tg_dec_iv);
+        let encryptor = AesCtr::new(&tg_enc_key, tg_enc_iv);
+        
+        let tg_reader = CryptoReader::new(read_half, decryptor);
+        let tg_writer = CryptoWriter::new(write_half, encryptor);
+        
+        Ok((tg_reader, tg_writer))
+    }
+}

src/proxy/handshake.rs

@@ -0,0 +1,411 @@
+//! MTProto Handshake Magics
+
+use std::net::SocketAddr;
+use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
+use tracing::{debug, warn, trace, info};
+
+use crate::crypto::{sha256, AesCtr};
+use crate::crypto::random::SECURE_RANDOM;
+use crate::protocol::constants::*;
+use crate::protocol::tls;
+use crate::stream::{FakeTlsReader, FakeTlsWriter, CryptoReader, CryptoWriter};
+use crate::error::{ProxyError, HandshakeResult};
+use crate::stats::ReplayChecker;
+use crate::config::ProxyConfig;
+
+/// Result of successful handshake
+#[derive(Debug, Clone)]
+pub struct HandshakeSuccess {
+    /// Authenticated user name
+    pub user: String,
+    /// Target datacenter index
+    pub dc_idx: i16,
+    /// Protocol variant (abridged/intermediate/secure)
+    pub proto_tag: ProtoTag,
+    /// Decryption key and IV (for reading from client)
+    pub dec_key: [u8; 32],
+    pub dec_iv: u128,
+    /// Encryption key and IV (for writing to client) 
+    pub enc_key: [u8; 32],
+    pub enc_iv: u128,
+    /// Client address
+    pub peer: SocketAddr,
+    /// Whether TLS was used
+    pub is_tls: bool,
+}
+
+/// Handle fake TLS handshake
+pub async fn handle_tls_handshake<R, W>(
+    handshake: &[u8],
+    reader: R,
+    mut writer: W,
+    peer: SocketAddr,
+    config: &ProxyConfig,
+    replay_checker: &ReplayChecker,
+) -> HandshakeResult<(FakeTlsReader<R>, FakeTlsWriter<W>, String)>
+where
+    R: AsyncRead + Unpin,
+    W: AsyncWrite + Unpin,
+{
+    debug!(peer = %peer, handshake_len = handshake.len(), "Processing TLS handshake");
+    
+    // Check minimum length
+    if handshake.len() < tls::TLS_DIGEST_POS + tls::TLS_DIGEST_LEN + 1 {
+        debug!(peer = %peer, "TLS handshake too short");
+        return HandshakeResult::BadClient;
+    }
+    
+    // Extract digest for replay check
+    let digest = &handshake[tls::TLS_DIGEST_POS..tls::TLS_DIGEST_POS + tls::TLS_DIGEST_LEN];
+    let digest_half = &digest[..tls::TLS_DIGEST_HALF_LEN];
+    
+    // Check for replay
+    if replay_checker.check_tls_digest(digest_half) {
+        warn!(peer = %peer, "TLS replay attack detected");
+        return HandshakeResult::BadClient;
+    }
+    
+    // Build secrets list
+    let secrets: Vec<(String, Vec<u8>)> = config.users.iter()
+        .filter_map(|(name, hex)| {
+            hex::decode(hex).ok().map(|bytes| (name.clone(), bytes))
+        })
+        .collect();
+    
+    debug!(peer = %peer, num_users = secrets.len(), "Validating TLS handshake against users");
+    
+    // Validate handshake
+    let validation = match tls::validate_tls_handshake(
+        handshake,
+        &secrets,
+        config.ignore_time_skew,
+    ) {
+        Some(v) => v,
+        None => {
+            debug!(peer = %peer, "TLS handshake validation failed - no matching user");
+            return HandshakeResult::BadClient;
+        }
+    };
+    
+    // Get secret for response
+    let secret = match secrets.iter().find(|(name, _)| *name == validation.user) {
+        Some((_, s)) => s,
+        None => return HandshakeResult::BadClient,
+    };
+    
+    // Build and send response
+    let response = tls::build_server_hello(
+        secret,
+        &validation.digest,
+        &validation.session_id,
+        config.fake_cert_len,
+    );
+    
+    debug!(peer = %peer, response_len = response.len(), "Sending TLS ServerHello");
+    
+    if let Err(e) = writer.write_all(&response).await {
+        return HandshakeResult::Error(ProxyError::Io(e));
+    }
+    
+    if let Err(e) = writer.flush().await {
+        return HandshakeResult::Error(ProxyError::Io(e));
+    }
+    
+    // Record for replay protection
+    replay_checker.add_tls_digest(digest_half);
+    
+    info!(
+        peer = %peer,
+        user = %validation.user,
+        "TLS handshake successful"
+    );
+    
+    HandshakeResult::Success((
+        FakeTlsReader::new(reader),
+        FakeTlsWriter::new(writer),
+        validation.user,
+    ))
+}
+
+/// Handle MTProto obfuscation handshake
+pub async fn handle_mtproto_handshake<R, W>(
+    handshake: &[u8; HANDSHAKE_LEN],
+    reader: R,
+    writer: W,
+    peer: SocketAddr,
+    config: &ProxyConfig,
+    replay_checker: &ReplayChecker,
+    is_tls: bool,
+) -> HandshakeResult<(CryptoReader<R>, CryptoWriter<W>, HandshakeSuccess)>
+where
+    R: AsyncRead + Unpin + Send,
+    W: AsyncWrite + Unpin + Send,
+{
+    trace!(peer = %peer, handshake = ?hex::encode(handshake), "MTProto handshake bytes");
+    
+    // Extract prekey and IV
+    let dec_prekey_iv = &handshake[SKIP_LEN..SKIP_LEN + PREKEY_LEN + IV_LEN];
+    
+    debug!(
+        peer = %peer,
+        dec_prekey_iv = %hex::encode(dec_prekey_iv),
+        "Extracted prekey+IV from handshake"
+    );
+    
+    // Check for replay
+    if replay_checker.check_handshake(dec_prekey_iv) {
+        warn!(peer = %peer, "MTProto replay attack detected");
+        return HandshakeResult::BadClient;
+    }
+    
+    // Reversed for encryption direction
+    let enc_prekey_iv: Vec<u8> = dec_prekey_iv.iter().rev().copied().collect();
+    
+    // Try each user's secret
+    for (user, secret_hex) in &config.users {
+        let secret = match hex::decode(secret_hex) {
+            Ok(s) => s,
+            Err(_) => continue,
+        };
+        
+        // Derive decryption key
+        let dec_prekey = &dec_prekey_iv[..PREKEY_LEN];
+        let dec_iv_bytes = &dec_prekey_iv[PREKEY_LEN..];
+        
+        let mut dec_key_input = Vec::with_capacity(PREKEY_LEN + secret.len());
+        dec_key_input.extend_from_slice(dec_prekey);
+        dec_key_input.extend_from_slice(&secret);
+        let dec_key = sha256(&dec_key_input);
+        
+        let dec_iv = u128::from_be_bytes(dec_iv_bytes.try_into().unwrap());
+        
+        // Decrypt handshake to check protocol tag
+        let mut decryptor = AesCtr::new(&dec_key, dec_iv);
+        let decrypted = decryptor.decrypt(handshake);
+        
+        trace!(
+            peer = %peer,
+            user = %user,
+            decrypted_tail = %hex::encode(&decrypted[PROTO_TAG_POS..]),
+            "Decrypted handshake tail"
+        );
+        
+        // Check protocol tag
+        let tag_bytes: [u8; 4] = decrypted[PROTO_TAG_POS..PROTO_TAG_POS + 4]
+            .try_into()
+            .unwrap();
+        
+        let proto_tag = match ProtoTag::from_bytes(tag_bytes) {
+            Some(tag) => tag,
+            None => {
+                trace!(peer = %peer, user = %user, tag = %hex::encode(tag_bytes), "Invalid proto tag");
+                continue;
+            }
+        };
+        
+        debug!(peer = %peer, user = %user, proto = ?proto_tag, "Found valid proto tag");
+        
+        // Check if mode is enabled
+        let mode_ok = match proto_tag {
+            ProtoTag::Secure => {
+                if is_tls { config.modes.tls } else { config.modes.secure }
+            }
+            ProtoTag::Intermediate | ProtoTag::Abridged => config.modes.classic,
+        };
+        
+        if !mode_ok {
+            debug!(peer = %peer, user = %user, proto = ?proto_tag, "Mode not enabled");
+            continue;
+        }
+        
+        // Extract DC index
+        let dc_idx = i16::from_le_bytes(
+            decrypted[DC_IDX_POS..DC_IDX_POS + 2].try_into().unwrap()
+        );
+        
+        // Derive encryption key
+        let enc_prekey = &enc_prekey_iv[..PREKEY_LEN];
+        let enc_iv_bytes = &enc_prekey_iv[PREKEY_LEN..];
+        
+        let mut enc_key_input = Vec::with_capacity(PREKEY_LEN + secret.len());
+        enc_key_input.extend_from_slice(enc_prekey);
+        enc_key_input.extend_from_slice(&secret);
+        let enc_key = sha256(&enc_key_input);
+        
+        let enc_iv = u128::from_be_bytes(enc_iv_bytes.try_into().unwrap());
+        
+        // Record for replay protection
+        replay_checker.add_handshake(dec_prekey_iv);
+        
+        // Create new cipher instances
+        let decryptor = AesCtr::new(&dec_key, dec_iv);
+        let encryptor = AesCtr::new(&enc_key, enc_iv);
+        
+        let success = HandshakeSuccess {
+            user: user.clone(),
+            dc_idx,
+            proto_tag,
+            dec_key,
+            dec_iv,
+            enc_key,
+            enc_iv,
+            peer,
+            is_tls,
+        };
+        
+        info!(
+            peer = %peer,
+            user = %user,
+            dc = dc_idx,
+            proto = ?proto_tag,
+            tls = is_tls,
+            "MTProto handshake successful"
+        );
+        
+        return HandshakeResult::Success((
+            CryptoReader::new(reader, decryptor),
+            CryptoWriter::new(writer, encryptor),
+            success,
+        ));
+    }
+    
+    debug!(peer = %peer, "MTProto handshake: no matching user found");
+    HandshakeResult::BadClient
+}
+
+/// Generate nonce for Telegram connection
+/// 
+/// In FAST MODE: we use the same keys for TG as for client, but reversed.
+/// This means: client's enc_key becomes TG's dec_key and vice versa.
+pub fn generate_tg_nonce(
+    proto_tag: ProtoTag, 
+    client_dec_key: &[u8; 32],
+    client_dec_iv: u128,
+    fast_mode: bool,
+) -> ([u8; HANDSHAKE_LEN], [u8; 32], u128, [u8; 32], u128) {
+    loop {
+        let bytes = SECURE_RANDOM.bytes(HANDSHAKE_LEN);
+        let mut nonce: [u8; HANDSHAKE_LEN] = bytes.try_into().unwrap();
+        
+        // Check reserved patterns
+        if RESERVED_NONCE_FIRST_BYTES.contains(&nonce[0]) {
+            continue;
+        }
+        
+        let first_four: [u8; 4] = nonce[..4].try_into().unwrap();
+        if RESERVED_NONCE_BEGINNINGS.contains(&first_four) {
+            continue;
+        }
+        
+        let continue_four: [u8; 4] = nonce[4..8].try_into().unwrap();
+        if RESERVED_NONCE_CONTINUES.contains(&continue_four) {
+            continue;
+        }
+        
+        // Set protocol tag
+        nonce[PROTO_TAG_POS..PROTO_TAG_POS + 4].copy_from_slice(&proto_tag.to_bytes());
+        
+        // Fast mode: copy client's dec_key+iv (this becomes TG's enc direction)
+        // In fast mode, we make TG use the same keys as client but swapped:
+        // - What we decrypt FROM TG = what we encrypt TO client (so no re-encryption needed)
+        // - What we encrypt TO TG = what we decrypt FROM client
+        if fast_mode {
+            // Put client's dec_key + dec_iv into nonce[8:56]
+            // This will be used by TG for encryption TO us
+            nonce[SKIP_LEN..SKIP_LEN + KEY_LEN].copy_from_slice(client_dec_key);
+            nonce[SKIP_LEN + KEY_LEN..SKIP_LEN + KEY_LEN + IV_LEN]
+                .copy_from_slice(&client_dec_iv.to_be_bytes());
+        }
+        
+        // Now compute what keys WE will use for TG connection
+        // enc_key_iv = nonce[8:56] (for encrypting TO TG)
+        // dec_key_iv = nonce[8:56] reversed (for decrypting FROM TG)
+        let enc_key_iv = &nonce[SKIP_LEN..SKIP_LEN + KEY_LEN + IV_LEN];
+        let dec_key_iv: Vec<u8> = enc_key_iv.iter().rev().copied().collect();
+        
+        let tg_enc_key: [u8; 32] = enc_key_iv[..KEY_LEN].try_into().unwrap();
+        let tg_enc_iv = u128::from_be_bytes(enc_key_iv[KEY_LEN..].try_into().unwrap());
+        
+        let tg_dec_key: [u8; 32] = dec_key_iv[..KEY_LEN].try_into().unwrap();
+        let tg_dec_iv = u128::from_be_bytes(dec_key_iv[KEY_LEN..].try_into().unwrap());
+        
+        debug!(
+            fast_mode = fast_mode,
+            tg_enc_key = %hex::encode(&tg_enc_key[..8]),
+            tg_dec_key = %hex::encode(&tg_dec_key[..8]),
+            "Generated TG nonce"
+        );
+        
+        return (nonce, tg_enc_key, tg_enc_iv, tg_dec_key, tg_dec_iv);
+    }
+}
+
+/// Encrypt nonce for sending to Telegram
+/// 
+/// Only the part from PROTO_TAG_POS onwards is encrypted.
+/// The encryption key is derived from enc_key_iv in the nonce itself.
+pub fn encrypt_tg_nonce(nonce: &[u8; HANDSHAKE_LEN]) -> Vec<u8> {
+    // enc_key_iv is at nonce[8:56]
+    let enc_key_iv = &nonce[SKIP_LEN..SKIP_LEN + KEY_LEN + IV_LEN];
+    
+    // Key for encrypting is just the first 32 bytes of enc_key_iv
+    let key: [u8; 32] = enc_key_iv[..KEY_LEN].try_into().unwrap();
+    let iv = u128::from_be_bytes(enc_key_iv[KEY_LEN..].try_into().unwrap());
+    
+    let mut encryptor = AesCtr::new(&key, iv);
+    
+    // Encrypt the entire nonce first, then take only the encrypted tail
+    let encrypted_full = encryptor.encrypt(nonce);
+    
+    // Result: unencrypted head + encrypted tail
+    let mut result = nonce[..PROTO_TAG_POS].to_vec();
+    result.extend_from_slice(&encrypted_full[PROTO_TAG_POS..]);
+    
+    trace!(
+        original = %hex::encode(&nonce[PROTO_TAG_POS..]),
+        encrypted = %hex::encode(&result[PROTO_TAG_POS..]),
+        "Encrypted nonce tail"
+    );
+    
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    
+    #[test]
+    fn test_generate_tg_nonce() {
+        let client_dec_key = [0x42u8; 32];
+        let client_dec_iv = 12345u128;
+        
+        let (nonce, tg_enc_key, tg_enc_iv, tg_dec_key, tg_dec_iv) = 
+            generate_tg_nonce(ProtoTag::Secure, &client_dec_key, client_dec_iv, false);
+        
+        // Check length
+        assert_eq!(nonce.len(), HANDSHAKE_LEN);
+        
+        // Check proto tag is set
+        let tag_bytes: [u8; 4] = nonce[PROTO_TAG_POS..PROTO_TAG_POS + 4].try_into().unwrap();
+        assert_eq!(ProtoTag::from_bytes(tag_bytes), Some(ProtoTag::Secure));
+    }
+    
+    #[test]
+    fn test_encrypt_tg_nonce() {
+        let client_dec_key = [0x42u8; 32];
+        let client_dec_iv = 12345u128;
+        
+        let (nonce, _, _, _, _) = 
+            generate_tg_nonce(ProtoTag::Secure, &client_dec_key, client_dec_iv, false);
+        
+        let encrypted = encrypt_tg_nonce(&nonce);
+        
+        assert_eq!(encrypted.len(), HANDSHAKE_LEN);
+        
+        // First PROTO_TAG_POS bytes should be unchanged
+        assert_eq!(&encrypted[..PROTO_TAG_POS], &nonce[..PROTO_TAG_POS]);
+        
+        // Rest should be different (encrypted)
+        assert_ne!(&encrypted[PROTO_TAG_POS..], &nonce[PROTO_TAG_POS..]);
+    }
+}

src/proxy/masking.rs

@@ -0,0 +1,115 @@
+//! Masking - forward unrecognized traffic to mask host
+
+use std::time::Duration;
+use tokio::net::TcpStream;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::time::timeout;
+use tracing::debug;
+use crate::config::ProxyConfig;
+use crate::transport::set_linger_zero;
+
+const MASK_TIMEOUT: Duration = Duration::from_secs(5);
+const MASK_BUFFER_SIZE: usize = 8192;
+
+/// Handle a bad client by forwarding to mask host
+pub async fn handle_bad_client(
+    mut client: TcpStream,
+    initial_data: &[u8],
+    config: &ProxyConfig,
+) {
+    if !config.mask {
+        // Masking disabled, just consume data
+        consume_client_data(client).await;
+        return;
+    }
+    
+    let mask_host = config.mask_host.as_deref()
+        .unwrap_or(&config.tls_domain);
+    let mask_port = config.mask_port;
+    
+    debug!(
+        host = %mask_host,
+        port = mask_port,
+        "Forwarding bad client to mask host"
+    );
+    
+    // Connect to mask host
+    let mask_addr = format!("{}:{}", mask_host, mask_port);
+    let connect_result = timeout(
+        MASK_TIMEOUT,
+        TcpStream::connect(&mask_addr)
+    ).await;
+    
+    let mut mask_stream = match connect_result {
+        Ok(Ok(s)) => s,
+        Ok(Err(e)) => {
+            debug!(error = %e, "Failed to connect to mask host");
+            consume_client_data(client).await;
+            return;
+        }
+        Err(_) => {
+            debug!("Timeout connecting to mask host");
+            consume_client_data(client).await;
+            return;
+        }
+    };
+    
+    // Send initial data to mask host
+    if mask_stream.write_all(initial_data).await.is_err() {
+        return;
+    }
+    
+    // Relay traffic
+    let (mut client_read, mut client_write) = client.into_split();
+    let (mut mask_read, mut mask_write) = mask_stream.into_split();
+    
+    let c2m = tokio::spawn(async move {
+        let mut buf = vec![0u8; MASK_BUFFER_SIZE];
+        loop {
+            match client_read.read(&mut buf).await {
+                Ok(0) | Err(_) => {
+                    let _ = mask_write.shutdown().await;
+                    break;
+                }
+                Ok(n) => {
+                    if mask_write.write_all(&buf[..n]).await.is_err() {
+                        break;
+                    }
+                }
+            }
+        }
+    });
+    
+    let m2c = tokio::spawn(async move {
+        let mut buf = vec![0u8; MASK_BUFFER_SIZE];
+        loop {
+            match mask_read.read(&mut buf).await {
+                Ok(0) | Err(_) => {
+                    let _ = client_write.shutdown().await;
+                    break;
+                }
+                Ok(n) => {
+                    if client_write.write_all(&buf[..n]).await.is_err() {
+                        break;
+                    }
+                }
+            }
+        }
+    });
+    
+    // Wait for either to complete
+    tokio::select! {
+        _ = c2m => {}
+        _ = m2c => {}
+    }
+}
+
+/// Just consume all data from client without responding
+async fn consume_client_data(mut client: TcpStream) {
+    let mut buf = vec![0u8; MASK_BUFFER_SIZE];
+    while let Ok(n) = client.read(&mut buf).await {
+        if n == 0 {
+            break;
+        }
+    }
+}

src/proxy/mod.rs

@@ -0,0 +1,11 @@
+//! Proxy Defs
+
+pub mod handshake;
+pub mod client;
+pub mod relay;
+pub mod masking;
+
+pub use handshake::*;
+pub use client::ClientHandler;
+pub use relay::*;
+pub use masking::*;

src/proxy/relay.rs

@@ -0,0 +1,162 @@
+//! Bidirectional Relay
+
+use std::sync::Arc;
+use tokio::io::{AsyncRead, AsyncWrite, AsyncReadExt, AsyncWriteExt};
+use tracing::{debug, trace, warn};
+use crate::error::Result;
+use crate::stats::Stats;
+use std::sync::atomic::{AtomicU64, Ordering};
+
+const BUFFER_SIZE: usize = 65536;
+
+/// Relay data bidirectionally between client and server
+pub async fn relay_bidirectional<CR, CW, SR, SW>(
+    mut client_reader: CR,
+    mut client_writer: CW,
+    mut server_reader: SR,
+    mut server_writer: SW,
+    user: &str,
+    stats: Arc<Stats>,
+) -> Result<()>
+where
+    CR: AsyncRead + Unpin + Send + 'static,
+    CW: AsyncWrite + Unpin + Send + 'static,
+    SR: AsyncRead + Unpin + Send + 'static,
+    SW: AsyncWrite + Unpin + Send + 'static,
+{
+    let user_c2s = user.to_string();
+    let user_s2c = user.to_string();
+    
+    // Используем Arc::clone вместо stats.clone()
+    let stats_c2s = Arc::clone(&stats);
+    let stats_s2c = Arc::clone(&stats);
+    
+    let c2s_bytes = Arc::new(AtomicU64::new(0));
+    let s2c_bytes = Arc::new(AtomicU64::new(0));
+    let c2s_bytes_clone = Arc::clone(&c2s_bytes);
+    let s2c_bytes_clone = Arc::clone(&s2c_bytes);
+    
+    // Client -> Server task
+    let c2s = tokio::spawn(async move {
+        let mut buf = vec![0u8; BUFFER_SIZE];
+        let mut total_bytes = 0u64;
+        let mut msg_count = 0u64;
+        
+        loop {
+            match client_reader.read(&mut buf).await {
+                Ok(0) => {
+                    debug!(
+                        user = %user_c2s, 
+                        total_bytes = total_bytes,
+                        msgs = msg_count,
+                        "Client closed connection (C->S)"
+                    );
+                    let _ = server_writer.shutdown().await;
+                    break;
+                }
+                Ok(n) => {
+                    total_bytes += n as u64;
+                    msg_count += 1;
+                    c2s_bytes_clone.store(total_bytes, Ordering::Relaxed);
+                    
+                    stats_c2s.add_user_octets_from(&user_c2s, n as u64);
+                    stats_c2s.increment_user_msgs_from(&user_c2s);
+                    
+                    trace!(
+                        user = %user_c2s,
+                        bytes = n,
+                        total = total_bytes,
+                        data_preview = %hex::encode(&buf[..n.min(32)]),
+                        "C->S data"
+                    );
+                    
+                    if let Err(e) = server_writer.write_all(&buf[..n]).await {
+                        debug!(user = %user_c2s, error = %e, "Failed to write to server");
+                        break;
+                    }
+                    if let Err(e) = server_writer.flush().await {
+                        debug!(user = %user_c2s, error = %e, "Failed to flush to server");
+                        break;
+                    }
+                }
+                Err(e) => {
+                    debug!(user = %user_c2s, error = %e, total_bytes = total_bytes, "Client read error");
+                    break;
+                }
+            }
+        }
+    });
+    
+    // Server -> Client task
+    let s2c = tokio::spawn(async move {
+        let mut buf = vec![0u8; BUFFER_SIZE];
+        let mut total_bytes = 0u64;
+        let mut msg_count = 0u64;
+        
+        loop {
+            match server_reader.read(&mut buf).await {
+                Ok(0) => {
+                    debug!(
+                        user = %user_s2c,
+                        total_bytes = total_bytes,
+                        msgs = msg_count,
+                        "Server closed connection (S->C)"
+                    );
+                    let _ = client_writer.shutdown().await;
+                    break;
+                }
+                Ok(n) => {
+                    total_bytes += n as u64;
+                    msg_count += 1;
+                    s2c_bytes_clone.store(total_bytes, Ordering::Relaxed);
+                    
+                    stats_s2c.add_user_octets_to(&user_s2c, n as u64);
+                    stats_s2c.increment_user_msgs_to(&user_s2c);
+                    
+                    trace!(
+                        user = %user_s2c,
+                        bytes = n,
+                        total = total_bytes,
+                        data_preview = %hex::encode(&buf[..n.min(32)]),
+                        "S->C data"
+                    );
+                    
+                    if let Err(e) = client_writer.write_all(&buf[..n]).await {
+                        debug!(user = %user_s2c, error = %e, "Failed to write to client");
+                        break;
+                    }
+                    if let Err(e) = client_writer.flush().await {
+                        debug!(user = %user_s2c, error = %e, "Failed to flush to client");
+                        break;
+                    }
+                }
+                Err(e) => {
+                    debug!(user = %user_s2c, error = %e, total_bytes = total_bytes, "Server read error");
+                    break;
+                }
+            }
+        }
+    });
+    
+    // Wait for either direction to complete
+    tokio::select! {
+        result = c2s => {
+            if let Err(e) = result {
+                warn!(error = %e, "C->S task panicked");
+            }
+        }
+        result = s2c => {
+            if let Err(e) = result {
+                warn!(error = %e, "S->C task panicked");
+            }
+        }
+    }
+    
+    debug!(
+        c2s_bytes = c2s_bytes.load(Ordering::Relaxed),
+        s2c_bytes = s2c_bytes.load(Ordering::Relaxed),
+        "Relay finished"
+    );
+    
+    Ok(())
+}