use super::mse_crypto::{
MseCryptoMethod, MseCryptoState, MseDerivedKeys, Rc4State, compute_vc, init_rc4,
};
use super::mse_dh::{
CRYPTO_BITFIELD_LENGTH, INFO_HASH_LENGTH, KEY_LENGTH, MAX_PAD_LENGTH, MseDhKeyExchange,
SHA1_LENGTH, VC_LENGTH,
};
use rand::Rng;
const INITIATOR_SYNC_LIMIT: usize = 616;
const RECEIVER_SYNC_LIMIT: usize = 628;
#[derive(Debug, Clone, PartialEq)]
pub enum MseHandshakePhase {
Idle,
PublicKeySent,
PublicKeyReceived,
InitiatorStep2Sent,
Completed(MseCryptoMethod),
Failed(String),
}
pub struct MseHandshake {
phase: MseHandshakePhase,
dh: MseDhKeyExchange,
initiator: bool,
info_hash: [u8; INFO_HASH_LENGTH],
shared_secret: Option<[u8; KEY_LENGTH]>,
keys: Option<MseDerivedKeys>,
negotiated_method: MseCryptoMethod,
force_encryption: bool,
prefer_encryption: bool,
initiator_vc_marker: Option<[u8; VC_LENGTH]>,
initiator_encryptor: Option<Rc4State>,
initiator_decryptor: Option<Rc4State>,
}
impl MseHandshake {
pub fn new_initiator(info_hash: [u8; INFO_HASH_LENGTH]) -> Self {
MseHandshake {
phase: MseHandshakePhase::Idle,
dh: MseDhKeyExchange::new(),
initiator: true,
info_hash,
shared_secret: None,
keys: None,
negotiated_method: MseCryptoMethod::Plain,
force_encryption: false,
prefer_encryption: true,
initiator_vc_marker: None,
initiator_encryptor: None,
initiator_decryptor: None,
}
}
pub fn new_responder(info_hash: [u8; INFO_HASH_LENGTH]) -> Self {
MseHandshake {
phase: MseHandshakePhase::Idle,
dh: MseDhKeyExchange::new(),
initiator: false,
info_hash,
shared_secret: None,
keys: None,
negotiated_method: MseCryptoMethod::Plain,
force_encryption: false,
prefer_encryption: true,
initiator_vc_marker: None,
initiator_encryptor: None,
initiator_decryptor: None,
}
}
pub fn set_crypto_preferences(&mut self, force_encryption: bool, prefer_encryption: bool) {
self.force_encryption = force_encryption;
self.prefer_encryption = prefer_encryption;
}
pub fn phase(&self) -> &MseHandshakePhase {
&self.phase
}
pub fn info_hash(&self) -> &[u8; INFO_HASH_LENGTH] {
&self.info_hash
}
pub fn negotiated_method(&self) -> MseCryptoMethod {
self.negotiated_method
}
pub fn build_step1(&self) -> Vec<u8> {
let mut rng = rand::thread_rng();
let pad_length: usize = rng.gen_range(0..=MAX_PAD_LENGTH);
let mut buf = Vec::with_capacity(KEY_LENGTH + pad_length);
buf.extend_from_slice(&self.dh.generate_public_key());
let mut pad = vec![0u8; pad_length];
rng.fill(&mut pad[..]);
buf.extend_from_slice(&pad);
buf
}
pub fn receive_step1(&mut self, data: &[u8]) -> Result<(), String> {
if data.len() < KEY_LENGTH {
return Err(format!(
"Step1 data too short: got {} bytes, need at least {}",
data.len(),
KEY_LENGTH
));
}
let mut remote_public = [0u8; KEY_LENGTH];
remote_public.copy_from_slice(&data[..KEY_LENGTH]);
let shared = self.dh.compute_shared_secret(&remote_public);
self.shared_secret = Some(shared);
let keys = MseDerivedKeys::derive(&shared, &self.info_hash);
self.keys = Some(keys);
if self.initiator {
let keys = self.keys.as_ref().expect("keys just set");
self.initiator_encryptor = Some(init_rc4(&keys.key_a));
let mut peer_cipher = init_rc4(&keys.key_b);
let vc_marker = compute_vc(&mut peer_cipher);
self.initiator_vc_marker = Some(vc_marker);
self.initiator_decryptor = Some(peer_cipher);
}
self.phase = MseHandshakePhase::PublicKeyReceived;
Ok(())
}
pub fn build_initiator_step2(&mut self) -> Result<Vec<u8>, String> {
if !self.initiator {
return Err("Only initiator can build step 3".to_string());
}
let keys = self.keys.as_ref().ok_or("Keys not derived yet")?;
let mut buf = Vec::new();
buf.extend_from_slice(&keys.req1);
buf.extend_from_slice(&keys.req2_xor_req3());
let mut rng = rand::thread_rng();
let pad_c_length: u16 = rng.gen_range(0..=MAX_PAD_LENGTH as u16);
let ia_length: u16 = 0;
let mut encrypted =
Vec::with_capacity(VC_LENGTH + CRYPTO_BITFIELD_LENGTH + 2 + pad_c_length as usize + 2);
encrypted.extend_from_slice(&[0u8; VC_LENGTH]);
let mut crypto_provide: u32 = 0;
if !self.force_encryption && self.prefer_encryption {
crypto_provide |= MseCryptoMethod::Plain.as_u32();
}
crypto_provide |= MseCryptoMethod::Rc4.as_u32();
encrypted.extend_from_slice(&crypto_provide.to_be_bytes());
encrypted.extend_from_slice(&pad_c_length.to_be_bytes());
let mut pad_c = vec![0u8; pad_c_length as usize];
rng.fill(&mut pad_c[..]);
encrypted.extend_from_slice(&pad_c);
encrypted.extend_from_slice(&ia_length.to_be_bytes());
if let Some(ref mut cipher) = self.initiator_encryptor {
cipher.process(&mut encrypted);
} else {
return Err("Initiator encryptor not initialized".to_string());
}
buf.extend_from_slice(&encrypted);
self.phase = MseHandshakePhase::InitiatorStep2Sent;
Ok(buf)
}
pub fn receive_initiator_step2(
&mut self,
data: &[u8],
known_info_hashes: &[[u8; INFO_HASH_LENGTH]],
) -> Result<MseCryptoMethod, String> {
if self.initiator {
return Err("Only receiver can process initiator step 3".to_string());
}
if data.len() < SHA1_LENGTH + SHA1_LENGTH + VC_LENGTH + CRYPTO_BITFIELD_LENGTH + 2 {
return Err(format!(
"Initiator step3 data too short: {} bytes",
data.len()
));
}
let keys = self.keys.as_ref().ok_or("Keys not derived yet")?;
let req1_match = find_req1_marker(data, &keys.req1, RECEIVER_SYNC_LIMIT)?;
let req1_end = req1_match + SHA1_LENGTH;
let req2_xor_req3 = &data[req1_end..req1_end + SHA1_LENGTH];
let matched_info_hash = verify_req2_xor_req3(req2_xor_req3, known_info_hashes, &keys.req3);
let verified_info_hash = match matched_info_hash {
Some(hash) => hash,
None => {
let expected_xor = {
let mut expected = [0u8; SHA1_LENGTH];
for (expected, (&req2, &req3)) in expected
.iter_mut()
.zip(keys.req2.iter().zip(keys.req3.iter()))
{
*expected = req2 ^ req3;
}
expected
};
if req2_xor_req3 == expected_xor {
self.info_hash
} else {
return Err("Unknown info hash: req2^req3 verification failed".to_string());
}
}
};
if verified_info_hash != self.info_hash {
self.info_hash = verified_info_hash;
let shared = self.shared_secret.ok_or("Shared secret not computed")?;
let new_keys = MseDerivedKeys::derive(&shared, &verified_info_hash);
self.keys = Some(new_keys);
}
let keys = self.keys.as_ref().expect("keys just set");
let mut decryptor = init_rc4(&keys.key_a);
let encrypted_start = req1_end + SHA1_LENGTH;
let encrypted_data = &data[encrypted_start..];
if encrypted_data.len() < VC_LENGTH + CRYPTO_BITFIELD_LENGTH + 2 {
return Err("Encrypted payload too short".to_string());
}
let mut decrypted = encrypted_data.to_vec();
decryptor.process(&mut decrypted);
let vc = &decrypted[..VC_LENGTH];
if vc != [0u8; VC_LENGTH] {
return Err(format!(
"VC verification failed: expected zeros, got {:02X?}",
&vc[..8.min(vc.len())]
));
}
let crypto_provide =
u32::from_be_bytes([decrypted[8], decrypted[9], decrypted[10], decrypted[11]]);
if (crypto_provide & MseCryptoMethod::Rc4.as_u32()) != 0 {
self.negotiated_method = MseCryptoMethod::Rc4;
} else if (crypto_provide & MseCryptoMethod::Plain.as_u32()) != 0
&& !self.force_encryption
&& !self.prefer_encryption
{
self.negotiated_method = MseCryptoMethod::Plain;
} else {
return Err(format!(
"No supported crypto method in provide: {:#010X}",
crypto_provide
));
}
self.phase = MseHandshakePhase::Completed(self.negotiated_method);
Ok(self.negotiated_method)
}
pub fn build_receiver_step2(&mut self) -> Result<Vec<u8>, String> {
if self.initiator {
return Err("Only receiver can build step 4".to_string());
}
if !matches!(self.phase, MseHandshakePhase::Completed(_)) {
return Err("Handshake not completed yet".to_string());
}
let keys = self.keys.as_ref().ok_or("Keys not derived yet")?;
let mut rng = rand::thread_rng();
let pad_d_length: u16 = rng.gen_range(0..=MAX_PAD_LENGTH as u16);
let mut encrypted =
Vec::with_capacity(VC_LENGTH + CRYPTO_BITFIELD_LENGTH + 2 + pad_d_length as usize);
encrypted.extend_from_slice(&[0u8; VC_LENGTH]);
encrypted.extend_from_slice(&self.negotiated_method.as_u32().to_be_bytes());
encrypted.extend_from_slice(&pad_d_length.to_be_bytes());
let mut pad_d = vec![0u8; pad_d_length as usize];
rng.fill(&mut pad_d[..]);
encrypted.extend_from_slice(&pad_d);
let mut cipher = init_rc4(&keys.key_b);
cipher.process(&mut encrypted);
Ok(encrypted)
}
pub fn receive_receiver_step2(&mut self, data: &[u8]) -> Result<MseCryptoMethod, String> {
if !self.initiator {
return Err("Only initiator can process receiver step 4".to_string());
}
let vc_marker = self.initiator_vc_marker.ok_or("VC marker not computed")?;
let vc_pos = find_vc_marker(data, &vc_marker, INITIATOR_SYNC_LIMIT)?;
let encrypted_start = vc_pos + VC_LENGTH;
if data.len() < encrypted_start + CRYPTO_BITFIELD_LENGTH + 2 {
return Err(format!(
"Receiver step4 data too short after VC: {} bytes",
data.len() - encrypted_start
));
}
let mut remaining = data[encrypted_start..].to_vec();
if let Some(ref mut cipher) = self.initiator_decryptor {
cipher.process(&mut remaining);
} else {
return Err("Initiator decryptor not initialized".to_string());
}
let crypto_select =
u32::from_be_bytes([remaining[0], remaining[1], remaining[2], remaining[3]]);
if (crypto_select & MseCryptoMethod::Rc4.as_u32()) != 0 {
self.negotiated_method = MseCryptoMethod::Rc4;
} else if (crypto_select & MseCryptoMethod::Plain.as_u32()) != 0 && !self.force_encryption {
self.negotiated_method = MseCryptoMethod::Plain;
} else {
return Err(format!(
"No supported crypto method in select: {:#010X}",
crypto_select
));
}
if remaining.len() < CRYPTO_BITFIELD_LENGTH + 2 {
return Err("Not enough data for PadD length".to_string());
}
let _pad_d_length = u16::from_be_bytes([remaining[4], remaining[5]]);
if _pad_d_length as usize > MAX_PAD_LENGTH {
return Err(format!("PadD length too large: {}", _pad_d_length));
}
self.phase = MseHandshakePhase::Completed(self.negotiated_method);
Ok(self.negotiated_method)
}
pub fn finalize(self) -> Result<MseCryptoState, String> {
match self.phase {
MseHandshakePhase::Completed(method) => {
let keys = self.keys.ok_or("Keys not derived")?;
match method {
MseCryptoMethod::Plain => Ok(MseCryptoState::new_plain()),
MseCryptoMethod::Rc4 => {
Ok(MseCryptoState::new_encrypted(&keys, self.initiator))
}
}
}
MseHandshakePhase::Failed(e) => Err(e),
_ => Err(format!("Handshake not completed: {:?}", self.phase)),
}
}
pub fn should_negotiate(local_supports_mse: bool, remote_reserved: &[u8]) -> bool {
local_supports_mse && remote_reserved.len() >= 8 && (remote_reserved[7] & 0x01) != 0
}
pub fn identify_handshake_type(data: &[u8]) -> HandshakeType {
if data.len() < 20 {
return HandshakeType::NotYet;
}
if data[0] == 19 && &data[1..20] == b"BitTorrent protocol" {
return HandshakeType::Legacy;
}
HandshakeType::Encrypted
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HandshakeType {
NotYet,
Legacy,
Encrypted,
}
fn find_req1_marker(
data: &[u8],
req1_hash: &[u8; SHA1_LENGTH],
sync_limit: usize,
) -> Result<usize, String> {
if data.len() < SHA1_LENGTH {
return Err("Data too short for req1 marker search".to_string());
}
for i in 0..=(data.len().saturating_sub(SHA1_LENGTH)) {
if data[i..].starts_with(req1_hash) {
return Ok(i);
}
if i + SHA1_LENGTH > sync_limit {
return Err("Failed to find req1 hash marker within sync limit".to_string());
}
}
Err("Failed to find req1 hash marker".to_string())
}
fn find_vc_marker(
data: &[u8],
vc_marker: &[u8; VC_LENGTH],
sync_limit: usize,
) -> Result<usize, String> {
if data.len() < VC_LENGTH {
return Err("Data too short for VC marker search".to_string());
}
for i in 0..=(data.len().saturating_sub(VC_LENGTH)) {
if data[i..].starts_with(vc_marker) {
return Ok(i);
}
if i + VC_LENGTH > sync_limit - KEY_LENGTH {
return Err("Failed to find VC marker within sync limit".to_string());
}
}
Err("Failed to find VC marker".to_string())
}
fn verify_req2_xor_req3(
req2_xor_req3: &[u8],
known_info_hashes: &[[u8; INFO_HASH_LENGTH]],
req3: &[u8; SHA1_LENGTH],
) -> Option<[u8; INFO_HASH_LENGTH]> {
for info_hash in known_info_hashes {
let req2 = {
use sha1::{Digest, Sha1};
let mut hasher = Sha1::new();
hasher.update(b"req2");
hasher.update(info_hash);
let result = hasher.finalize();
let mut arr = [0u8; SHA1_LENGTH];
arr.copy_from_slice(&result);
arr
};
let mut expected = [0u8; SHA1_LENGTH];
for i in 0..SHA1_LENGTH {
expected[i] = req2[i] ^ req3[i];
}
if req2_xor_req3 == expected {
return Some(*info_hash);
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
fn test_info_hash() -> [u8; INFO_HASH_LENGTH] {
[
0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54,
0x32, 0x10, 0xAA, 0xBB, 0xCC, 0xDD,
]
}
#[test]
fn test_step1_payload_size() {
let h = MseHandshake::new_initiator(test_info_hash());
let s1 = h.build_step1();
assert!(s1.len() >= KEY_LENGTH);
assert!(s1.len() <= KEY_LENGTH + MAX_PAD_LENGTH);
}
#[test]
fn test_receive_step1_too_short() {
let mut h = MseHandshake::new_responder(test_info_hash());
let result = h.receive_step1(&[0u8; 16]);
assert!(result.is_err());
}
#[test]
fn test_receive_step1_computes_shared_secret() {
let initiator = MseHandshake::new_initiator(test_info_hash());
let step1 = initiator.build_step1();
let mut responder = MseHandshake::new_responder(test_info_hash());
responder.receive_step1(&step1).expect("receive step1");
assert!(responder.shared_secret.is_some());
assert!(responder.keys.is_some());
}
#[test]
fn test_full_handshake_rc4() {
let info_hash = test_info_hash();
let mut initiator = MseHandshake::new_initiator(info_hash);
let mut responder = MseHandshake::new_responder(info_hash);
let i_step1 = initiator.build_step1();
let r_step1 = responder.build_step1();
initiator
.receive_step1(&r_step1)
.expect("I receive R step1");
responder
.receive_step1(&i_step1)
.expect("R receive I step1");
let i_secret = initiator.shared_secret.expect("I secret");
let r_secret = responder.shared_secret.expect("R secret");
assert_eq!(i_secret, r_secret, "Shared secrets must match");
let i_step3 = initiator.build_initiator_step2().expect("I build step3");
let method_r = responder
.receive_initiator_step2(&i_step3, &[info_hash])
.expect("R receive step3");
assert_eq!(method_r, MseCryptoMethod::Rc4);
let r_step4 = responder.build_receiver_step2().expect("R build step4");
let method_i = initiator
.receive_receiver_step2(&r_step4)
.expect("I receive step4");
assert_eq!(method_i, MseCryptoMethod::Rc4);
let mut crypto_i = initiator.finalize().expect("I finalize");
let crypto_r = responder.finalize().expect("R finalize");
assert!(crypto_i.is_encrypted());
assert!(crypto_r.is_encrypted());
let original = b"Hello, BitTorrent MSE!";
let mut encrypted = original.to_vec();
crypto_i.encrypt(&mut encrypted);
let info_hash2 = test_info_hash();
let mut initiator2 = MseHandshake::new_initiator(info_hash2);
let mut responder2 = MseHandshake::new_responder(info_hash2);
let i2_step1 = initiator2.build_step1();
let r2_step1 = responder2.build_step1();
initiator2
.receive_step1(&r2_step1)
.expect("I2 receive R2 step1");
responder2
.receive_step1(&i2_step1)
.expect("R2 receive I2 step1");
let i2_step3 = initiator2.build_initiator_step2().expect("I2 build step3");
responder2
.receive_initiator_step2(&i2_step3, &[test_info_hash()])
.expect("R2 receive step3");
let r2_step4 = responder2.build_receiver_step2().expect("R2 build step4");
initiator2
.receive_receiver_step2(&r2_step4)
.expect("I2 receive step4");
let mut crypto_i2 = initiator2.finalize().expect("I2 finalize");
let mut crypto_r2 = responder2.finalize().expect("R2 finalize");
let original2 = b"Test encrypted data";
let mut enc2 = original2.to_vec();
crypto_i2.encrypt(&mut enc2);
assert_ne!(enc2, original2.to_vec());
crypto_r2.decrypt(&mut enc2);
assert_eq!(enc2, original2.to_vec());
}
#[test]
fn test_handshake_type_detection() {
let mut legacy = vec![19u8];
legacy.extend_from_slice(b"BitTorrent protocol");
assert_eq!(
MseHandshake::identify_handshake_type(&legacy),
HandshakeType::Legacy
);
let encrypted = [0u8; 20];
assert_eq!(
MseHandshake::identify_handshake_type(&encrypted),
HandshakeType::Encrypted
);
let short = [19u8; 10];
assert_eq!(
MseHandshake::identify_handshake_type(&short),
HandshakeType::NotYet
);
}
#[test]
fn test_should_negotiate() {
let reserved_all_zero = [0u8; 8];
let mut reserved_mse_set = [0u8; 8];
reserved_mse_set[7] = 0x01;
assert!(!MseHandshake::should_negotiate(true, &reserved_all_zero));
assert!(MseHandshake::should_negotiate(true, &reserved_mse_set));
assert!(!MseHandshake::should_negotiate(false, &reserved_mse_set));
assert!(!MseHandshake::should_negotiate(true, &[]));
}
#[test]
fn test_different_instances_different_keys() {
let h1 = MseHandshake::new_initiator(test_info_hash());
let h2 = MseHandshake::new_initiator(test_info_hash());
let pk1 = h1.dh.generate_public_key();
let pk2 = h2.dh.generate_public_key();
assert_ne!(
pk1, pk2,
"Different instances should have different public keys"
);
}
#[test]
fn test_initiator_step2_before_keys() {
let mut h = MseHandshake::new_initiator(test_info_hash());
let result = h.build_initiator_step2();
assert!(result.is_err());
}
#[test]
fn test_finalize_before_completed() {
let h = MseHandshake::new_initiator(test_info_hash());
let result = h.finalize();
assert!(result.is_err());
}
#[test]
fn test_receiver_step4_before_completed() {
let mut h = MseHandshake::new_responder(test_info_hash());
let result = h.build_receiver_step2();
assert!(result.is_err());
}
#[test]
fn test_only_initiator_builds_step3() {
let mut h = MseHandshake::new_responder(test_info_hash());
let result = h.build_initiator_step2();
assert!(result.is_err());
}
#[test]
fn test_only_receiver_builds_step4() {
let info_hash = test_info_hash();
let mut h = MseHandshake::new_initiator(info_hash);
let result = h.build_receiver_step2();
assert!(result.is_err());
}
#[test]
fn test_only_receiver_processes_step3() {
let mut h = MseHandshake::new_initiator(test_info_hash());
let result = h.receive_initiator_step2(&[], &[]);
assert!(result.is_err());
}
#[test]
fn test_only_initiator_processes_step4() {
let mut h = MseHandshake::new_responder(test_info_hash());
let result = h.receive_receiver_step2(&[]);
assert!(result.is_err());
}
#[test]
fn test_key_derivation_format() {
let info_hash = test_info_hash();
let initiator = MseHandshake::new_initiator(info_hash);
let step1 = initiator.build_step1();
let mut responder = MseHandshake::new_responder(info_hash);
responder.receive_step1(&step1).expect("receive step1");
let keys = responder.keys.as_ref().expect("keys derived");
let shared = responder.shared_secret.expect("shared secret");
let mut input = Vec::new();
input.extend_from_slice(b"keyA");
input.extend_from_slice(&shared);
input.extend_from_slice(&info_hash);
use sha1::{Digest, Sha1};
let mut hasher = Sha1::new();
hasher.update(&input);
let expected = hasher.finalize();
assert_eq!(&keys.key_a[..], &expected[..]);
}
#[test]
fn test_multi_torrent_info_hash_selection() {
let info_hash_1 = [0x01u8; INFO_HASH_LENGTH];
let info_hash_2 = [0x02u8; INFO_HASH_LENGTH];
let mut initiator = MseHandshake::new_initiator(info_hash_2);
let mut responder = MseHandshake::new_responder(info_hash_1);
let i_step1 = initiator.build_step1();
let r_step1 = responder.build_step1();
initiator
.receive_step1(&r_step1)
.expect("I receive R step1");
responder
.receive_step1(&i_step1)
.expect("R receive I step1");
let i_step3 = initiator.build_initiator_step2().expect("I build step3");
let method = responder
.receive_initiator_step2(&i_step3, &[info_hash_1, info_hash_2])
.expect("R receive step3");
assert_eq!(method, MseCryptoMethod::Rc4);
assert_eq!(responder.info_hash, info_hash_2);
}
}