use std::collections::VecDeque;
use std::time::Duration;
use sha1::{Digest, Sha1};
use tokio::net::TcpStream;
use tokio::time::timeout;
use crate::error::{Error, Result};
use crate::mse::dh::{self, PUBLIC_KEY_LEN};
use crate::mse::rc4::Rc4;
use crate::mse::carrier::MseCarrier;
use crate::mse::stream::MseStream;
use crate::utp::UtpStream;
const RC4_DROP: usize = 1024;
const HANDSHAKE_TIMEOUT: Duration = Duration::from_secs(30);
const CRYPTO_PLAINTEXT: u32 = 0x01;
const CRYPTO_RC4: u32 = 0x02;
const CRYPTO_PROVIDE: u32 = CRYPTO_PLAINTEXT | CRYPTO_RC4;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CryptoSelect {
Plaintext,
Rc4,
}
impl CryptoSelect {
fn from_u32(value: u32) -> Result<Self> {
match value {
CRYPTO_PLAINTEXT => Ok(Self::Plaintext),
CRYPTO_RC4 => Ok(Self::Rc4),
other => Err(Error::Peer(format!(
"MSE crypto_select unsupported: {other:#x}"
))),
}
}
fn to_u32(self) -> u32 {
match self {
Self::Plaintext => CRYPTO_PLAINTEXT,
Self::Rc4 => CRYPTO_RC4,
}
}
}
struct BufIo {
stream: MseCarrier,
pending: VecDeque<u8>,
}
impl BufIo {
fn new(stream: MseCarrier) -> Self {
Self {
stream,
pending: VecDeque::new(),
}
}
async fn write_all(&mut self, data: &[u8]) -> Result<()> {
self.stream.write_all(data).await
}
async fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
let mut filled = 0;
while filled < buf.len() {
if let Some(byte) = self.pending.pop_front() {
buf[filled] = byte;
filled += 1;
continue;
}
let n = self.stream.read(&mut buf[filled..]).await?;
if n == 0 {
return Err(Error::Peer("MSE connection closed".into()));
}
filled += n;
}
Ok(())
}
async fn read_some(&mut self, buf: &mut [u8]) -> Result<usize> {
if !self.pending.is_empty() {
let n = buf.len().min(self.pending.len());
for slot in buf.iter_mut().take(n) {
*slot = self.pending.pop_front().expect("pending");
}
return Ok(n);
}
let n = self.stream.read(buf).await?;
if n == 0 {
return Err(Error::Peer("MSE connection closed".into()));
}
Ok(n)
}
fn into_carrier(self) -> MseCarrier {
debug_assert!(self.pending.is_empty());
self.stream
}
}
fn sha1(parts: &[&[u8]]) -> [u8; 20] {
let mut h = Sha1::new();
for p in parts {
h.update(p);
}
h.finalize().into()
}
fn s_bytes(s: &num_bigint::BigUint) -> [u8; PUBLIC_KEY_LEN] {
dh::encode_public(s)
}
fn init_rc4(outgoing_key: &[u8; 20], incoming_key: &[u8; 20]) -> (Rc4, Rc4) {
let mut enc = Rc4::new(outgoing_key);
let mut dec = Rc4::new(incoming_key);
enc.discard(RC4_DROP);
dec.discard(RC4_DROP);
(enc, dec)
}
fn keys_initiator(s: &[u8; PUBLIC_KEY_LEN], skey: &[u8; 20]) -> ([u8; 20], [u8; 20]) {
(sha1(&[b"keyA", s, skey]), sha1(&[b"keyB", s, skey]))
}
fn keys_acceptor(s: &[u8; PUBLIC_KEY_LEN], skey: &[u8; 20]) -> ([u8; 20], [u8; 20]) {
(sha1(&[b"keyB", s, skey]), sha1(&[b"keyA", s, skey]))
}
pub async fn dial_mse(stream: TcpStream, skey: &[u8; 20]) -> Result<MseStream> {
dial_mse_carrier(MseCarrier::Tcp(stream), skey).await
}
pub async fn dial_mse_utp(stream: UtpStream, skey: &[u8; 20]) -> Result<MseStream> {
dial_mse_carrier(MseCarrier::Utp(stream), skey).await
}
pub async fn dial_mse_carrier(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
timeout(HANDSHAKE_TIMEOUT, dial_mse_inner(stream, skey))
.await
.map_err(|_| Error::Peer("MSE dial handshake timed out".into()))?
}
async fn dial_mse_inner(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
let mut sock = BufIo::new(stream);
let kp = dh::generate_keypair()?;
sock.write_all(&dh::encode_public(&kp.public)).await?;
let mut yb_buf = [0u8; PUBLIC_KEY_LEN];
sock.read_exact(&mut yb_buf).await?;
drain_pad(&mut sock, 512).await?;
let secret = dh::shared_secret(&dh::decode_public(&yb_buf), &kp.secret);
let s = s_bytes(&secret);
let (out_key, in_key) = keys_initiator(&s, skey);
let (mut enc, mut dec) = init_rc4(&out_key, &in_key);
let req1 = sha1(&[b"req1", &s]);
let mut xor = sha1(&[b"req2", skey]);
let req3 = sha1(&[b"req3", &s]);
for (a, b) in xor.iter_mut().zip(req3.iter()) {
*a ^= *b;
}
let mut plain = Vec::with_capacity(16);
plain.extend_from_slice(&[0u8; 8]);
plain.extend_from_slice(&CRYPTO_PROVIDE.to_be_bytes());
plain.extend_from_slice(&0u16.to_be_bytes());
plain.extend_from_slice(&0u16.to_be_bytes());
let encrypted = enc.process_copy(&plain);
let mut packet3 = Vec::with_capacity(40 + encrypted.len());
packet3.extend_from_slice(&req1);
packet3.extend_from_slice(&xor);
packet3.extend_from_slice(&encrypted);
sock.write_all(&packet3).await?;
let mut vc = [0u8; 8];
sock.read_exact(&mut vc).await?;
dec.process(&mut vc);
if vc != [0u8; 8] {
return Err(Error::Peer("MSE VC mismatch (dial)".into()));
}
let mut select_buf = [0u8; 4];
sock.read_exact(&mut select_buf).await?;
dec.process(&mut select_buf);
let select = CryptoSelect::from_u32(u32::from_be_bytes(select_buf))?;
if select.to_u32() & CRYPTO_PROVIDE == 0 {
return Err(Error::Peer("MSE crypto_select not in provide".into()));
}
let mut len_buf = [0u8; 2];
sock.read_exact(&mut len_buf).await?;
dec.process(&mut len_buf);
let pad_d = u16::from_be_bytes(len_buf) as usize;
if pad_d > 512 {
return Err(Error::Peer("MSE PadD too large".into()));
}
if pad_d > 0 {
let mut pad = vec![0u8; pad_d];
sock.read_exact(&mut pad).await?;
dec.process(&mut pad);
}
finish(sock, select, enc, dec)
}
pub async fn accept_mse(stream: TcpStream, skey: &[u8; 20]) -> Result<MseStream> {
accept_mse_carrier(MseCarrier::Tcp(stream), skey).await
}
pub async fn accept_mse_utp(stream: UtpStream, skey: &[u8; 20]) -> Result<MseStream> {
accept_mse_carrier(MseCarrier::Utp(stream), skey).await
}
pub async fn accept_mse_carrier(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
timeout(HANDSHAKE_TIMEOUT, accept_mse_inner(stream, skey))
.await
.map_err(|_| Error::Peer("MSE accept handshake timed out".into()))?
}
async fn accept_mse_inner(stream: MseCarrier, skey: &[u8; 20]) -> Result<MseStream> {
let mut sock = BufIo::new(stream);
let mut ya_buf = [0u8; PUBLIC_KEY_LEN];
sock.read_exact(&mut ya_buf).await?;
let kp = dh::generate_keypair()?;
sock.write_all(&dh::encode_public(&kp.public)).await?;
let secret = dh::shared_secret(&dh::decode_public(&ya_buf), &kp.secret);
let s = s_bytes(&secret);
let req1 = sha1(&[b"req1", &s]);
sync_hash(&mut sock, &req1, 512).await?;
let mut xor_buf = [0u8; 20];
sock.read_exact(&mut xor_buf).await?;
let req3 = sha1(&[b"req3", &s]);
let mut req2 = xor_buf;
for (a, b) in req2.iter_mut().zip(req3.iter()) {
*a ^= *b;
}
if req2 != sha1(&[b"req2", skey]) {
return Err(Error::Peer("MSE SKEY mismatch (accept)".into()));
}
let (out_key, in_key) = keys_acceptor(&s, skey);
let (mut enc, mut dec) = init_rc4(&out_key, &in_key);
let mut vc = [0u8; 8];
sock.read_exact(&mut vc).await?;
dec.process(&mut vc);
if vc != [0u8; 8] {
return Err(Error::Peer("MSE VC mismatch (accept)".into()));
}
let mut provide_buf = [0u8; 4];
sock.read_exact(&mut provide_buf).await?;
dec.process(&mut provide_buf);
let provide = u32::from_be_bytes(provide_buf);
let select = if provide & CRYPTO_RC4 != 0 {
CryptoSelect::Rc4
} else if provide & CRYPTO_PLAINTEXT != 0 {
CryptoSelect::Plaintext
} else {
return Err(Error::Peer(
"MSE crypto_provide has no supported method".into(),
));
};
let mut len_buf = [0u8; 2];
sock.read_exact(&mut len_buf).await?;
dec.process(&mut len_buf);
let pad_c = u16::from_be_bytes(len_buf) as usize;
if pad_c > 512 {
return Err(Error::Peer("MSE PadC too large".into()));
}
if pad_c > 0 {
let mut pad = vec![0u8; pad_c];
sock.read_exact(&mut pad).await?;
dec.process(&mut pad);
}
sock.read_exact(&mut len_buf).await?;
dec.process(&mut len_buf);
let ia_len = u16::from_be_bytes(len_buf) as usize;
if ia_len > 65_535 {
return Err(Error::Peer("MSE IA too large".into()));
}
if ia_len > 0 {
let mut ia = vec![0u8; ia_len];
sock.read_exact(&mut ia).await?;
dec.process(&mut ia);
}
let mut plain = Vec::with_capacity(14);
plain.extend_from_slice(&[0u8; 8]);
plain.extend_from_slice(&select.to_u32().to_be_bytes());
plain.extend_from_slice(&0u16.to_be_bytes());
let encrypted = enc.process_copy(&plain);
sock.write_all(&encrypted).await?;
finish(sock, select, enc, dec)
}
fn finish(sock: BufIo, select: CryptoSelect, enc: Rc4, dec: Rc4) -> Result<MseStream> {
if !sock.pending.is_empty() {
return Err(Error::Peer("MSE leftover bytes after handshake".into()));
}
let (enc, dec) = match select {
CryptoSelect::Rc4 => (Some(enc), Some(dec)),
CryptoSelect::Plaintext => (None, None),
};
Ok(MseStream::new(sock.into_carrier(), select, enc, dec))
}
async fn drain_pad(sock: &mut BufIo, max: usize) -> Result<()> {
let mut total = 0usize;
let mut buf = [0u8; 64];
while total < max {
match timeout(Duration::from_millis(25), sock.read_some(&mut buf)).await {
Ok(Ok(n)) => total = total.saturating_add(n),
Ok(Err(err)) => return Err(err),
Err(_) => break,
}
}
Ok(())
}
async fn sync_hash(sock: &mut BufIo, needle: &[u8; 20], max_pad: usize) -> Result<()> {
let mut window = Vec::with_capacity(max_pad + 20);
let mut buf = [0u8; 64];
while window.len() < max_pad + 20 {
let n = sock.read_some(&mut buf).await?;
window.extend_from_slice(&buf[..n]);
if let Some(pos) = window.windows(20).position(|w| w == needle) {
let rest = &window[pos + 20..];
for &byte in rest {
sock.pending.push_back(byte);
}
return Ok(());
}
}
Err(Error::Peer("MSE sync hash not found within pad window".into()))
}