Stable

.gitignore

@@ -0,0 +1,119 @@
+# User-specific stuff
+.idea/
+
+*.iml
+*.ipr
+*.iws
+
+# IntelliJ
+out/
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+.gradle
+build/
+
+# Ignore Gradle GUI config
+gradle-app.setting
+
+# Cache of project
+.gradletasknamecache
+
+**/build/
+
+# Common working directory
+run/
+runs/
+
+# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
+!gradle-wrapper.jar

LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Verox
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

build.gradle

@@ -0,0 +1,92 @@
+plugins {
+    id 'fabric-loom' version '1.11-SNAPSHOT'
+    id 'maven-publish'
+}
+
+version = project.mod_version
+group = project.maven_group
+
+base {
+    archivesName = project.archives_base_name
+}
+
+
+repositories {
+    // Add repositories to retrieve artifacts from in here.
+    // You should only use this when depending on other mods because
+    // Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
+    // See https://docs.gradle.org/current/userguide/declaring_repositories.html
+    // for more information about repositories.
+}
+
+dependencies {
+    // To change the versions see the gradle.properties file
+    minecraft "com.mojang:minecraft:${project.minecraft_version}"
+    mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
+    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
+
+    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
+
+    implementation("com.electronwill.night-config:core:3.8.2")
+    implementation("com.electronwill.night-config:json:3.8.2")
+}
+
+processResources {
+    inputs.property "version", project.version
+    inputs.property "minecraft_version", project.minecraft_version
+    inputs.property "loader_version", project.loader_version
+    filteringCharset "UTF-8"
+
+    filesMatching("fabric.mod.json") {
+        expand "version": project.version,
+                "minecraft_version": project.minecraft_version,
+                "loader_version": project.loader_version
+    }
+}
+
+def targetJavaVersion = 21
+tasks.withType(JavaCompile).configureEach {
+    // ensure that the encoding is set to UTF-8, no matter what the system default is
+    // this fixes some edge cases with special characters not displaying correctly
+    // see http://yodaconditions.net/blog/fix-for-java-file-encoding-problems-with-gradle.html
+    // If Javadoc is generated, this must be specified in that task too.
+    it.options.encoding = "UTF-8"
+    if (targetJavaVersion >= 10 || JavaVersion.current().isJava10Compatible()) {
+        it.options.release.set(targetJavaVersion)
+    }
+}
+
+java {
+    def javaVersion = JavaVersion.toVersion(targetJavaVersion)
+    if (JavaVersion.current() < javaVersion) {
+        toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
+    }
+    // Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
+    // if it is present.
+    // If you remove this line, sources will not be generated.
+    withSourcesJar()
+}
+
+jar {
+    from("LICENSE") {
+        rename { "${it}_${project.archivesBaseName}" }
+    }
+}
+
+// configure the maven publication
+publishing {
+    publications {
+        create("mavenJava", MavenPublication) {
+            artifactId = project.archives_base_name
+            from components.java
+        }
+    }
+
+    // See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
+    repositories {
+        // Add repositories to publish to here.
+        // Notice: This block does NOT have the same function as the block in the top level.
+        // The repositories here will be used for publishing your artifact, not for
+        // retrieving dependencies.
+    }
+}

gradle.properties

@@ -0,0 +1,14 @@
+# Done to increase the memory available to gradle.
+org.gradle.jvmargs=-Xmx1G
+# Fabric Properties
+# check these on https://modmuss50.me/fabric.html
+minecraft_version=1.21.5
+yarn_mappings=1.21.5+build.1
+loader_version=0.16.14
+# Mod Properties
+mod_version=1.0.0
+maven_group=com.cimeyclust
+archives_base_name=EZCheat
+# Dependencies
+# check this on https://modmuss50.me/fabric.html
+fabric_version=0.128.1+1.21.5

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1 @@
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.1-bin.zip

settings.gradle

@@ -0,0 +1,9 @@
+pluginManagement {
+    repositories {
+        maven {
+            name = 'Fabric'
+            url = 'https://maven.fabricmc.net/'
+        }
+        gradlePluginPortal()
+    }
+}

src/main/java/com/cimeyclust/ezcheat/Config.java

@@ -0,0 +1,32 @@
+package com.cimeyclust.ezcheat;
+
+import com.electronwill.nightconfig.core.file.CommentedFileConfig;
+import com.electronwill.nightconfig.core.file.FileConfig;
+import com.electronwill.nightconfig.core.io.WritingMode;
+import net.fabricmc.loader.api.FabricLoader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.file.Path;
+
+public class Config {
+    private static final Logger LOGGER = LoggerFactory.getLogger("ezcheat");
+    private static final Path CONFIG_PATH =
+            FabricLoader.getInstance().getConfigDir().resolve("ezcheat.json");
+
+    public static String MOD_ENDPOINT_URL = "https://modlist.ugasmp.com/api/mods";
+
+    public static void load() {
+        var cfg = FileConfig.builder(CONFIG_PATH)
+                .sync()
+                .autosave()
+                .writingMode(WritingMode.REPLACE)
+                .build();
+
+        cfg.load();
+        MOD_ENDPOINT_URL = cfg.getOrElse("modEndpointUrl",
+                "https://modlist.ugasmp.com/api/mods");
+        cfg.save();
+        LOGGER.info("Loaded config: modEndpointUrl={}", MOD_ENDPOINT_URL);
+    }
+}

