feat: Added support_1_19 config [issue #1]

Author: Andcool-Systems

README.md

@@ -92,6 +92,10 @@ timeout = 10
 # This is necessary to prevent proxy bypass or spoofing.
 server_ip = "localhost"
 
+# Enable partial support of 1.19-1.19.2 clients
+# https://github.com/Andcool-Systems/mc-oauth-rs/issues/1
+support_1_19 = false
+
 [server.config]
 # Minecraft server name
 server_name = "mc-oauth-rs"

config.example.toml

@@ -9,6 +9,7 @@ addr = "0.0.0.0"
 port = 25565
 timeout = 20
 server_ip = "localhost" # Change or remove before production use!
+support_1_19 = false # READ: https://github.com/Andcool-Systems/mc-oauth-rs/issues/1
 
 [server.config]
 server_name = "mc-oauth-rs"

src/byte_buf_utils.rs

@@ -89,8 +89,8 @@ pub fn try_get_uuid(buf: &mut BytesMut) -> anyhow::Result<Uuid> {
         return Err(Error::msg("Not enough data"));
     }
 
-    if len > 16 && read_varint(buf)? == 0 {
-        return Err(Error::msg("No UUID in packet"));
+    if len > 16 {
+        buf.advance(len - 16); // Normalize uuid length
     }
 
     let mut bytes = [0u8; 16];

src/config/types.rs

@@ -50,6 +50,9 @@ pub struct Server {
 
     /// Proxy address (optional)
     pub server_ip: Option<String>,
+
+    /// Enable partial support of 1.19 servers
+    pub support_1_19: bool,
 }
 
 #[derive(Deserialize, Debug)]

src/handlers/encryption_response.rs

@@ -10,23 +10,26 @@ impl MinecraftServer {
     Check verify tokens and set up the cipher
     */
     pub fn handle_encryption(&mut self) -> Result<()> {
-        let response = EncryptionResponsePacket::parse(&mut self.buffer)?;
+        let response = EncryptionResponsePacket::parse(self)?;
 
         // Decrypt client's keys
         let decrypted_secret = self
             .keys
             .decrypt(Pkcs1v15Encrypt, &response.shared_secret)?;
-        let decrypted_verify = self.keys.decrypt(Pkcs1v15Encrypt, &response.verify_token)?;
 
-        // Check tokens equality
-        if decrypted_verify
-            .iter()
-            .zip(&self.session.verify_token)
-            .filter(|&(a, b)| a == b)
-            .count()
-            != decrypted_verify.len()
-        {
-            return Err(Error::msg("Verify tokens didn't match!"));
+        if response.has_verify {
+            let decrypted_verify = self.keys.decrypt(Pkcs1v15Encrypt, &response.verify_token)?;
+
+            // Check tokens equality
+            if decrypted_verify
+                .iter()
+                .zip(&self.session.verify_token)
+                .filter(|&(a, b)| a == b)
+                .count()
+                != decrypted_verify.len()
+            {
+                return Err(Error::msg("Verify tokens didn't match!"));
+            }
         }
 
         // Set up client cipher

src/handlers/login_start.rs

@@ -10,9 +10,12 @@ impl MinecraftServer {
         self.session.nickname = Some(packet.name);
         self.session.uuid = packet.uuid;
 
-        if self.session.proto_ver >= 759 && self.session.proto_ver <= 762 {
+        if self.session.proto_ver >= 759
+            && self.session.proto_ver <= 760
+            && !self.config.server.support_1_19
+        {
             self.send_disconnect(
-                "Sorry, Minecraft 1.19.* clients not supported yet.\nTry using another version of client."
+                "§cSorry, Minecraft 1.19-1.19.2 clients not supported yet.\nTry using another version of client."
                     .to_string(),
             )
             .await?;

src/packets/encryption_response.rs

@@ -1,23 +1,30 @@
-use crate::byte_buf_utils::read_varint;
+use crate::{byte_buf_utils::read_varint, server::MinecraftServer};
 use anyhow::Result;
 use bytes::BytesMut;
 
 pub struct EncryptionResponsePacket {
     pub shared_secret: Vec<u8>,
     pub verify_token: Vec<u8>,
+    pub has_verify: bool,
 }
 
 impl EncryptionResponsePacket {
-    pub fn parse(buff: &mut BytesMut) -> Result<Self> {
-        let shared_secret_length = read_varint(buff)?;
-        let shared_secret = buff.split_to(shared_secret_length);
+    pub fn parse(server: &mut MinecraftServer) -> Result<Self> {
+        let shared_secret_length = read_varint(&mut server.buffer)?;
+        let shared_secret = server.buffer.split_to(shared_secret_length);
 
-        let verify_token_length = read_varint(buff)?;
-        let verify_token = buff.split_to(verify_token_length);
+        let mut has_verify = false;
+        let mut verify_token = BytesMut::new();
+        if !(server.session.proto_ver >= 759 && server.session.proto_ver <= 760) {
+            let verify_token_length = read_varint(&mut server.buffer)?;
+            verify_token = server.buffer.split_to(verify_token_length);
+            has_verify = true;
+        }
 
         Ok(Self {
             shared_secret: shared_secret.to_vec(),
             verify_token: verify_token.to_vec(),
+            has_verify,
         })
     }
 }