Detect repeated iv/salt for defending from reply attacks

This commit is contained in:
zonyitoo
2020-01-11 21:49:51 +08:00
parent aa71a72e48
commit d8a7f8f5bc
14 changed files with 253 additions and 53 deletions
+3
View File
@@ -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"] }
+104 -2
View File
@@ -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<PingPongBloom>,
}
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<Context>;
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)
}
}
+1 -1
View File
@@ -137,7 +137,7 @@ impl ServerClient {
pub(crate) async fn connect(context: &Context, addr: &Address, svr_cfg: &ServerConfig) -> io::Result<ServerClient> {
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?,
})
}
}
+39 -8
View File
@@ -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<u8>, usize, CipherType, Bytes),
/// (context, Buffer, already_read_bytes, method, key)
WaitIv(SharedServerState, Vec<u8>, usize, CipherType, Bytes),
/// Connection is established, DecryptedReader is initialized
Established,
@@ -56,7 +57,7 @@ impl<S: Unpin> Unpin for CryptoStream<S> {}
impl<S> CryptoStream<S> {
/// Create a new CryptoStream with the underlying stream connection
pub fn new(stream: S, svr_cfg: &ServerConfig) -> CryptoStream<S> {
pub fn new(context: &context::Context, stream: S, svr_cfg: &ServerConfig) -> CryptoStream<S> {
let method = svr_cfg.method();
let prev_len = match method.category() {
CipherCategory::Stream => method.iv_size(),
@@ -65,12 +66,26 @@ impl<S> CryptoStream<S> {
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<S> CryptoStream<S> {
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<io::Result<()>> {
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));
+3 -3
View File
@@ -75,7 +75,7 @@ impl tower::Service<Address> 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<Uri> 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!(
+8 -7
View File
@@ -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<CryptoStream<STcpStream>> {
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);
+4 -2
View File
@@ -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 {
+1 -1
View File
@@ -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;
+1 -1
View File
@@ -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();
+2 -2
View File
@@ -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");
+65 -14
View File
@@ -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<Option<Vec<u8>>> {
pub fn decrypt_payload(context: &Context, t: CipherType, key: &[u8], payload: &[u8]) -> io::Result<Option<Vec<u8>>> {
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<Option<Vec<u8>>> {
fn decrypt_payload_stream(context: &Context, t: CipherType, key: &[u8], payload: &[u8]) -> io::Result<Option<Vec<u8>>> {
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<Option<Vec<u8>>> {
fn decrypt_payload_aead(context: &Context, t: CipherType, key: &[u8], payload: &[u8]) -> io::Result<Option<Vec<u8>>> {
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));
+8 -4
View File
@@ -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 {
+7 -4
View File
@@ -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<u8>)>,
@@ -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");
+7 -4
View File
@@ -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<u8>)>,
@@ -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");