use std::collections::HashMap;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use crate::bittorrent::extension::mse_crypto::MseCryptoState;
use crate::bittorrent::extension::mse_handshake::{
MSE_MAX_INCOMING_HANDSHAKE_LENGTH, MSE_PUBLIC_KEY_LENGTH, MseHandshake,
};
use crate::bittorrent::message::handshake::Handshake;
const HANDSHAKE_LENGTH: usize = 68;
pub const DEFAULT_INCOMING_HANDSHAKE_READ_TIMEOUT: std::time::Duration =
std::time::Duration::from_secs(30);
#[derive(Debug, Clone, Copy)]
pub struct IncomingHandshakeOptions {
pub read_timeout: std::time::Duration,
}
impl Default for IncomingHandshakeOptions {
fn default() -> Self {
Self {
read_timeout: DEFAULT_INCOMING_HANDSHAKE_READ_TIMEOUT,
}
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct IncomingCryptoPolicy {
pub reject_plain: bool,
pub force_encryption: bool,
pub prefer_encryption: bool,
}
pub enum IncomingHandshake {
Plain {
stream: TcpStream,
handshake: Handshake,
},
Mse {
stream: TcpStream,
handshake: Handshake,
crypto: Box<MseCryptoState>,
},
}
impl IncomingHandshake {
pub fn info_hash(&self) -> &[u8; 20] {
match self {
Self::Plain { handshake, .. } | Self::Mse { handshake, .. } => &handshake.info_hash,
}
}
pub async fn complete(
self,
local_peer_id: [u8; 20],
info_hash_v2: Option<[u8; 32]>,
dht_enabled: bool,
) -> Result<crate::bittorrent::peer::connection::PeerConnection, String> {
match self {
Self::Plain {
mut stream,
handshake,
} => {
let response_hash = info_hash_v2
.filter(|_| handshake.supports_bep52())
.map(|hash| hash[..20].try_into().expect("SHA-256 hash is 32 bytes"))
.unwrap_or(handshake.info_hash);
stream
.write_all(
&Handshake::new(&response_hash, &local_peer_id)
.with_dht(dht_enabled)
.with_bep52(info_hash_v2.is_some())
.to_bytes(),
)
.await
.map_err(|error| format!("Failed to send handshake response: {error}"))?;
Ok(
crate::bittorrent::peer::connection::PeerConnection::from_stream_with_peer_capabilities(
stream,
handshake.peer_id,
handshake.supports_dht(),
handshake.supports_fast_extension(),
handshake.supports_extended_messaging(),
),
)
}
Self::Mse {
mut stream,
handshake,
mut crypto,
} => {
let response_hash = info_hash_v2
.filter(|_| handshake.supports_bep52())
.map(|hash| hash[..20].try_into().expect("SHA-256 hash is 32 bytes"))
.unwrap_or(handshake.info_hash);
let mut response = Handshake::new(&response_hash, &local_peer_id)
.with_dht(dht_enabled)
.with_bep52(info_hash_v2.is_some())
.to_bytes();
crypto.encrypt(&mut response);
stream
.write_all(&response)
.await
.map_err(|error| format!("Failed to send MSE handshake response: {error}"))?;
Ok(
crate::bittorrent::peer::connection::PeerConnection::from_stream_with_mse(
stream,
*crypto,
Vec::new(),
handshake.peer_id,
handshake.supports_dht(),
handshake.supports_fast_extension(),
handshake.supports_extended_messaging(),
),
)
}
}
}
}
pub async fn receive(
stream: TcpStream,
known_info_hashes: &[[u8; 20]],
) -> Result<IncomingHandshake, String> {
receive_with_options(
stream,
known_info_hashes,
&HashMap::new(),
IncomingHandshakeOptions::default(),
)
.await
}
pub async fn receive_with_policies(
stream: TcpStream,
known_info_hashes: &[[u8; 20]],
policies: &HashMap<[u8; 20], IncomingCryptoPolicy>,
) -> Result<IncomingHandshake, String> {
receive_with_options(
stream,
known_info_hashes,
policies,
IncomingHandshakeOptions::default(),
)
.await
}
pub async fn receive_with_options(
mut stream: TcpStream,
known_info_hashes: &[[u8; 20]],
policies: &HashMap<[u8; 20], IncomingCryptoPolicy>,
options: IncomingHandshakeOptions,
) -> Result<IncomingHandshake, String> {
let mut prefix = [0u8; 20];
read_exact(&mut stream, &mut prefix, options.read_timeout).await?;
if prefix[0] == 19 && &prefix[1..20] == b"BitTorrent protocol" {
let mut bytes = [0u8; HANDSHAKE_LENGTH];
bytes[..20].copy_from_slice(&prefix);
read_exact(&mut stream, &mut bytes[20..], options.read_timeout).await?;
let handshake = Handshake::parse(&bytes)?;
if policies
.get(&handshake.info_hash)
.is_some_and(|policy| policy.reject_plain)
{
return Err("The legacy BitTorrent handshake is disabled by policy".to_string());
}
return Ok(IncomingHandshake::Plain { stream, handshake });
}
let mut responder = MseHandshake::new_responder([0u8; 20]);
let mut public_key = vec![0u8; MSE_PUBLIC_KEY_LENGTH];
public_key[..20].copy_from_slice(&prefix);
read_exact(&mut stream, &mut public_key[20..], options.read_timeout).await?;
responder.receive_step1(&public_key)?;
stream
.write_all(&responder.build_step1())
.await
.map_err(|error| format!("Failed to send MSE public key: {error}"))?;
let mut step2 = Vec::with_capacity(MSE_MAX_INCOMING_HANDSHAKE_LENGTH);
let info_hash = loop {
if let Some(info_hash) = responder.receiver_info_hash(&step2, known_info_hashes)? {
responder.set_info_hash(info_hash)?;
break info_hash;
}
if step2.len() >= MSE_MAX_INCOMING_HANDSHAKE_LENGTH {
return Err(format!(
"MSE handshake exceeded receiver buffer limit; prefix={:02x?}",
&step2[..step2.len().min(48)]
));
}
let mut byte = [0u8; 1];
read_exact(&mut stream, &mut byte, options.read_timeout).await?;
step2.push(byte[0]);
};
let required = loop {
if let Some(required) = responder.receiver_step2_required_len(&step2)? {
break required;
}
if step2.len() >= MSE_MAX_INCOMING_HANDSHAKE_LENGTH {
return Err(format!(
"MSE handshake exceeded receiver buffer limit; prefix={:02x?}",
&step2[..step2.len().min(48)]
));
}
let mut byte = [0u8; 1];
read_exact(&mut stream, &mut byte, options.read_timeout).await?;
step2.push(byte[0]);
};
if required > MSE_MAX_INCOMING_HANDSHAKE_LENGTH {
return Err("MSE handshake IA exceeds receiver buffer limit".to_string());
}
while step2.len() < required {
let remaining = required - step2.len();
let chunk_len = remaining.min(64);
let mut chunk = vec![0u8; chunk_len];
read_exact(&mut stream, &mut chunk, options.read_timeout).await?;
step2.extend_from_slice(&chunk);
}
debug_assert_eq!(info_hash, *responder.info_hash());
let policy = policies.get(&info_hash).copied().unwrap_or_default();
responder.set_crypto_preferences(policy.force_encryption, policy.prefer_encryption);
responder.receive_initiator_step2(&step2, &[info_hash])?;
let initial_payload = responder.take_receiver_initial_payload();
let response = responder.build_receiver_step2()?;
stream
.write_all(&response)
.await
.map_err(|error| format!("Failed to send MSE response: {error}"))?;
let mut crypto = responder.finalize()?;
let mut handshake_bytes = [0u8; HANDSHAKE_LENGTH];
let initial_length = initial_payload.len();
handshake_bytes[..initial_length].copy_from_slice(&initial_payload);
read_exact(
&mut stream,
&mut handshake_bytes[initial_length..],
options.read_timeout,
)
.await?;
crypto.decrypt(&mut handshake_bytes[initial_length..]);
let handshake_data = handshake_bytes.to_vec();
let handshake = Handshake::parse(&handshake_data).map_err(|error| {
format!(
"{error}; decrypted handshake prefix={:02x?}",
&handshake_data[..8]
)
})?;
if handshake.info_hash != info_hash {
return Err("MSE BitTorrent handshake info_hash mismatch".to_string());
}
Ok(IncomingHandshake::Mse {
stream,
handshake,
crypto: Box::new(crypto),
})
}
async fn read_exact(
stream: &mut TcpStream,
buffer: &mut [u8],
read_timeout: std::time::Duration,
) -> Result<(), String> {
tokio::time::timeout(read_timeout, stream.read_exact(buffer))
.await
.map_err(|_| "Incoming handshake read timeout".to_string())?
.map(|_| ())
.map_err(|error| format!("Incoming handshake read failed: {error}"))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::bittorrent::message::types::BtMessage;
use std::net::SocketAddr;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
async fn run_incoming_server(
info_hash: [u8; 20],
policy: IncomingCryptoPolicy,
) -> (
SocketAddr,
tokio::task::JoinHandle<
Result<crate::bittorrent::peer::connection::PeerConnection, String>,
>,
) {
let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.map_err(|error| error.to_string())?;
let mut policies = HashMap::new();
policies.insert(info_hash, policy);
let incoming = receive_with_policies(stream, &[info_hash], &policies).await?;
incoming.complete([2u8; 20], None, false).await
});
(address, server)
}
#[tokio::test]
async fn configured_read_timeout_is_used_for_incoming_handshake() {
let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
receive_with_options(
stream,
&[],
&HashMap::new(),
IncomingHandshakeOptions {
read_timeout: std::time::Duration::from_millis(20),
},
)
.await
});
let mut client = TcpStream::connect(address).await.unwrap();
client.write_all(b"x").await.unwrap();
let error = server.await.unwrap().err().unwrap();
assert!(error.contains("Incoming handshake read timeout"));
}
#[tokio::test]
async fn mse_rc4_socket_handshake_preserves_post_handshake_cipher_state() {
let info_hash = [0x31u8; 20];
let (address, server) = run_incoming_server(
info_hash,
IncomingCryptoPolicy {
reject_plain: true,
force_encryption: true,
prefer_encryption: true,
},
)
.await;
let stream = TcpStream::connect(address).await.unwrap();
let client_result = crate::bittorrent::peer::mse::connect_with_stream(
stream,
&info_hash,
None,
crate::bittorrent::peer::mse::MseConnectionOptions {
force_encryption: true,
prefer_encryption: true,
local_peer_id: [0x41; 20],
timeout: std::time::Duration::from_secs(2),
dht_enabled: false,
},
)
.await;
let mut client = match client_result {
Ok(client) => client,
Err(error) => {
let server_result = server.await.unwrap();
let server_error = match server_result {
Ok(_) => "ok".to_owned(),
Err(server_error) => server_error,
};
panic!("client: {error}; server: {server_error}");
}
};
assert!(client.is_encrypted());
client.send_message(&BtMessage::KeepAlive).await.unwrap();
let mut server_connection = server.await.unwrap().unwrap();
assert!(server_connection.is_mse_negotiated());
assert_eq!(
server_connection.read_message().await.unwrap(),
Some(BtMessage::KeepAlive)
);
server_connection
.send_message(&BtMessage::Choke)
.await
.unwrap();
assert_eq!(client.read_message().await.unwrap(), Some(BtMessage::Choke));
}
#[tokio::test]
async fn plain_incoming_handshake_preserves_dht_capabilities() {
let info_hash = [0x34u8; 20];
let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
let incoming = receive(stream, &[info_hash]).await.unwrap();
incoming.complete([2u8; 20], None, true).await.unwrap()
});
let mut client = TcpStream::connect(address).await.unwrap();
client
.write_all(
&Handshake::new(&info_hash, &[3u8; 20])
.with_dht(true)
.to_bytes(),
)
.await
.unwrap();
let mut response = [0u8; 68];
client.read_exact(&mut response).await.unwrap();
assert!(Handshake::parse(&response).unwrap().supports_dht());
let connection = server.await.unwrap();
assert!(connection.remote_supports_dht());
assert!(connection.remote_supports_fast_extension());
assert!(connection.remote_supports_extended_messaging());
}
#[tokio::test]
async fn mse_plain_socket_handshake_keeps_aria2_fallback() {
let info_hash = [0x32u8; 20];
let (address, server) =
run_incoming_server(info_hash, IncomingCryptoPolicy::default()).await;
let stream = TcpStream::connect(address).await.unwrap();
let client = crate::bittorrent::peer::mse::connect_with_stream(
stream,
&info_hash,
None,
crate::bittorrent::peer::mse::MseConnectionOptions {
force_encryption: false,
prefer_encryption: false,
local_peer_id: [0x42; 20],
timeout: std::time::Duration::from_secs(2),
dht_enabled: false,
},
)
.await
.unwrap();
assert!(!client.is_encrypted());
let server_connection = server.await.unwrap().unwrap();
assert!(server_connection.is_mse_negotiated());
assert!(!server_connection.is_encrypted());
assert!(server_connection.remote_supports_extended_messaging());
}
#[tokio::test]
async fn legacy_plain_handshake_is_rejected_by_policy() {
let info_hash = [0x33u8; 20];
let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
let mut policies = HashMap::new();
policies.insert(
info_hash,
IncomingCryptoPolicy {
reject_plain: true,
..IncomingCryptoPolicy::default()
},
);
receive_with_policies(stream, &[info_hash], &policies).await
});
let mut client = TcpStream::connect(address).await.unwrap();
client
.write_all(&Handshake::new(&info_hash, &[9u8; 20]).to_bytes())
.await
.unwrap();
let result = server.await.unwrap();
assert!(result.is_err());
}
#[tokio::test]
async fn mse_hybrid_handshake_upgrades_to_v2_hash() {
let v1 = [0x41u8; 20];
let v2 = [0x42u8; 32];
let listener = TcpListener::bind(("127.0.0.1", 0)).await.unwrap();
let address = listener.local_addr().unwrap();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.unwrap();
let mut policies = HashMap::new();
policies.insert(
v1,
IncomingCryptoPolicy {
reject_plain: true,
force_encryption: true,
prefer_encryption: true,
},
);
let incoming = receive_with_policies(stream, &[v1], &policies).await?;
incoming.complete([0x44; 20], Some(v2), false).await
});
let stream = TcpStream::connect(address).await.unwrap();
let connection = crate::bittorrent::peer::mse::connect_with_stream(
stream,
&v1,
Some(&v2),
crate::bittorrent::peer::mse::MseConnectionOptions {
force_encryption: true,
prefer_encryption: true,
local_peer_id: [0x43; 20],
timeout: std::time::Duration::from_secs(2),
dht_enabled: false,
},
)
.await
.unwrap();
assert!(connection.is_encrypted());
let server_connection = server.await.unwrap().unwrap();
assert_eq!(server_connection.remote_peer_id(), Some(&[0x43; 20]));
}
}