check for offline players & optimization

Author: MeiNanziiii

src/main/java/ua/mei/minekord/mixin/ServerLoginNetworkHandlerMixin.java

@@ -1,10 +1,7 @@
 package ua.mei.minekord.mixin;
 
 import com.mojang.authlib.GameProfile;
-import net.minecraft.network.ClientConnection;
 import net.minecraft.network.packet.c2s.login.LoginHelloC2SPacket;
-import net.minecraft.network.packet.s2c.login.LoginHelloS2CPacket;
-import net.minecraft.network.packet.s2c.login.LoginSuccessS2CPacket;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerLoginNetworkHandler;
 import net.minecraft.text.Text;
@@ -27,16 +24,23 @@ public abstract class ServerLoginNetworkHandlerMixin {
 
     @Shadow protected abstract void sendSuccessPacket(GameProfile gameProfile);
 
+    @Shadow @Final MinecraftServer server;
+
     @Inject(method = "onHello", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/MinecraftServer;isOnlineMode()Z"), cancellable = true)
     private void minekord$trueUuids(LoginHelloC2SPacket loginHelloC2SPacket, CallbackInfo ci) {
         if (SnowflakeToUUID.INSTANCE.enabled()) {
+            if (this.server.isOnlineMode() && !SnowflakeToUUID.INSTANCE.allowOfflinePlayers() && !SnowflakeToUUID.INSTANCE.premiumPlayer(loginHelloC2SPacket.comp_907())) {
+                this.disconnect(Text.literal("test1"));
+                ci.cancel();
+            }
+
             UUID trueUuid = SnowflakeToUUID.INSTANCE.generateFromNickname(loginHelloC2SPacket.comp_765());
 
             if (trueUuid != null) {
                 this.profile = new GameProfile(trueUuid, loginHelloC2SPacket.comp_765());
-                sendSuccessPacket(this.profile);
+                this.sendSuccessPacket(this.profile);
             } else {
-                this.disconnect(Text.literal("lol"));
+                this.disconnect(Text.literal("test2"));
             }
 
             ci.cancel();

src/main/kotlin/ua/mei/minekord/auth/SnowflakeToUUID.kt

@@ -2,21 +2,42 @@ package ua.mei.minekord.auth
 
 import dev.kord.common.annotation.KordExperimental
 import dev.kord.core.entity.Member
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.okhttp.OkHttp
+import io.ktor.client.plugins.timeout
+import io.ktor.client.request.get
+import io.ktor.client.statement.HttpResponse
+import io.ktor.http.HttpStatusCode
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.runBlocking
 import ua.mei.minekord.bot.MinekordBot
 import ua.mei.minekord.config.AuthSpec
 import ua.mei.minekord.config.config
 import java.util.UUID
+import kotlin.experimental.inv
 
 object SnowflakeToUUID {
+    private val client: HttpClient = HttpClient(OkHttp)
+
     fun enabled(): Boolean = config[AuthSpec.uuidFromSnowflake]
+    fun allowOfflinePlayers(): Boolean = config[AuthSpec.allowOfflinePlayers]
+
+    fun premiumPlayer(uuid: UUID): Boolean {
+        return runBlocking {
+            try {
+                client.get("https://sessionserver.mojang.com/session/minecraft/profile/$uuid")
+                    .status == HttpStatusCode.OK
+            } catch (_: Exception) {
+                false
+            }
+        }
+    }
 
     @OptIn(KordExperimental::class)
     fun generateFromNickname(nickname: String): UUID? {
         return runBlocking {
-            return@runBlocking try {
+            try {
                 val member: Member = MinekordBot.guild?.getMembers(nickname)?.filter {
                     it.roleIds.map { it.value }.all { it in config[AuthSpec.requiredRoles] }
                 }?.firstOrNull() ?: return@runBlocking null
@@ -29,8 +50,8 @@ object SnowflakeToUUID {
     }
 
     fun generateFromId(discordId: ULong): UUID {
-        val mostSigBytes: ByteArray = ByteArray(8) { i -> (discordId shr ((7 - i) * 8) and 0xFFu).toByte() }
-        val leastSigBytes: ByteArray = ByteArray(8) { i -> ((ULong.MAX_VALUE - discordId) shr ((7 - i) * 8) and 0xFFu).toByte() }
+        val mostSigBytes: ByteArray = ByteArray(8) { (discordId shr ((7 - it) * 8) and 0xFFu).toByte() }
+        val leastSigBytes: ByteArray = mostSigBytes.map { it.inv() }.toByteArray()
 
         val mostSigBits: Long = mostSigBytes.fold(0L) { acc, byte -> (acc shl 8) or (byte.toLong() and 0xFF) }
         val leastSigBits: Long = leastSigBytes.fold(0L) { acc, byte -> (acc shl 8) or (byte.toLong() and 0xFF) }

src/main/kotlin/ua/mei/minekord/config/AuthSpec.kt

@@ -4,5 +4,6 @@ import com.uchuhimo.konf.ConfigSpec
 
 object AuthSpec : ConfigSpec() {
     val uuidFromSnowflake by required<Boolean>()
+    val allowOfflinePlayers by required<Boolean>()
     val requiredRoles by required<List<ULong>>()
 }

src/main/resources/minekord.toml

@@ -11,6 +11,9 @@ chat = 0
 # Works with offline and online mode.
 uuidFromSnowflake = false
 
+# If true, offline players can join server if online mode enabled.
+allowOfflinePlayers = false
+
 # Roles which required for server join.
 # Can be empty.
 requiredRoles = []