minecraft_net/
net.rs

1use crate::errors::Errors;
2use crate::fields::{encode_var_int, read_var_int_from_stream};
3use crate::{Packet, PacketReader};
4use flate2::read::{ZlibDecoder, ZlibEncoder};
5use flate2::Compression;
6use openssl::symm::{Cipher, Crypter, Mode};
7use std::io::{Read, Write};
8use std::net::TcpStream;
9
10
11pub struct EncryptedTcp {
12    stream: TcpStream,
13    encryptor: Crypter,
14    decryptor: Crypter,
15}
16impl EncryptedTcp {
17    pub fn new(stream: TcpStream, secret: Vec<u8>) -> Result<Self, Errors> {
18        Ok(Self {
19            stream,
20            encryptor: Crypter::new(Cipher::aes_128_cfb8(), Mode::Encrypt, &*secret, Some(&*secret)).map_err(|e| Errors::EncryptionError(e))?,
21            decryptor: Crypter::new(Cipher::aes_128_cfb8(), Mode::Decrypt, &*secret, Some(&*secret)).map_err(|e| Errors::EncryptionError(e))?,
22        })
23    }
24}
25impl Read for EncryptedTcp {
26    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
27        let mut read_buff = vec![0; buf.len()];
28        self.stream.read(&mut *read_buff)?;
29        Ok(self.decryptor.update(&*read_buff, buf)?)
30    }
31}
32impl Write for EncryptedTcp {
33    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
34        let mut encrypted_buff = vec![0; buf.len()];
35        self.encryptor.update(buf, &mut *encrypted_buff)?;
36        self.stream.write(&*encrypted_buff)
37    }
38
39    fn flush(&mut self) -> std::io::Result<()> {
40        self.stream.flush()
41    }
42}
43
44pub struct UnknownPacket {
45    pub id: i32,
46    pub reader: PacketReader,
47}
48
49pub fn send_packet<T: Packet>(packet: T, mut stream: impl Write, compression_threshold: Option<usize>) -> Result<(), Errors> {
50    let mut data = encode_var_int(T::ID);
51    data.append(&mut packet.to_bytes());
52    let res = compress_packet_data(data, compression_threshold)?;
53    stream.write_all(&*res).map_err(|e| Errors::IOError(e))
54}
55
56fn compress_packet_data(mut data: Vec<u8>, threshold: Option<usize>) -> Result<Vec<u8>, Errors> {
57    #[cfg(not(debug_assertions))]
58    let _data = data.clone();
59    if threshold.is_none() {
60        let mut res = encode_var_int(data.len() as i32);
61        res.append(&mut data);
62        return Ok(res);
63    }
64
65    if data.len() < threshold.unwrap() {
66        let mut res = encode_var_int((data.len() + 1) as i32);
67        res.append(&mut encode_var_int(0));
68        res.append(&mut data);
69        return Ok(res);
70    }
71
72    let mut data_length = encode_var_int(data.len() as i32);
73    let mut encoder = ZlibEncoder::new(&*data, Compression::default());
74    let mut compressed = Vec::new();
75    if let Err(_e) = encoder.read_to_end(&mut compressed) {
76        return Err(Errors::InvalidPacket("Invalid compression".to_string()));
77    }
78    let mut res = encode_var_int((compressed.len() + data_length.len()) as i32);
79    res.append(&mut data_length);
80    res.append(&mut compressed);
81    Ok(res)
82}
83
84pub fn receive_packet<T: Packet>(mut stream: impl Read, with_compression: bool) -> Result<T, Errors> {
85    let len = read_var_int_from_stream(&mut stream)? as usize;
86    let mut data = vec![0;len];
87    stream.read_exact(&mut *data).map_err(|e| Errors::IOError(e))?;
88    let mut reader = decompress_packet_data(data, with_compression)?;
89    let _id = reader.read_var_int()?;
90    let packet = T::from_reader(&mut reader)?;
91    if reader.len() != 0 {
92        return Err(Errors::InvalidPacket("Packet not read to end. Invalid length".into()))
93    }
94    Ok(packet)
95}
96pub fn receive_unknown_packet(mut stream: impl Read, with_compression: bool) -> Result<UnknownPacket, Errors> {
97    let len = read_var_int_from_stream(&mut stream)? as usize;
98    let mut data = vec![0;len];
99    stream.read(&mut *data).map_err(|e| Errors::IOError(e))?;
100    let mut reader = decompress_packet_data(data, with_compression)?;
101    let id = reader.read_var_int()?;
102    if id == 0 {
103        print!("");
104    }
105    Ok(UnknownPacket { id, reader })
106}
107fn decompress_packet_data(data: Vec<u8>, with_compression: bool) -> Result<PacketReader, Errors> {
108    if data.len() == 0 {
109        return Err(Errors::InvalidPacket("received packet with length 0".into()));
110    }
111    let mut reader = PacketReader::new(data);
112    if !with_compression {
113        return Ok(reader)
114    }
115    
116    let uncompressed_length = reader.read_var_int()?;
117    
118    if uncompressed_length == 0 {
119        return Ok(reader)
120    }
121    
122    let remaining = reader.read_rest();
123    
124    let mut decoder = ZlibDecoder::new(&*remaining);
125    let mut decompressed = Vec::new();
126    match decoder.read_to_end(&mut decompressed) {
127        Err(e) => Err(Errors::CompressionError(e)),
128        Ok(count) => if count == uncompressed_length as usize {
129            Ok(())
130        } else {
131            Err(Errors::InvalidPacket("decompressed size not equal to asserted size.".into()))
132        }
133    }?;
134    Ok(PacketReader::new(decompressed))
135}
minecraft_net/net.rs

minecraft_net/
net.rs
