torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! RC4 stream cipher (MSE keystreams). Intentionally local — MSE requires classic RC4-drop1024.

#[derive(Clone)]
pub struct Rc4 {
    i: u8,
    j: u8,
    s: [u8; 256],
}

impl Rc4 {
    pub fn new(key: &[u8]) -> Self {
        let mut s = [0u8; 256];
        for (i, slot) in s.iter_mut().enumerate() {
            *slot = i as u8;
        }
        let mut j: u8 = 0;
        for i in 0..256 {
            j = j.wrapping_add(s[i]).wrapping_add(key[i % key.len()]);
            s.swap(i, j as usize);
        }
        Self { i: 0, j: 0, s }
    }

    pub fn discard(&mut self, n: usize) {
        for _ in 0..n {
            let _ = self.next_byte();
        }
    }

    fn next_byte(&mut self) -> u8 {
        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 t = self.s[self.i as usize].wrapping_add(self.s[self.j as usize]);
        self.s[t as usize]
    }

    pub fn process(&mut self, data: &mut [u8]) {
        for byte in data {
            *byte ^= self.next_byte();
        }
    }

    pub fn process_copy(&mut self, data: &[u8]) -> Vec<u8> {
        let mut out = data.to_vec();
        self.process(&mut out);
        out
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn rc4_roundtrip() {
        let key = b"mse-test-key";
        let mut enc = Rc4::new(key);
        let mut dec = Rc4::new(key);
        enc.discard(1024);
        dec.discard(1024);
        let mut buf = b"hello torrent".to_vec();
        enc.process(&mut buf);
        assert_ne!(buf, b"hello torrent");
        dec.process(&mut buf);
        assert_eq!(buf, b"hello torrent");
    }
}