diff --git a/Cargo.toml b/Cargo.toml index 3b213045..6c929666 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -76,6 +76,9 @@ tower = "0.3" pin-project = "0.4" socket2 = "0.3" cfg-if = "0.1" +# bloomfilter = "1.0" +bloomfilter = { git = "https://github.com/zonyitoo/rust-bloom-filter.git" } +spin = "0.5" [target.'cfg(windows)'.dependencies] winapi = { version = "0.3", features = ["mswsock", "winsock2"] } diff --git a/src/context.rs b/src/context.rs index 2662b16a..3c5447a4 100644 --- a/src/context.rs +++ b/src/context.rs @@ -9,14 +9,92 @@ use std::{ }, }; +use bloomfilter::Bloom; +use spin::Mutex; use tokio::runtime::Handle; #[cfg(feature = "trust-dns")] use trust_dns_resolver::TokioAsyncResolver; -use crate::config::Config; +use crate::config::{Config, ConfigType}; #[cfg(feature = "trust-dns")] use crate::relay::dns_resolver::create_resolver; +// Entries for server's bloom filter +// +// Borrowed from shadowsocks-libev's default value +const BF_NUM_ENTRIES_FOR_SERVER: usize = 1_000_000; + +// Entries for client's bloom filter +// +// Borrowed from shadowsocks-libev's default value +const BF_NUM_ENTRIES_FOR_CLIENT: usize = 10_000; + +// Error rate for server's bloom filter +// +// Borrowed from shadowsocks-libev's default value +const BF_ERROR_RATE_FOR_SERVER: f64 = 1e-6; + +// Error rate for client's bloom filter +// +// Borrowed from shadowsocks-libev's default value +const BF_ERROR_RATE_FOR_CLIENT: f64 = 1e-15; + +// A bloom filter borrowed from shadowsocks-libev's `ppbloom` +// +// It contains 2 bloom filters and each one holds 1/2 entries. +// Use them as a ring buffer. +struct PingPongBloom { + blooms: [Bloom<[u8]>; 2], + bloom_count: [usize; 2], + item_count: usize, + current: usize, +} + +impl PingPongBloom { + fn new(ty: ConfigType) -> PingPongBloom { + let (mut item_count, fp_p) = if ty.is_local() { + (BF_NUM_ENTRIES_FOR_CLIENT, BF_ERROR_RATE_FOR_CLIENT) + } else { + (BF_NUM_ENTRIES_FOR_SERVER, BF_ERROR_RATE_FOR_SERVER) + }; + + item_count /= 2; + + PingPongBloom { + blooms: [ + Bloom::new_for_fp_rate(item_count, fp_p), + Bloom::new_for_fp_rate(item_count, fp_p), + ], + bloom_count: [0, 0], + item_count, + current: 0, + } + } + + // Check if data in `buf` exist. + // + // Set into the current bloom filter if not exist. + // + // Return `true` if data exist in bloom filter. + fn check_and_set(&mut self, buf: &[u8]) -> bool { + if self.bloom_count[self.current] >= self.item_count { + // Current bloom filter is full, + // Create a new one and use the next one as current. + self.bloom_count[self.current] = 0; + self.blooms[self.current].clear(); + + self.current = (self.current + 1) % 2; + } + + if !self.blooms[self.current].check_and_set(buf) { + self.bloom_count[self.current] += 1; + false + } else { + true + } + } +} + /// Server's global running status /// /// Shared between UDP and TCP servers @@ -24,6 +102,7 @@ pub struct ServerState { #[cfg(feature = "trust-dns")] dns_resolver: TokioAsyncResolver, server_running: AtomicBool, + nonce_ppbloom: Mutex, } impl ServerState { @@ -33,6 +112,7 @@ impl ServerState { #[cfg(feature = "trust-dns")] dns_resolver: create_resolver(config.get_dns_config(), rt).await?, server_running: AtomicBool::new(true), + nonce_ppbloom: Mutex::new(PingPongBloom::new(config.config_type)), }; Ok(Arc::new(state)) @@ -48,11 +128,19 @@ impl ServerState { self.server_running.store(false, Ordering::Release) } - #[cfg(feature = "trust-dns")] /// Get the global shared resolver + #[cfg(feature = "trust-dns")] pub fn dns_resolver(&self) -> &TokioAsyncResolver { &self.dns_resolver } + + /// Check if nonce exist or not + /// + /// If not, set into the current bloom filter + pub fn check_nonce_and_set(&self, nonce: &[u8]) -> bool { + let mut ppbloom = self.nonce_ppbloom.lock(); + ppbloom.check_and_set(nonce) + } } /// `ServerState` wrapped in `Arc` @@ -68,14 +156,21 @@ pub struct Context { pub type SharedContext = Arc; impl Context { + /// Create a non-shared Context pub fn new(config: Config, server_state: SharedServerState) -> Context { Context { config, server_state } } + /// Create a shared Context, wrapped in `Arc` pub fn new_shared(config: Config, server_state: SharedServerState) -> SharedContext { SharedContext::new(Context::new(config, server_state)) } + /// Clone the internal `ServerState` + pub fn clone_server_state(&self) -> SharedServerState { + self.server_state.clone() + } + /// Config for TCP server pub fn config(&self) -> &Config { &self.config @@ -108,4 +203,11 @@ impl Context { pub fn check_forbidden_ip(&self, ip: &IpAddr) -> bool { self.config.check_forbidden_ip(ip) } + + /// Check if nonce exist or not + /// + /// If not, set into the current bloom filter + pub fn check_nonce_and_set(&self, nonce: &[u8]) -> bool { + self.server_state.check_nonce_and_set(nonce) + } } diff --git a/src/relay/tcprelay/client.rs b/src/relay/tcprelay/client.rs index 463680d2..97002df0 100644 --- a/src/relay/tcprelay/client.rs +++ b/src/relay/tcprelay/client.rs @@ -137,7 +137,7 @@ impl ServerClient { pub(crate) async fn connect(context: &Context, addr: &Address, svr_cfg: &ServerConfig) -> io::Result { let stream = super::connect_proxy_server(context, svr_cfg).await?; Ok(ServerClient { - stream: super::proxy_server_handshake(stream, svr_cfg, addr).await?, + stream: super::proxy_server_handshake(context, stream, svr_cfg, addr).await?, }) } } diff --git a/src/relay/tcprelay/crypto_io.rs b/src/relay/tcprelay/crypto_io.rs index 3079e289..76e4ce50 100644 --- a/src/relay/tcprelay/crypto_io.rs +++ b/src/relay/tcprelay/crypto_io.rs @@ -10,11 +10,12 @@ use std::{ use byte_string::ByteStr; use bytes::Bytes; use futures::ready; -use log::trace; +use log::{error, trace}; use tokio::prelude::*; use crate::{ config::ServerConfig, + context::{self, SharedServerState}, crypto::{CipherCategory, CipherType}, }; @@ -37,8 +38,8 @@ enum EncryptedWriter { enum ReadStatus { /// Waiting for initializing vector (or nonce for AEAD ciphers) /// - /// (Buffer, already_read_bytes, method, key) - WaitIv(Vec, usize, CipherType, Bytes), + /// (context, Buffer, already_read_bytes, method, key) + WaitIv(SharedServerState, Vec, usize, CipherType, Bytes), /// Connection is established, DecryptedReader is initialized Established, @@ -56,7 +57,7 @@ impl Unpin for CryptoStream {} impl CryptoStream { /// Create a new CryptoStream with the underlying stream connection - pub fn new(stream: S, svr_cfg: &ServerConfig) -> CryptoStream { + pub fn new(context: &context::Context, stream: S, svr_cfg: &ServerConfig) -> CryptoStream { let method = svr_cfg.method(); let prev_len = match method.category() { CipherCategory::Stream => method.iv_size(), @@ -65,12 +66,26 @@ impl CryptoStream { let iv = match method.category() { CipherCategory::Stream => { - let local_iv = method.gen_init_vec(); + let local_iv = loop { + let iv = method.gen_init_vec(); + if context.check_nonce_and_set(&iv) { + // IV exist, generate another one + continue; + } + break iv; + }; trace!("Generated Stream cipher IV {:?}", local_iv); local_iv } CipherCategory::Aead => { - let local_salt = method.gen_salt(); + let local_salt = loop { + let salt = method.gen_salt(); + if context.check_nonce_and_set(&salt) { + // Salt exist, generate another one + continue; + } + break salt; + }; trace!("Generated AEAD cipher salt {:?}", local_salt); local_salt } @@ -86,7 +101,13 @@ impl CryptoStream { stream, dec: None, enc, - read_status: ReadStatus::WaitIv(vec![0u8; prev_len], 0usize, method, svr_cfg.clone_key()), + read_status: ReadStatus::WaitIv( + context.clone_server_state(), + vec![0u8; prev_len], + 0usize, + method, + svr_cfg.clone_key(), + ), } } } @@ -96,7 +117,7 @@ where S: AsyncRead + Unpin, { fn poll_read_handshake(&mut self, cx: &mut Context<'_>) -> Poll> { - if let ReadStatus::WaitIv(ref mut buf, ref mut pos, method, ref key) = self.read_status { + if let ReadStatus::WaitIv(ref ctx, ref mut buf, ref mut pos, method, ref key) = self.read_status { while *pos < buf.len() { let n = ready!(Pin::new(&mut self.stream).poll_read(cx, &mut buf[*pos..]))?; if n == 0 { @@ -106,6 +127,16 @@ where *pos += n; } + // Got iv/salt, check if it is repeated + if ctx.check_nonce_and_set(buf) { + use std::io::{Error, ErrorKind}; + + error!("Detected repeated iv/salt {:?}", ByteStr::new(buf)); + + let err = Error::new(ErrorKind::Other, "detected repeated iv/salt"); + return Poll::Ready(Err(err)); + } + let dec = match method.category() { CipherCategory::Stream => { trace!("Got Stream cipher IV {:?}", ByteStr::new(&buf)); diff --git a/src/relay/tcprelay/http_local.rs b/src/relay/tcprelay/http_local.rs index 41fd900c..fa294bc2 100644 --- a/src/relay/tcprelay/http_local.rs +++ b/src/relay/tcprelay/http_local.rs @@ -75,7 +75,7 @@ impl tower::Service
for ShadowSocksConnector { ShadowSocksConnecting { fut: async move { let stream = super::connect_proxy_server(&*context, &*svr_cfg).await?; - super::proxy_server_handshake(stream, &*svr_cfg, &addr).await + super::proxy_server_handshake(&*context, stream, &*svr_cfg, &addr).await } .boxed(), } @@ -108,7 +108,7 @@ impl tower::Service for ShadowSocksConnector { } Some(addr) => { let stream = super::connect_proxy_server(&*context, &*svr_cfg).await?; - super::proxy_server_handshake(stream, &*svr_cfg, &addr).await + super::proxy_server_handshake(&*context, stream, &*svr_cfg, &addr).await } } } @@ -278,7 +278,7 @@ async fn server_dispatch( let svr_cfg = svr_score.server_config(); let stream = super::connect_proxy_server(&*context, svr_cfg).await?; - super::proxy_server_handshake(stream, svr_cfg, &host).await? + super::proxy_server_handshake(&*context, stream, svr_cfg, &host).await? }; debug!( diff --git a/src/relay/tcprelay/mod.rs b/src/relay/tcprelay/mod.rs index a9c27ad8..80e03c66 100644 --- a/src/relay/tcprelay/mod.rs +++ b/src/relay/tcprelay/mod.rs @@ -13,12 +13,6 @@ use std::{ time::Duration, }; -use crate::{ - config::{ConfigType, ServerAddr, ServerConfig}, - context::Context, - relay::{socks5::Address, utils::try_timeout}, -}; - use bytes::BytesMut; use futures::{future::FusedFuture, ready, select, Future}; use log::{debug, error, trace}; @@ -29,6 +23,12 @@ use tokio::{ time::{self, Delay}, }; +use crate::{ + config::{ConfigType, ServerAddr, ServerConfig}, + context::Context, + relay::{socks5::Address, utils::try_timeout}, +}; + mod aead; pub mod client; mod crypto_io; @@ -277,11 +277,12 @@ async fn connect_proxy_server(context: &Context, svr_cfg: &ServerConfig) -> io:: /// Handshake logic for ShadowSocks Client pub async fn proxy_server_handshake( + context: &Context, remote_stream: STcpStream, svr_cfg: &ServerConfig, relay_addr: &Address, ) -> io::Result> { - let mut stream = CryptoStream::new(remote_stream, svr_cfg); + let mut stream = CryptoStream::new(context, remote_stream, svr_cfg); trace!("Got encrypt stream and going to send addr: {:?}", relay_addr); diff --git a/src/relay/tcprelay/server.rs b/src/relay/tcprelay/server.rs index 283c0c7b..8d4753c0 100644 --- a/src/relay/tcprelay/server.rs +++ b/src/relay/tcprelay/server.rs @@ -32,7 +32,9 @@ async fn handle_client( error!("Failed to set keep alive: {:?}", err); } - if svr_context.context().config().no_delay { + let context = svr_context.context(); + + if context.config().no_delay { if let Err(err) = socket.set_nodelay(true) { error!("Failed to set no delay: {:?}", err); } @@ -51,7 +53,7 @@ async fn handle_client( // Do server-client handshake // Perform encryption IV exchange - let mut stream = CryptoStream::new(stream, svr_context.svr_cfg()); + let mut stream = CryptoStream::new(context, stream, svr_context.svr_cfg()); // Read remote Address let remote_addr = match Address::read_from(&mut stream).await { diff --git a/src/relay/tcprelay/socks5_local.rs b/src/relay/tcprelay/socks5_local.rs index ec163a62..70a118ed 100644 --- a/src/relay/tcprelay/socks5_local.rs +++ b/src/relay/tcprelay/socks5_local.rs @@ -81,7 +81,7 @@ async fn handle_socks5_connect<'a>( } }; - let mut svr_s = super::proxy_server_handshake(svr_s, svr_cfg, addr).await?; + let mut svr_s = super::proxy_server_handshake(context, svr_s, svr_cfg, addr).await?; let (mut svr_r, mut svr_w) = svr_s.split(); use tokio::io::copy; diff --git a/src/relay/tcprelay/tunnel_local.rs b/src/relay/tcprelay/tunnel_local.rs index 80afb9d4..4c644861 100644 --- a/src/relay/tcprelay/tunnel_local.rs +++ b/src/relay/tcprelay/tunnel_local.rs @@ -44,7 +44,7 @@ async fn establish_client_tcp_tunnel<'a>( } }; - let mut svr_s = super::proxy_server_handshake(svr_s, svr_cfg, addr).await?; + let mut svr_s = super::proxy_server_handshake(context, svr_s, svr_cfg, addr).await?; let (mut svr_r, mut svr_w) = svr_s.split(); let (mut r, mut w) = s.split(); diff --git a/src/relay/udprelay/client.rs b/src/relay/udprelay/client.rs index 0df2bec7..55973e4a 100644 --- a/src/relay/udprelay/client.rs +++ b/src/relay/udprelay/client.rs @@ -60,7 +60,7 @@ impl ServerClient { send_buf.extend_from_slice(payload); let mut encrypt_buf = BytesMut::new(); - encrypt_payload(self.method, &self.key, &send_buf, &mut encrypt_buf)?; + encrypt_payload(context, self.method, &self.key, &send_buf, &mut encrypt_buf)?; let send_len = match self.server_addr { ServerAddr::SocketAddr(ref remote_addr) => { @@ -86,7 +86,7 @@ impl ServerClient { let mut recv_buf = [0u8; MAXIMUM_UDP_PAYLOAD_SIZE]; let (recv_n, ..) = try_timeout(self.socket.recv_from(&mut recv_buf), Some(timeout)).await?; - let decrypt_buf = match decrypt_payload(self.method, &self.key, &recv_buf[..recv_n])? { + let decrypt_buf = match decrypt_payload(context, self.method, &self.key, &recv_buf[..recv_n])? { None => { error!("UDP packet too short, received length {}", recv_n); let err = io::Error::new(io::ErrorKind::InvalidData, "packet too short"); diff --git a/src/relay/udprelay/crypto_io.rs b/src/relay/udprelay/crypto_io.rs index 018001f4..a0ff0fa5 100644 --- a/src/relay/udprelay/crypto_io.rs +++ b/src/relay/udprelay/crypto_io.rs @@ -24,20 +24,41 @@ use std::{io, slice}; use byte_string::ByteStr; use bytes::{BufMut, BytesMut}; -use log::trace; +use log::{error, trace}; -use crate::crypto::{self, CipherCategory, CipherType, CryptoMode}; +use crate::{ + context::Context, + crypto::{self, CipherCategory, CipherType, CryptoMode}, +}; /// Encrypt payload into ShadowSocks UDP encrypted packet -pub fn encrypt_payload(t: CipherType, key: &[u8], payload: &[u8], dst: &mut BytesMut) -> io::Result<()> { +pub fn encrypt_payload( + context: &Context, + t: CipherType, + key: &[u8], + payload: &[u8], + dst: &mut BytesMut, +) -> io::Result<()> { match t.category() { - CipherCategory::Stream => encrypt_payload_stream(t, key, payload, dst), - CipherCategory::Aead => encrypt_payload_aead(t, key, payload, dst), + CipherCategory::Stream => encrypt_payload_stream(context, t, key, payload, dst), + CipherCategory::Aead => encrypt_payload_aead(context, t, key, payload, dst), } } -fn encrypt_payload_stream(t: CipherType, key: &[u8], payload: &[u8], dst: &mut BytesMut) -> io::Result<()> { - let iv = t.gen_init_vec(); +fn encrypt_payload_stream( + context: &Context, + t: CipherType, + key: &[u8], + payload: &[u8], + dst: &mut BytesMut, +) -> io::Result<()> { + let iv = loop { + let iv = t.gen_init_vec(); + if context.check_nonce_and_set(&iv) { + continue; + } + break iv; + }; let mut cipher = crypto::new_stream(t, key, &iv, CryptoMode::Encrypt); trace!("UDP packet generated stream iv {:?}", ByteStr::new(&iv)); @@ -54,8 +75,20 @@ fn encrypt_payload_stream(t: CipherType, key: &[u8], payload: &[u8], dst: &mut B Ok(()) } -fn encrypt_payload_aead(t: CipherType, key: &[u8], payload: &[u8], dst: &mut BytesMut) -> io::Result<()> { - let salt = t.gen_salt(); +fn encrypt_payload_aead( + context: &Context, + t: CipherType, + key: &[u8], + payload: &[u8], + dst: &mut BytesMut, +) -> io::Result<()> { + let salt = loop { + let salt = t.gen_salt(); + if context.check_nonce_and_set(&salt) { + continue; + } + break salt; + }; let tag_size = t.tag_size(); let mut cipher = crypto::new_aead_encryptor(t, key, &salt); @@ -79,20 +112,29 @@ fn encrypt_payload_aead(t: CipherType, key: &[u8], payload: &[u8], dst: &mut Byt } /// Decrypt payload from ShadowSocks UDP encrypted packet -pub fn decrypt_payload(t: CipherType, key: &[u8], payload: &[u8]) -> io::Result>> { +pub fn decrypt_payload(context: &Context, t: CipherType, key: &[u8], payload: &[u8]) -> io::Result>> { match t.category() { - CipherCategory::Stream => decrypt_payload_stream(t, key, payload), - CipherCategory::Aead => decrypt_payload_aead(t, key, payload), + CipherCategory::Stream => decrypt_payload_stream(context, t, key, payload), + CipherCategory::Aead => decrypt_payload_aead(context, t, key, payload), } } -fn decrypt_payload_stream(t: CipherType, key: &[u8], payload: &[u8]) -> io::Result>> { +fn decrypt_payload_stream(context: &Context, t: CipherType, key: &[u8], payload: &[u8]) -> io::Result>> { let iv_size = t.iv_size(); if payload.len() < iv_size { return Ok(None); } let iv = &payload[..iv_size]; + if context.check_nonce_and_set(iv) { + use std::io::{Error, ErrorKind}; + + error!("Detected repeated iv {:?}", ByteStr::new(iv)); + + let err = Error::new(ErrorKind::Other, "detected repeated iv"); + return Err(err); + } + let data = &payload[iv_size..]; trace!("UDP packet got stream IV {:?}", ByteStr::new(iv)); @@ -106,7 +148,7 @@ fn decrypt_payload_stream(t: CipherType, key: &[u8], payload: &[u8]) -> io::Resu Ok(Some(recv_payload)) } -fn decrypt_payload_aead(t: CipherType, key: &[u8], payload: &[u8]) -> io::Result>> { +fn decrypt_payload_aead(context: &Context, t: CipherType, key: &[u8], payload: &[u8]) -> io::Result>> { let tag_size = t.tag_size(); let salt_size = t.salt_size(); @@ -115,6 +157,15 @@ fn decrypt_payload_aead(t: CipherType, key: &[u8], payload: &[u8]) -> io::Result } let salt = &payload[..salt_size]; + if context.check_nonce_and_set(salt) { + use std::io::{Error, ErrorKind}; + + error!("Detected repeated salt {:?}", ByteStr::new(salt)); + + let err = Error::new(ErrorKind::Other, "detected repeated salt"); + return Err(err); + } + let data = &payload[salt_size..]; trace!("UDP packet got AEAD salt {:?}", ByteStr::new(salt)); diff --git a/src/relay/udprelay/server.rs b/src/relay/udprelay/server.rs index ff17729f..1b445854 100644 --- a/src/relay/udprelay/server.rs +++ b/src/relay/udprelay/server.rs @@ -84,11 +84,12 @@ impl UdpAssociation { // local -> remote let c_svr_cfg = svr_cfg.clone(); + let c_context = context.clone(); tokio::spawn(async move { while let Some(pkt) = rx.recv().await { // pkt is already a raw packet, so just send it if let Err(err) = - UdpAssociation::relay_l2r(&*context, src_addr, &mut sender, &pkt[..], timeout, &*c_svr_cfg).await + UdpAssociation::relay_l2r(&*c_context, src_addr, &mut sender, &pkt[..], timeout, &*c_svr_cfg).await { error!("Failed to relay packet, {} -> ..., error: {}", src_addr, err); @@ -104,7 +105,9 @@ impl UdpAssociation { let transfer_fut = async move { loop { // Read and send back to source - match UdpAssociation::relay_r2l(src_addr, &mut receiver, &mut response_tx, &*svr_cfg).await { + match UdpAssociation::relay_r2l(&*context, src_addr, &mut receiver, &mut response_tx, &*svr_cfg) + .await + { Ok(..) => {} Err(err) => { error!("Failed to receive packet, {} <- .., error: {}", src_addr, err); @@ -138,7 +141,7 @@ impl UdpAssociation { svr_cfg: &ServerConfig, ) -> io::Result<()> { // First of all, decrypt payload CLIENT -> SERVER - let decrypted_pkt = match decrypt_payload(svr_cfg.method(), svr_cfg.key(), pkt) { + let decrypted_pkt = match decrypt_payload(context, svr_cfg.method(), svr_cfg.key(), pkt) { Ok(Some(pkt)) => pkt, Ok(None) => { error!("Failed to decrypt pkt in UDP relay, packet too short"); @@ -207,6 +210,7 @@ impl UdpAssociation { /// Relay packets from remote to local async fn relay_r2l( + context: &Context, src_addr: SocketAddr, remote_udp: &mut RecvHalf, response_tx: &mut mpsc::Sender<(SocketAddr, BytesMut)>, @@ -231,7 +235,7 @@ impl UdpAssociation { send_buf.extend_from_slice(&remote_buf[..remote_recv_len]); let mut encrypt_buf = BytesMut::new(); - encrypt_payload(svr_cfg.method(), svr_cfg.key(), &send_buf, &mut encrypt_buf)?; + encrypt_payload(context, svr_cfg.method(), svr_cfg.key(), &send_buf, &mut encrypt_buf)?; // Send back to src_addr if let Err(err) = response_tx.send((src_addr, encrypt_buf)).await { diff --git a/src/relay/udprelay/socks5_local.rs b/src/relay/udprelay/socks5_local.rs index 2b7d4db7..eb58c6e6 100644 --- a/src/relay/udprelay/socks5_local.rs +++ b/src/relay/udprelay/socks5_local.rs @@ -103,13 +103,14 @@ impl UdpAssociation { // local -> remote let c_svr_cfg = svr_cfg.clone(); + let c_context = context.clone(); tokio::spawn(async move { let svr_cfg = c_svr_cfg.server_config(); while let Some(pkt) = rx.recv().await { // pkt is already a raw packet, so just send it if let Err(err) = - UdpAssociation::relay_l2r(&*context, src_addr, &mut sender, &pkt[..], timeout, svr_cfg).await + UdpAssociation::relay_l2r(&*c_context, src_addr, &mut sender, &pkt[..], timeout, svr_cfg).await { error!("Failed to send packet {} -> ..., error: {}", src_addr, err); @@ -127,7 +128,8 @@ impl UdpAssociation { loop { // Read and send back to source - match UdpAssociation::relay_r2l(src_addr, &mut receiver, &mut response_tx, svr_cfg).await { + match UdpAssociation::relay_r2l(&*context, src_addr, &mut receiver, &mut response_tx, svr_cfg).await + { Ok(..) => {} Err(err) => { error!("Failed to receive packet, {} <- .., error: {}", src_addr, err); @@ -175,7 +177,7 @@ impl UdpAssociation { send_buf.extend_from_slice(&payload); let mut encrypt_buf = BytesMut::new(); - encrypt_payload(svr_cfg.method(), svr_cfg.key(), &send_buf, &mut encrypt_buf)?; + encrypt_payload(context, svr_cfg.method(), svr_cfg.key(), &send_buf, &mut encrypt_buf)?; let send_len = match svr_cfg.addr() { ServerAddr::SocketAddr(ref remote_addr) => { @@ -194,6 +196,7 @@ impl UdpAssociation { /// Relay packets from remote to local async fn relay_r2l( + context: &Context, src_addr: SocketAddr, remote_udp: &mut RecvHalf, response_tx: &mut mpsc::Sender<(SocketAddr, Vec)>, @@ -204,7 +207,7 @@ impl UdpAssociation { let mut recv_buf = [0u8; MAXIMUM_UDP_PAYLOAD_SIZE]; let (recv_n, remote_addr) = remote_udp.recv_from(&mut recv_buf).await?; - let decrypt_buf = match decrypt_payload(svr_cfg.method(), svr_cfg.key(), &recv_buf[..recv_n])? { + let decrypt_buf = match decrypt_payload(context, svr_cfg.method(), svr_cfg.key(), &recv_buf[..recv_n])? { None => { error!("UDP packet too short, received length {}", recv_n); let err = io::Error::new(io::ErrorKind::InvalidData, "packet too short"); diff --git a/src/relay/udprelay/tunnel_local.rs b/src/relay/udprelay/tunnel_local.rs index ebeedeb3..e7209808 100644 --- a/src/relay/udprelay/tunnel_local.rs +++ b/src/relay/udprelay/tunnel_local.rs @@ -83,13 +83,14 @@ impl UdpAssociation { // local -> remote let c_svr_cfg = svr_cfg.clone(); + let c_context = context.clone(); tokio::spawn(async move { let svr_cfg = c_svr_cfg.server_config(); while let Some(pkt) = rx.recv().await { // pkt is already a raw packet, so just send it if let Err(err) = - UdpAssociation::relay_l2r(&*context, src_addr, &mut sender, &pkt[..], timeout, svr_cfg).await + UdpAssociation::relay_l2r(&*c_context, src_addr, &mut sender, &pkt[..], timeout, svr_cfg).await { error!("failed to send packet {} -> ..., error: {}", src_addr, err); @@ -107,7 +108,8 @@ impl UdpAssociation { let transfer_fut = async move { loop { // Read and send back to source - match UdpAssociation::relay_r2l(src_addr, &mut receiver, &mut response_tx, svr_cfg).await { + match UdpAssociation::relay_r2l(&*context, src_addr, &mut receiver, &mut response_tx, svr_cfg).await + { Ok(..) => {} Err(err) => { error!("failed to receive packet, {} <- .., error: {}", src_addr, err); @@ -150,7 +152,7 @@ impl UdpAssociation { send_buf.extend_from_slice(payload); let mut encrypt_buf = BytesMut::new(); - encrypt_payload(svr_cfg.method(), svr_cfg.key(), &send_buf, &mut encrypt_buf)?; + encrypt_payload(context, svr_cfg.method(), svr_cfg.key(), &send_buf, &mut encrypt_buf)?; let send_len = match svr_cfg.addr() { ServerAddr::SocketAddr(ref remote_addr) => { @@ -169,6 +171,7 @@ impl UdpAssociation { /// Relay packets from remote to local async fn relay_r2l( + context: &Context, src_addr: SocketAddr, remote_udp: &mut RecvHalf, response_tx: &mut mpsc::Sender<(SocketAddr, Vec)>, @@ -180,7 +183,7 @@ impl UdpAssociation { let (recv_n, remote_addr) = remote_udp.recv_from(&mut recv_buf).await?; - let decrypt_buf = match decrypt_payload(svr_cfg.method(), svr_cfg.key(), &recv_buf[..recv_n])? { + let decrypt_buf = match decrypt_payload(context, svr_cfg.method(), svr_cfg.key(), &recv_buf[..recv_n])? { None => { error!("UDP packet too short, received length {}", recv_n); let err = io::Error::new(io::ErrorKind::InvalidData, "packet too short");