generating uuid based on discord user id

Author: MeiNanziiii

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

@@ -0,0 +1,45 @@
+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;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import ua.mei.minekord.auth.SnowflakeToUUID;
+
+import java.util.UUID;
+
+@Mixin(ServerLoginNetworkHandler.class)
+public abstract class ServerLoginNetworkHandlerMixin {
+    @Shadow public abstract void disconnect(Text text);
+
+    @Shadow @Nullable private GameProfile profile;
+
+    @Shadow protected abstract void sendSuccessPacket(GameProfile gameProfile);
+
+    @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()) {
+            UUID trueUuid = SnowflakeToUUID.INSTANCE.generateFromNickname(loginHelloC2SPacket.comp_765());
+
+            if (trueUuid != null) {
+                this.profile = new GameProfile(trueUuid, loginHelloC2SPacket.comp_765());
+                sendSuccessPacket(this.profile);
+            } else {
+                this.disconnect(Text.literal("lol"));
+            }
+
+            ci.cancel();
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+package ua.mei.minekord.auth
+
+import dev.kord.common.annotation.KordExperimental
+import dev.kord.core.entity.Member
+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
+
+object SnowflakeToUUID {
+    fun enabled(): Boolean = config[AuthSpec.uuidFromSnowflake]
+
+    @OptIn(KordExperimental::class)
+    fun generateFromNickname(nickname: String): UUID? {
+        return runBlocking {
+            return@runBlocking try {
+                val member: Member = MinekordBot.guild?.getMembers(nickname)?.filter {
+                    it.roleIds.map { it.value }.all { it in config[AuthSpec.requiredRoles] }
+                }?.firstOrNull() ?: return@runBlocking null
+
+                generateFromId(member.id.value)
+            } catch (_: Throwable) {
+                null
+            }
+        }
+    }
+
+    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 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) }
+
+        return UUID(mostSigBits, leastSigBits)
+    }
+}

src/main/kotlin/ua/mei/minekord/bot/MinekordBot.kt

@@ -1,21 +1,25 @@
 package ua.mei.minekord.bot
 
+import dev.kord.core.entity.Guild
 import dev.kordex.core.ExtensibleBot
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import ua.mei.minekord.config.BotSpec
 import ua.mei.minekord.config.config
+import ua.mei.minekord.extensions.StartupExtension
 import kotlin.coroutines.CoroutineContext
 
 object MinekordBot : CoroutineScope {
     lateinit var bot: ExtensibleBot
 
+    var guild: Guild? = null
+
     fun launchBot() {
         launch {
             bot = ExtensibleBot(config[BotSpec.token]) {
-                members {
-                    fill(config[BotSpec.guild])
+                extensions {
+                    add(::StartupExtension)
                 }
             }
 
@@ -24,4 +28,4 @@ object MinekordBot : CoroutineScope {
     }
 
     override val coroutineContext: CoroutineContext = Dispatchers.Default
-}
+}

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

@@ -0,0 +1,8 @@
+package ua.mei.minekord.config
+
+import com.uchuhimo.konf.ConfigSpec
+
+object AuthSpec : ConfigSpec() {
+    val uuidFromSnowflake by required<Boolean>()
+    val requiredRoles by required<List<ULong>>()
+}

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

@@ -6,4 +6,4 @@ object BotSpec : ConfigSpec() {
     val token by required<String>()
     val guild by required<ULong>()
     val chat by required<ULong>()
-}
+}

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

@@ -6,6 +6,6 @@ import net.fabricmc.loader.api.FabricLoader
 
 const val CONFIG_PATH: String = "minekord.toml"
 
-val config: Config = Config { addSpec(BotSpec) }
+val config: Config = Config { addSpec(BotSpec); addSpec(AuthSpec) }
     .from.toml.resource(CONFIG_PATH)
     .from.toml.watchFile(FabricLoader.getInstance().configDir.resolve(CONFIG_PATH).toFile())

src/main/kotlin/ua/mei/minekord/extensions/StartupExtension.kt

@@ -0,0 +1,15 @@
+package ua.mei.minekord.extensions
+
+import dev.kord.common.entity.Snowflake
+import dev.kordex.core.extensions.Extension
+import ua.mei.minekord.bot.MinekordBot
+import ua.mei.minekord.config.BotSpec
+import ua.mei.minekord.config.config
+
+class StartupExtension : Extension() {
+    override val name: String = "Startup"
+
+    override suspend fun setup() {
+        MinekordBot.guild = kord.getGuildOrNull(Snowflake(config[BotSpec.guild]))
+    }
+}

src/main/resources/minekord.mixins.json

@@ -4,8 +4,7 @@
     "package": "ua.mei.minekord.mixin",
     "compatibilityLevel": "JAVA_21",
     "mixins": [
-    ],
-    "client": [
+        "ServerLoginNetworkHandlerMixin"
     ],
     "injectors": {
         "defaultRequire": 1

src/main/resources/minekord.toml

@@ -3,3 +3,14 @@
 token = ""
 guild = 0
 chat = 0
+
+[Auth]
+
+# If true, player UUID will be generated by they Discord ID.
+# If user doens't exists in guild with player nickname, player will be kicked.
+# Works with offline and online mode.
+uuidFromSnowflake = false
+
+# Roles which required for server join.
+# Can be empty.
+requiredRoles = []