mirror of
https://github.com/shadowsocks/shadowsocks-rust.git
synced 2026-11-20 00:06:23 +00:00
Detect repeated iv/salt for defending from reply attacks
This commit is contained in:
@@ -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
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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?,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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!(
|
||||
|
||||
@@ -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);
|
||||
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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");
|
||||
|
||||
@@ -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");
|
||||
|
||||
Reference in New Issue
Block a user