src/main/java/com/cimeyclust/ezcheat/Ezcheat.java

@@ -0,0 +1,135 @@
+package com.cimeyclust.ezcheat;
+
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
+import net.fabricmc.fabric.api.networking.v1.*;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.network.ServerPlayNetworkHandler;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.text.Text;
+import net.minecraft.util.Identifier;
+import org.apache.commons.codec.digest.DigestUtils;
+import org.apache.logging.log4j.core.jmx.Server;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.lang.reflect.Type;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class Ezcheat implements ModInitializer {
+    public static final String MODID = "ezcheat";
+    public static final Logger LOGGER = LoggerFactory.getLogger(MODID);
+    private static final Gson GSON = new Gson();
+    private static final Map<UUID, Long> pendingChecks = new ConcurrentHashMap<>();
+
+    @Override
+    public void onInitialize() {
+        ServerPlayConnectionEvents.JOIN.register(this::onPlayerJoin);
+        ServerTickEvents.END_SERVER_TICK.register(this::onServerTick);
+
+        PayloadTypeRegistry.playC2S().register(EzcheatPayload.ID, EzcheatPayload.CODEC);
+
+        ServerPlayNetworking.registerGlobalReceiver(EzcheatPayload.ID, (payload, context) -> {
+            context.server().execute(() -> {
+                ServerPlayNetworkHandler handler = context.player().networkHandler;
+                MinecraftServer server = handler.player.getServer();
+                UUID uuid = handler.player.getUuid();
+
+                // check if we have a pending check for this player
+                if (pendingChecks.containsKey(uuid)) {
+                    pendingChecks.remove(uuid);
+                    verifyPlayerMods(handler.player, payload.hashes());
+                } else {
+                    LOGGER.warn("Received mod hashes from {} without a pending check", handler.player.getName().getString());
+                }
+            });
+        });
+
+        // load config
+        Config.load();
+        LOGGER.info("Ezcheat initialized; endpoint = {}", Config.MOD_ENDPOINT_URL);
+    }
+
+    private void onPlayerJoin(ServerPlayNetworkHandler handler, PacketSender sender, MinecraftServer server) {
+        if (server.isSingleplayer()) {
+            LOGGER.debug("Skipping mod check for singleplayer");
+            return;
+        }
+        UUID uuid = handler.player.getUuid();
+        pendingChecks.put(uuid, System.currentTimeMillis());
+        LOGGER.debug("Pending mod check for {}", handler.player.getName().getString());
+    }
+
+    private void onServerTick(MinecraftServer server) {
+        long now = System.currentTimeMillis();
+        pendingChecks.entrySet().removeIf(entry -> {
+            if (now - entry.getValue() > 10_000) {
+                ServerPlayerEntity p = server.getPlayerManager().getPlayer(entry.getKey());
+                if (p != null) {
+                    p.networkHandler.disconnect(Text.literal("You must have Ezcheat installed (If you do, maybe there was an issue with your connection. Please try to join again in that case)."));
+                    LOGGER.info("Kicked {} for not sending mod hashes in time", p.getName().getString());
+                }
+                return true;
+            }
+            return false;
+        });
+    }
+
+    private String mapToString(Map<String, String> map) {
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<String, String> entry : map.entrySet()) {
+            sb.append(entry.getKey()).append("=").append(entry.getValue()).append(", ");
+        }
+        return sb.toString();
+    }
+
+    private void verifyPlayerMods(ServerPlayerEntity player, Map<String, String> hashes) {
+        LOGGER.info("Verifying mod hashes: {}", mapToString(hashes));
+        try {
+            // fetch allowed list
+            HttpURLConnection conn = (HttpURLConnection) new URL(Config.MOD_ENDPOINT_URL).openConnection();
+            conn.setRequestMethod("GET");
+            conn.setDoInput(true);
+
+            try (InputStream is = conn.getInputStream();
+                 Reader rdr = new InputStreamReader(is)) {
+                Type mapType = new TypeToken<Map<String, String>>() {
+                }.getType();
+                Map<String, String> allowed = GSON.fromJson(rdr, mapType);
+
+                List<String> bad = new ArrayList<>();
+                for (var e : hashes.entrySet()) {
+                    String modid = e.getKey(), hash = e.getValue();
+                    if (!allowed.containsValue(hash)) {
+                        bad.add(modid);
+                    }
+                }
+
+                if (!bad.isEmpty()) {
+                    String msg = "Unallowed mods: " + String.join(", ", bad);
+                    player.networkHandler.disconnect(Text.literal(msg));
+                    LOGGER.info("Kicked {} for unallowed mods: {}", player.getName().getString(), bad);
+                } else {
+                    LOGGER.info("{} passed mod check", player.getName().getString());
+                }
+            }
+        } catch (IOException e) {
+            LOGGER.error("Failed mod verification for {}: {}", player.getName().getString(), e.getMessage());
+        }
+    }
+}

