feat(join)!: make join protocol final working

Author: Cyberdolfi

Cargo.toml

@@ -25,4 +25,5 @@ sqlx = { version = "0.8.6", features = [ "runtime-tokio", "postgres", "macros",
 toml = "1.0.3+spec-1.1.0"
 url = "2.5.8"
 poise = "0.6.1"
-serenity = { version = "0.12", default-features = false, features = ["client", "gateway", "rustls_backend", "model"] }
+serenity = { version = "0.12", default-features = false, features = ["client", "gateway", "rustls_backend", "model"] }
+flate2 = "1.1.9"

src/cli.rs

@@ -68,6 +68,9 @@ pub enum Commands {
     Join {
         #[arg(value_name = "<IP>[:PORT]")]
         address: String,
+
+        #[arg(value_name = "Protocol version")]
+        protocol: i32,
     },
 
     #[command(

src/main.rs

@@ -105,8 +105,8 @@ async fn main() -> Result<()> {
             tasks::run_query(address).await;
         }
 
-        cli::Commands::Join { address } => {
-            tasks::run_join(address).await;
+        cli::Commands::Join { address, protocol } => {
+            tasks::run_join(address, protocol).await;
         }
 
         cli::Commands::Crawl { cidr } => {

src/minecraft/join.rs

@@ -1,22 +1,22 @@
+use std::io::Read;
+use std::io::Cursor;
 use std::net::Ipv4Addr;
 use std::time::Duration;
+use flate2::read::ZlibDecoder;
+use futures::TryFutureExt;
 use tokio::net::TcpStream;
-use tokio::io::AsyncWriteExt;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::time::timeout;
 use crate::minecraft::Join;
-use crate::minecraft::utils::{Handshake, write_varint, read_varint, prepend_length, MinecraftPacket, encode_string, encode_uuid};
+use crate::minecraft::utils::{Handshake, write_varint, read_varint, prepend_length, MinecraftPacket, encode_string};
+use uuid::Uuid;
 
-// TODO: Make this work
-//  It have every time the same error:
-//  [20:13:41 INFO]: /[0:0:0:0:0:0:0:1]:58067 lost connection: Internal Exception: io.netty.handler.codec.DecoderException: Failed to decode packet 'serverbound/minecraft:hello'
-// I used this docs here https://minecraft.wiki/w/Java_Edition_protocol/FAQ#What's_the_normal_login_sequence_for_a_client?
 pub async fn execute_join_check(ip: Ipv4Addr, port: u16, timeout_dur: Duration, username: &str, protocol: i32) -> Result<Join, String> {
     let mut stream = timeout(timeout_dur, TcpStream::connect((ip, port)))
         .await
         .map_err(|_| "Connect Timeout")?
         .map_err(|e| e.to_string())?;
 
-    // Send handshake
     let handshake = Handshake {
         protocol,
         address: ip,
@@ -25,36 +25,140 @@ pub async fn execute_join_check(ip: Ipv4Addr, port: u16, timeout_dur: Duration,
     }.serialize();
     stream.write_all(&handshake).await.map_err(|e| e.to_string())?;
 
-    // Login Start Packet
+    // Login start packet
     let mut login_start = Vec::new();
     write_varint(0x00, &mut login_start);
     login_start.extend(encode_string(username));
-    login_start.push(0x01);
-    // Used here 0x0U0
-    login_start.extend(encode_uuid("00000000-0000-0000-0000-000000000000"));
+
+    // The protocol needs an uuid after 1.17.3
+    if protocol > 761 {
+        let uuid = Uuid::nil();
+        login_start.extend_from_slice(uuid.as_bytes());
+    }
 
     let final_login = prepend_length(login_start);
     stream.write_all(&final_login).await.map_err(|e| e.to_string())?;
     stream.flush().await.map_err(|e| e.to_string())?;
 
-    let packet_length = read_varint(&mut stream).await? as usize;
-    let packet_id = read_varint(&mut stream).await?;
+    let result = timeout(timeout_dur, async {
+        let _packet_length = read_varint(&mut stream).await?;
+        let mut packet_id = read_varint(&mut stream).await?;
+
+        if packet_id == 0x03 {
+            let _threshold = read_varint(&mut stream).await?;
+
+            let total_len = read_varint(&mut stream).await? as usize;
+            let uncompressed_len = read_varint(&mut stream).await? as usize;
+
+            let mut packet_data = Vec::new();
+            if uncompressed_len == 0 {
+                let remaining = total_len - 1;
+                let mut buf = vec![0u8; remaining];
+                stream.read_exact(&mut buf).await.map_err(|e| e.to_string())?;
+                packet_data = buf;
+            } else {
+                let compressed_len = total_len - get_varint_size(uncompressed_len as i32);
+                let mut compressed_buf = vec![0u8; compressed_len];
+                stream.read_exact(&mut compressed_buf).await.map_err(|e| e.to_string())?;
+
+                let mut decoder = ZlibDecoder::new(&compressed_buf[..]);
+                decoder.read_to_end(&mut packet_data).map_err(|e: std::io::Error| e.to_string())?;
+            }
+
+            let mut cursor = Cursor::new(packet_data);
+            packet_id = read_varint(&mut cursor).await?;
+
+            return handle_packet(packet_id, cursor).await;
+        }
+
+        handle_packet_stream(packet_id, &mut stream).await
+    }).await.map_err(|_| "Timeout while reading answer".to_string())??;
+
+    Ok(result)
+}
+
+async fn handle_packet_stream(packet_id: i32, stream: &mut TcpStream) -> Result<Join, String> {
+    match packet_id {
+        0x00 => {
+            let reason_json = read_string_packet(stream).await?;
+            let plain_reason = crate::minecraft::utils::parse_plain(&reason_json);
+            let lower_reason = plain_reason.to_lowercase();
+
+            let online_mode_keywords = [
+                "failed to verify", "not authenticated", "premium account",
+                "authentication servers", "encryption", "online-mode",
+                "requires mojang", "requires microsoft"
+            ];
 
-    let packet_id = packet_id;
+            let whitelist_keywords = [
+                "whitelist", "whitelisted", "not allowed"
+            ];
 
-    Err(format!("Packet: 0x{:02X}", packet_id))
+            let is_cracked = !online_mode_keywords.iter().any(|&k| lower_reason.contains(k));
+            let is_whitelist = whitelist_keywords.iter().any(|&k| lower_reason.contains(k));
+
+            Ok(Join {
+                cracked: is_cracked,
+                whitelist: is_whitelist,
+                kick_message: Some(plain_reason)
+            })
+        }
+        0x01 => Ok(Join { cracked: false, whitelist: false, kick_message: None }),
+        0x02 => Ok(Join { cracked: true, whitelist: false, kick_message: None }),
+        _ => Err(format!("Unknown packet: 0x{:02X}", packet_id)),
+    }
 }
 
-fn read_varint_from_slice(slice: &mut &[u8]) -> Result<i32, String> {
-    let mut res = 0;
-    let mut pos = 0;
-    while pos < 32 {
-        if slice.is_empty() { return Err("Unexpected end of slice".into()); }
-        let byte = slice[0];
-        *slice = &slice[1..];
-        res |= ((byte & 0x7F) as i32) << pos;
-        if (byte & 0x80) == 0 { return Ok(res); }
-        pos += 7;
+async fn handle_packet(packet_id: i32, mut cursor: Cursor<Vec<u8>>) -> Result<Join, String> {
+    match packet_id {
+        0x00 => {
+            let len = read_varint(&mut cursor).await? as usize;
+            let mut buf = vec![0u8; len];
+
+            AsyncReadExt::read_exact(&mut cursor, &mut buf).map_err(|e| e.to_string()).await?;
+
+            let reason_json = String::from_utf8_lossy(&buf).to_string();
+            let plain_reason = crate::minecraft::utils::parse_plain(&reason_json);
+            let lower_reason = plain_reason.to_lowercase();
+
+            let online_mode_keywords = [
+                "failed to verify", "not authenticated", "premium account",
+                "authentication servers", "encryption", "online-mode",
+                "requires mojang", "requires microsoft"
+            ];
+
+            let whitelist_keywords = [
+                "whitelist", "whitelisted", "not allowed"
+            ];
+
+            let is_cracked = !online_mode_keywords.iter().any(|&k| lower_reason.contains(k));
+            let is_whitelist = whitelist_keywords.iter().any(|&k| lower_reason.contains(k));
+
+            Ok(Join {
+                cracked: is_cracked,
+                whitelist: is_whitelist,
+                kick_message: Some(plain_reason)
+            })
+        }
+        0x01 => Ok(Join { cracked: false, whitelist: false, kick_message: None }),
+        0x02 => Ok(Join { cracked: true, whitelist: false, kick_message: None }),
+        _ => Err(format!("Unknown packet after decompression: 0x{:02X}", packet_id)),
+    }
+}
+
+fn get_varint_size(mut value: i32) -> usize {
+    let mut size = 0;
+    loop {
+        size += 1;
+        if (value as u32 & !0x7F) == 0 { break; }
+        value = (value as u32 >> 7) as i32;
     }
-    Err("VarInt too big".into())
+    size
+}
+
+async fn read_string_packet(stream: &mut TcpStream) -> Result<String, String> {
+    let len = read_varint(stream).await?;
+    let mut buf = vec![0u8; len as usize];
+    stream.read_exact(&mut buf).await.map_err(|e| e.to_string())?;
+    Ok(String::from_utf8_lossy(&buf).to_string())
 }

src/minecraft/utils.rs

@@ -1,7 +1,6 @@
 use std::net::Ipv4Addr;
 use serde_json::Value;
-use tokio::io::AsyncReadExt;
-use tokio::net::TcpStream;
+use tokio::io::{AsyncRead, AsyncReadExt};
 use uuid::Uuid;
 
 // Minecraft packet decoder/encoder
@@ -14,7 +13,7 @@ pub fn write_varint(val: i32, buf: &mut Vec<u8>) {
     buf.push(v as u8);
 }
 
-pub async fn read_varint(stream: &mut TcpStream) -> Result<i32, String> {
+pub async fn read_varint<R: AsyncRead + Unpin>(stream: &mut R) -> Result<i32, String> {
     let mut res = 0;
     for i in 0..5 {
         let b = stream.read_u8().await.map_err(|e| e.to_string())?;

src/tasks.rs

@@ -83,20 +83,18 @@ pub async fn run_query(target: String) {
     }).await;
 }
 
-pub async fn run_join(target: String) {
+pub async fn run_join(target: String, protocol: i32) {
     TaskManager::spawn("Join", move |_cancel_token| async move {
         logger::info(format!("Starting Join-Check for {}", target.clone().hex(DefaultColor::Highlight.hex())))
             .prefix("Join").send().await;
-        logger::warning("Please note this feature is in development".on_yellow())
-            .prefix("Join").send().await;
 
         let parts = target.split(':').collect::<Vec<&str>>();
         let ip = Ipv4Addr::from_str(parts[0]).unwrap(); // TODO
         let port = parts.get(1).and_then(|p| p.parse::<u16>().ok()).unwrap_or(25565);
 
         let username = "ServerRawler";
 
-        match execute_join_check(ip, port, Duration::from_secs(7), username, 770).await {
+        match execute_join_check(ip, port, Duration::from_secs(7), username, protocol).await {
             Ok(result) => {
                 logger::success(format!("Join-Check completed for {}:", target.hex(DefaultColor::Highlight.hex())))
                     .prefix("Join").send().await;