caching ips & other things

MeiNanziiii · MeiNanziiii · commit 5c0f9117ec3d · 2024-10-07T21:34:48.000+03:00
diff --git a/src/main/java/ua/mei/minekord/mixin/PlayerManagerMixin.java b/src/main/java/ua/mei/minekord/mixin/PlayerManagerMixin.java
@@ -0,0 +1,30 @@
+package ua.mei.minekord.mixin;
+
+import com.mojang.authlib.GameProfile;
+import net.minecraft.server.PlayerManager;
+import net.minecraft.text.Text;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import ua.mei.minekord.bot.DiscordUtils;
+import ua.mei.minekord.config.AuthSpec;
+import ua.mei.minekord.config.MinekordConfigKt;
+import ua.mei.minekord.event.IPCheckEvent;
+
+import java.net.SocketAddress;
+
+@Mixin(PlayerManager.class)
+public class PlayerManagerMixin {
+    @Inject(method = "checkCanJoin", at = @At("RETURN"), cancellable = true)
+    private void minekord$checkRoles(SocketAddress socketAddress, GameProfile gameProfile, CallbackInfoReturnable<Text> cir) {
+        if (cir.getReturnValue() == null) {
+            if (!MinekordConfigKt.getConfig().get(AuthSpec.INSTANCE.getUuidFromSnowflake()) && !MinekordConfigKt.getConfig().get(AuthSpec.INSTANCE.getRequiredRoles()).isEmpty()) {
+                if (DiscordUtils.INSTANCE.getPlayer(gameProfile.getName()) == null) {
+                    cir.setReturnValue(Text.translatable("multiplayer.disconnect.generic"));
+                }
+            }
+            IPCheckEvent.Companion.getEvent().invoker().request(socketAddress, gameProfile);
+        }
+    }
+}
diff --git a/src/main/java/ua/mei/minekord/mixin/ServerLoginNetworkHandlerMixin.java b/src/main/java/ua/mei/minekord/mixin/ServerLoginNetworkHandlerMixin.java
@@ -12,7 +12,9 @@
 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 ua.mei.minekord.bot.DiscordUtils;
+import ua.mei.minekord.config.AuthSpec;
+import ua.mei.minekord.config.MinekordConfigKt;
 
 import java.util.UUID;
 
@@ -34,13 +36,13 @@ public abstract class ServerLoginNetworkHandlerMixin {
 
     @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())) {
+        if (MinekordConfigKt.getConfig().get(AuthSpec.INSTANCE.getUuidFromSnowflake())) {
+            if (this.server.isOnlineMode() && !MinekordConfigKt.getConfig().get(AuthSpec.INSTANCE.getAllowOfflinePlayers()) && !DiscordUtils.INSTANCE.premiumPlayer(loginHelloC2SPacket.comp_907())) {
                 this.disconnect(Text.translatable("multiplayer.disconnect.generic"));
                 ci.cancel();
             }
 
-            UUID trueUuid = SnowflakeToUUID.INSTANCE.generateFromNickname(loginHelloC2SPacket.comp_765());
+            UUID trueUuid = DiscordUtils.INSTANCE.generateFromNickname(loginHelloC2SPacket.comp_765());
 
             if (trueUuid != null) {
                 this.profile = new GameProfile(trueUuid, loginHelloC2SPacket.comp_765());
@@ -52,13 +54,4 @@ public abstract class ServerLoginNetworkHandlerMixin {
             ci.cancel();
         }
     }
-
-    @Inject(method = "sendSuccessPacket", at = @At("HEAD"))
-    private void minekord$checkRoles(GameProfile gameProfile, CallbackInfo ci) {
-        if (!SnowflakeToUUID.INSTANCE.enabled()) {
-            if (SnowflakeToUUID.INSTANCE.getPlayer(gameProfile.getName()) == null) {
-                this.disconnect(Text.translatable("multiplayer.disconnect.generic"));
-            }
-        }
-    }
 }
diff --git a/src/main/kotlin/ua/mei/minekord/Minekord.kt b/src/main/kotlin/ua/mei/minekord/Minekord.kt
@@ -6,6 +6,8 @@ import net.fabricmc.loader.api.FabricLoader
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.Logger
 import ua.mei.minekord.bot.MinekordBot
+import ua.mei.minekord.cache.IPCache
+import ua.mei.minekord.config.AuthSpec
 import ua.mei.minekord.config.CONFIG_PATH
 import ua.mei.minekord.config.config
 import java.nio.file.Files
@@ -27,6 +29,8 @@ object Minekord : ModInitializer {
 
         config.validateRequired()
 
-        ServerLifecycleEvents.SERVER_STARTING.register { MinekordBot.launchBot() }
+        if (config[AuthSpec.loginByIp]) IPCache.load()
+
+        MinekordBot.launchBot()
     }
 }