src/main/java/com/cimeyclust/ezcheat/EzcheatPayload.java

@@ -0,0 +1,42 @@
+package com.cimeyclust.ezcheat;
+
+import net.minecraft.network.RegistryByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.packet.CustomPayload;
+import net.minecraft.util.Identifier;
+import java.util.HashMap;
+import java.util.Map;
+
+public record EzcheatPayload(Map<String, String> hashes) implements CustomPayload {
+    public static final CustomPayload.Id<EzcheatPayload> ID =
+            new CustomPayload.Id<>(Identifier.of(Ezcheat.MODID, "mod_hashes"));
+
+    public static final PacketCodec<RegistryByteBuf, EzcheatPayload> CODEC = new PacketCodec<>() {
+        @Override
+        public void encode(RegistryByteBuf buf, EzcheatPayload value) {
+            Map<String, String> hashes = value.hashes();
+            buf.writeVarInt(hashes.size());
+            for (Map.Entry<String, String> entry : hashes.entrySet()) {
+                buf.writeString(entry.getKey());
+                buf.writeString(entry.getValue());
+            }
+        }
+
+        @Override
+        public EzcheatPayload decode(RegistryByteBuf buf) {
+            int size = buf.readVarInt();
+            Map<String, String> hashes = new HashMap<>();
+            for (int i = 0; i < size; i++) {
+                String key = buf.readString();
+                String value = buf.readString();
+                hashes.put(key, value);
+            }
+            return new EzcheatPayload(hashes);
+        }
+    };
+
+    @Override
+    public CustomPayload.Id<? extends CustomPayload> getId() {
+        return ID;
+    }
+}

src/main/java/com/cimeyclust/ezcheat/client/EzcheatClient.java

@@ -0,0 +1,68 @@
+package com.cimeyclust.ezcheat.client;
+
+import com.cimeyclust.ezcheat.Ezcheat;
+import com.cimeyclust.ezcheat.EzcheatPayload;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
+import net.fabricmc.loader.api.FabricLoader;
+import org.apache.commons.codec.digest.DigestUtils;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
+
+public class EzcheatClient implements ClientModInitializer {
+
+    @Override
+    public void onInitializeClient() {
+        ClientPlayConnectionEvents.JOIN.register((handler, sender, client) -> {
+            if (!client.isInSingleplayer()) {
+                this.sendHashes();
+            }
+        });
+    }
+
+    /** Called client‑side to compute & send hashes */
+    private void sendHashes() {
+        // gather mod files
+        Path modsDir = FabricLoader.getInstance()
+                .getGameDir()
+                .resolve("mods")
+                .toAbsolutePath();
+
+        Map<String, String> hashes = new HashMap<>();
+        for (var mod : FabricLoader.getInstance().getAllMods()) {
+            try {
+                Path path = null;
+                var paths = mod.getOrigin().getPaths();
+                for (Path p : paths) {
+                    if (Files.isRegularFile(p)) {
+                        path = p;
+                        break;
+                    }
+                }
+
+                if (path == null) {
+                    Ezcheat.LOGGER.debug("Skipping mod {}: No valid path", mod.getMetadata().getId());
+                    continue;
+                }
+
+                if (path.startsWith(modsDir)) {
+                    try (InputStream in = Files.newInputStream(path)) {
+                        hashes.put(mod.getMetadata().getId(), DigestUtils.sha256Hex(in));
+                    }
+                }
+            } catch (IOException e) {
+                Ezcheat.LOGGER.warn("Could not hash {}: {}", mod.getMetadata().getId(), e.getMessage());
+            }
+        }
+
+        EzcheatPayload payload = new EzcheatPayload(hashes);
+        ClientPlayNetworking.send(payload);
+    }
+}

src/main/resources/fabric.mod.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 1,
+  "id": "ezcheat",
+  "version": "${version}",
+  "name": "EZCheat",
+  "description": "An easy AntiCheat based on Mod-Whitelists",
+  "authors": [],
+  "contact": {},
+  "license": "MIT",
+  "icon": "assets/ezcheat/icon.png",
+  "environment": "*",
+  "entrypoints": {
+    "client": [
+      "com.cimeyclust.ezcheat.client.EzcheatClient"
+    ],
+    "main": [
+      "com.cimeyclust.ezcheat.Ezcheat"
+    ]
+  },
+  "depends": {
+    "fabricloader": ">=${loader_version}",
+    "fabric": "*",
+    "minecraft": "${minecraft_version}"
+  }
+}