use sha1::{Digest, Sha1};
use std::fmt;
use super::mse_dh::{INFO_HASH_LENGTH, KEY_LENGTH, SHA1_LENGTH, VC_LENGTH};
const KEYSTREAM_DISCARD: usize = 1024;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MseCryptoMethod {
Plain = 0x00000001,
Rc4 = 0x00000002,
}
impl MseCryptoMethod {
pub fn from_u32(v: u32) -> Self {
if v & 0x02 != 0 {
Self::Rc4
} else {
Self::Plain
}
}
pub fn as_u32(self) -> u32 {
self as u32
}
pub fn is_encrypted(self) -> bool {
matches!(self, Self::Rc4)
}
}
#[derive(Clone)]
pub struct Arc4Cipher {
s: [u8; 256],
i: u8,
j: u8,
}
impl fmt::Debug for Arc4Cipher {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Arc4Cipher")
.field("state", &"[REDACTED]")
.finish()
}
}
impl Arc4Cipher {
pub fn new(key: &[u8]) -> Self {
let mut s = [0u8; 256];
#[allow(clippy::needless_range_loop)]
for i in 0..256 {
s[i] = i as u8;
}
let mut j: usize = 0;
#[allow(clippy::needless_range_loop)]
for i in 0..256 {
let si = s[i] as usize;
j = (j + si + key[i % key.len()] as usize) % 256;
s.swap(i, j);
}
Arc4Cipher { s, i: 0, j: 0 }
}
pub fn encrypt(&mut self, data: &mut [u8]) {
for byte in data.iter_mut() {
self.i = self.i.wrapping_add(1);
self.j = self.j.wrapping_add(self.s[self.i as usize]);
self.s.swap(self.i as usize, self.j as usize);
let k =
self.s[(self.s[self.i as usize] as usize + self.s[self.j as usize] as usize) % 256];
*byte ^= k;
}
}
pub fn decrypt(&mut self, data: &mut [u8]) {
self.encrypt(data);
}
}
#[derive(Clone)]
pub struct MseDerivedKeys {
pub key_a: [u8; SHA1_LENGTH],
pub key_b: [u8; SHA1_LENGTH],
pub req1: [u8; SHA1_LENGTH],
pub req2: [u8; SHA1_LENGTH],
pub req3: [u8; SHA1_LENGTH],
}
impl fmt::Debug for MseDerivedKeys {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("MseDerivedKeys")
.field("key_a", &"[REDACTED]")
.field("key_b", &"[REDACTED]")
.field("req1", &"[REDACTED]")
.field("req2", &"[REDACTED]")
.field("req3", &"[REDACTED]")
.finish()
}
}
impl MseDerivedKeys {
pub fn derive(shared_secret: &[u8; KEY_LENGTH], info_hash: &[u8; INFO_HASH_LENGTH]) -> Self {
let key_a = {
let mut input = Vec::with_capacity(4 + KEY_LENGTH + INFO_HASH_LENGTH);
input.extend_from_slice(b"keyA");
input.extend_from_slice(shared_secret);
input.extend_from_slice(info_hash);
sha1_digest_array(&input)
};
let key_b = {
let mut input = Vec::with_capacity(4 + KEY_LENGTH + INFO_HASH_LENGTH);
input.extend_from_slice(b"keyB");
input.extend_from_slice(shared_secret);
input.extend_from_slice(info_hash);
sha1_digest_array(&input)
};
let req1 = {
let mut input = Vec::with_capacity(4 + KEY_LENGTH);
input.extend_from_slice(b"req1");
input.extend_from_slice(shared_secret);
sha1_digest_array(&input)
};
let req2 = {
let mut input = Vec::with_capacity(4 + INFO_HASH_LENGTH);
input.extend_from_slice(b"req2");
input.extend_from_slice(info_hash);
sha1_digest_array(&input)
};
let req3 = {
let mut input = Vec::with_capacity(4 + KEY_LENGTH);
input.extend_from_slice(b"req3");
input.extend_from_slice(shared_secret);
sha1_digest_array(&input)
};
MseDerivedKeys {
key_a,
key_b,
req1,
req2,
req3,
}
}
pub fn req2_xor_req3(&self) -> [u8; SHA1_LENGTH] {
let mut result = [0u8; SHA1_LENGTH];
for (result, (&req2, &req3)) in result
.iter_mut()
.zip(self.req2.iter().zip(self.req3.iter()))
{
*result = req2 ^ req3;
}
result
}
}
fn sha1_digest_array(data: &[u8]) -> [u8; SHA1_LENGTH] {
let mut hasher = Sha1::new();
hasher.update(data);
let result = hasher.finalize();
let mut arr = [0u8; SHA1_LENGTH];
arr.copy_from_slice(&result);
arr
}
pub struct Rc4State {
s: [u8; 256],
i: u8,
j: u8,
}
impl fmt::Debug for Rc4State {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Rc4State")
.field("state", &"[REDACTED]")
.finish()
}
}
impl Rc4State {
fn new(key: &[u8]) -> Self {
let mut s = [0u8; 256];
#[allow(clippy::needless_range_loop)]
for i in 0..256 {
s[i] = i as u8;
}
let mut j: usize = 0;
#[allow(clippy::needless_range_loop)]
for i in 0..256 {
let si = s[i] as usize;
j = (j + si + key[i % key.len()] as usize) % 256;
s.swap(i, j);
}
Rc4State { s, i: 0, j: 0 }
}
pub fn process(&mut self, data: &mut [u8]) {
for byte in data.iter_mut() {
self.i = self.i.wrapping_add(1);
self.j = self.j.wrapping_add(self.s[self.i as usize]);
self.s.swap(self.i as usize, self.j as usize);
let k =
self.s[(self.s[self.i as usize] as usize + self.s[self.j as usize] as usize) % 256];
*byte ^= k;
}
}
}
pub fn init_rc4(key: &[u8]) -> Rc4State {
let mut rc4 = Rc4State::new(key);
let mut discard = [0u8; KEYSTREAM_DISCARD];
rc4.process(&mut discard);
rc4
}
pub fn compute_vc(cipher: &mut Rc4State) -> [u8; VC_LENGTH] {
let mut vc = [0u8; VC_LENGTH];
cipher.process(&mut vc);
vc
}
pub struct MseCryptoState {
send_cipher: Option<Rc4State>,
recv_cipher: Option<Rc4State>,
method: MseCryptoMethod,
}
impl fmt::Debug for MseCryptoState {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("MseCryptoState")
.field("method", &self.method)
.field("encrypted", &self.is_encrypted())
.finish()
}
}
impl MseCryptoState {
pub fn new_plain() -> Self {
MseCryptoState {
send_cipher: None,
recv_cipher: None,
method: MseCryptoMethod::Plain,
}
}
pub fn new_encrypted(keys: &MseDerivedKeys, initiator: bool) -> Self {
if initiator {
MseCryptoState {
send_cipher: Some(init_rc4(&keys.key_a)),
recv_cipher: Some(init_rc4(&keys.key_b)),
method: MseCryptoMethod::Rc4,
}
} else {
MseCryptoState {
send_cipher: Some(init_rc4(&keys.key_b)),
recv_cipher: Some(init_rc4(&keys.key_a)),
method: MseCryptoMethod::Rc4,
}
}
}
pub fn from_raw_keys(
send_key: &[u8; SHA1_LENGTH],
recv_key: &[u8; SHA1_LENGTH],
method: MseCryptoMethod,
) -> Self {
match method {
MseCryptoMethod::Rc4 => MseCryptoState {
send_cipher: Some(init_rc4(send_key)),
recv_cipher: Some(init_rc4(recv_key)),
method: MseCryptoMethod::Rc4,
},
MseCryptoMethod::Plain => MseCryptoState::new_plain(),
}
}
pub(crate) fn from_rc4_states(
send_cipher: Rc4State,
recv_cipher: Rc4State,
method: MseCryptoMethod,
) -> Self {
Self {
send_cipher: Some(send_cipher),
recv_cipher: Some(recv_cipher),
method,
}
}
pub fn encrypt(&mut self, data: &mut [u8]) {
if let Some(ref mut cipher) = self.send_cipher {
cipher.process(data);
}
}
pub fn decrypt(&mut self, data: &mut [u8]) {
if let Some(ref mut cipher) = self.recv_cipher {
cipher.process(data);
}
}
pub fn is_encrypted(&self) -> bool {
self.send_cipher.is_some()
}
pub fn method(&self) -> MseCryptoMethod {
self.method
}
}
impl Default for MseCryptoState {
fn default() -> Self {
Self::new_plain()
}
}
impl Clone for MseCryptoState {
fn clone(&self) -> Self {
MseCryptoState::new_plain()
}
}
#[cfg(test)]
mod tests;