diff --git a/src/main/kotlin/ua/mei/minekord/bot/DiscordUtils.kt b/src/main/kotlin/ua/mei/minekord/bot/DiscordUtils.kt
@@ -1,25 +1,20 @@
-package ua.mei.minekord.auth
+package ua.mei.minekord.bot
 
 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.request.get
 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]
+object DiscordUtils {
+    private val client: HttpClient = HttpClient()
 
     fun premiumPlayer(uuid: UUID): Boolean {
         return runBlocking {
@@ -47,14 +42,14 @@ object SnowflakeToUUID {
             try {
                 val member: Member = getPlayer(nickname) ?: return@runBlocking null
 
-                generateFromId(member.id.value)
+                discordToUuid(member.id.value)
             } catch (_: Throwable) {
                 null
             }
         }
     }
 
-    fun generateFromId(discordId: ULong): UUID {
+    fun discordToUuid(discordId: ULong): UUID {
         val mostSigBytes: ByteArray = ByteArray(8) { (discordId shr ((7 - it) * 8) and 0xFFu).toByte() }
         val leastSigBytes: ByteArray = mostSigBytes.map { it.inv() }.toByteArray()
 
@@ -63,4 +58,11 @@ object SnowflakeToUUID {
 
         return UUID(mostSigBits, leastSigBits)
     }
+
+    fun uuidToDiscord(uuid: UUID): ULong {
+        val mostSigBits: Long = uuid.mostSignificantBits
+        val mostSigBytes: ByteArray = ByteArray(8) { i -> ((mostSigBits shr ((7 - i) * 8)) and 0xFF).toByte() }
+
+        return mostSigBytes.fold(0u) { acc, byte -> (acc shl 8) or (byte.toULong() and 0xFFu) }
+    }
 }
diff --git a/src/main/kotlin/ua/mei/minekord/bot/MinekordBot.kt b/src/main/kotlin/ua/mei/minekord/bot/MinekordBot.kt
@@ -1,25 +1,29 @@
 package ua.mei.minekord.bot
 
 import dev.kord.core.entity.Guild
+import dev.kord.core.entity.channel.TextChannel
 import dev.kordex.core.ExtensibleBot
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import ua.mei.minekord.bot.extensions.IPCheckExtension
 import ua.mei.minekord.config.BotSpec
 import ua.mei.minekord.config.config
-import ua.mei.minekord.extensions.StartupExtension
+import ua.mei.minekord.bot.extensions.SetupExtension
 import kotlin.coroutines.CoroutineContext
 
 object MinekordBot : CoroutineScope {
     lateinit var bot: ExtensibleBot
 
     var guild: Guild? = null
+    var chat: TextChannel? = null
 
     fun launchBot() {
         launch {
             bot = ExtensibleBot(config[BotSpec.token]) {
                 extensions {
-                    add(::StartupExtension)
+                    add(::SetupExtension)
+                    add(::IPCheckExtension)
                 }
             }
 
diff --git a/src/main/kotlin/ua/mei/minekord/bot/extensions/IPCheckExtension.kt b/src/main/kotlin/ua/mei/minekord/bot/extensions/IPCheckExtension.kt
@@ -0,0 +1,65 @@
+package ua.mei.minekord.bot.extensions
+
+import dev.kord.common.entity.ButtonStyle
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.behavior.channel.createEmbed
+import dev.kord.core.behavior.channel.createMessage
+import dev.kord.core.entity.User
+import dev.kord.rest.builder.message.actionRow
+import dev.kord.rest.builder.message.embed
+import dev.kordex.core.components.components
+import dev.kordex.core.components.publicButton
+import dev.kordex.core.extensions.Extension
+import io.ktor.util.network.address
+import kotlinx.coroutines.launch
+import ua.mei.minekord.bot.DiscordUtils
+import ua.mei.minekord.bot.MinekordBot
+import ua.mei.minekord.cache.IPCache
+import ua.mei.minekord.event.IPCheckEvent
+
+class IPCheckExtension : Extension() {
+    override val name: String = "IP Check Extension"
+
+    override suspend fun setup() {
+        IPCheckEvent.event.register { address, profile ->
+            MinekordBot.launch {
+                try {
+                    val discordId: ULong = DiscordUtils.uuidToDiscord(profile.id)
+                    val user: User? = kord.getUser(Snowflake(discordId))
+
+                    user?.getDmChannelOrNull()?.createMessage {
+                        embed {
+                            title = "Join with new IP"
+                            description = "This is your IP?\n> ${address.address}"
+                        }
+                        components {
+                            publicButton {
+                                label = "Yes"
+                                style = ButtonStyle.Success
+
+                                action {
+                                    IPCache.putIntoCache(profile.id, address.address)
+                                    respond {
+                                        content = "ІДІ НАХУЙ"
+                                    }
+                                }
+                            }
+                            publicButton {
+                                label = "No"
+                                style = ButtonStyle.Danger
+
+                                action {
+                                    respond {
+                                        content = "ІДІ НАХУЙ"
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } catch (_: Exception) {
+
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/kotlin/ua/mei/minekord/bot/extensions/SetupExtension.kt b/src/main/kotlin/ua/mei/minekord/bot/extensions/SetupExtension.kt
@@ -1,15 +1,17 @@
-package ua.mei.minekord.extensions
+package ua.mei.minekord.bot.extensions
 
 import dev.kord.common.entity.Snowflake
+import dev.kord.core.entity.channel.TextChannel
 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() {
+class SetupExtension : Extension() {
     override val name: String = "Startup"
 
     override suspend fun setup() {
         MinekordBot.guild = kord.getGuildOrNull(Snowflake(config[BotSpec.guild]))
+        MinekordBot.chat = MinekordBot.guild?.getChannel(Snowflake(config[BotSpec.chat])) as? TextChannel
     }
 }
diff --git a/src/main/kotlin/ua/mei/minekord/cache/IPCache.kt b/src/main/kotlin/ua/mei/minekord/cache/IPCache.kt
@@ -0,0 +1,44 @@
+package ua.mei.minekord.cache
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.stream.JsonReader
+import net.fabricmc.loader.api.FabricLoader
+import java.io.FileReader
+import java.nio.file.Files
+import java.nio.file.Path
+import java.util.UUID
+
+object IPCache {
+    private var cache: MutableMap<UUID, String> = mutableMapOf()
+    val path: Path = FabricLoader.getInstance().gameDir.resolve("ip-cache.json")
+    val gson: Gson = GsonBuilder()
+        .setPrettyPrinting()
+        .create()
+
+    fun load() {
+        if (!Files.exists(path)) {
+            Files.createFile(path)
+            Files.write(path, "{}".toByteArray())
+        }
+        val reader: JsonReader = JsonReader(FileReader(path.toFile()))
+        cache = gson.fromJson(reader, MutableMap::class.java)
+        reader.close()
+    }
+
+    fun save() {
+        if (!Files.exists(path)) {
+            Files.createFile(path)
+        }
+        Files.write(path, gson.toJson(cache).toByteArray())
+    }
+
+    fun putIntoCache(uuid: UUID, ip: String) {
+        cache[uuid] = ip
+        save()
+    }
+
+    fun getFromCache(uuid: UUID): String {
+        return cache[uuid] ?: ""
+    }
+}
diff --git a/src/main/kotlin/ua/mei/minekord/event/IPCheckEvent.kt b/src/main/kotlin/ua/mei/minekord/event/IPCheckEvent.kt
@@ -0,0 +1,20 @@
+package ua.mei.minekord.event
+
+import com.mojang.authlib.GameProfile
+import net.fabricmc.fabric.api.event.Event
+import net.fabricmc.fabric.api.event.EventFactory
+import java.net.SocketAddress
+
+fun interface IPCheckEvent {
+    fun request(address: SocketAddress, profile: GameProfile)
+
+    companion object {
+        val event: Event<IPCheckEvent> = EventFactory.createArrayBacked(IPCheckEvent::class.java) { listeners ->
+            IPCheckEvent { address, profile ->
+                listeners.forEach { listener ->
+                    listener.request(address, profile)
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/resources/minekord.mixins.json b/src/main/resources/minekord.mixins.json
@@ -4,6 +4,7 @@
     "package": "ua.mei.minekord.mixin",
     "compatibilityLevel": "JAVA_21",
     "mixins": [
+        "PlayerManagerMixin",
         "ServerLoginNetworkHandlerMixin"
     ],
     "injectors": {
