udpate

Update config.yml to add a hacked client site

.github/workflows/build.yml

@@ -0,0 +1,76 @@
+name: Build Plugin
+
+on:
+  push:
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    if: ${{ github.ref == 'refs/heads/main' }}
+    concurrency:
+      group: ${{ github.workflow }}
+      cancel-in-progress: true
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '17'
+
+      - name: Build Jar
+        run: |
+          gradle wrapper
+          ./gradlew shadowJar
+
+      - name: Publish Jar
+        uses: actions/upload-artifact@v4
+        with:
+          name: OriginBlacklist
+          path: build/libs/OriginBlacklist.jar
+
+      - name: Extract Version
+        id: version
+        run: |
+          VERSION=$(grep "^version" build.gradle | head -n 1 | cut -d\' -f2)
+          echo "version=$VERSION" >> "$GITHUB_OUTPUT"
+
+      - name: Remove Existing Release
+        run: |
+          gh release delete v${{ steps.version.outputs.version }} -y || true
+          git push origin :refs/tags/v${{ steps.version.outputs.version }} || true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create Release
+        id: create_release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: v${{ steps.version.outputs.version }}
+          name: ${{ steps.version.outputs.version }}
+          draft: false
+          prerelease: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: actions/upload-release-asset@v1.0.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./build/libs/OriginBlacklist.jar
+          asset_name: OriginBlacklist_${{ steps.version.outputs.version }}.jar
+          asset_content_type: application/java-archive
+
+      - uses: eregon/publish-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          release_id: ${{ steps.create_release.outputs.id }}

.gitignore

@@ -1,7 +1,9 @@
 **/.DS_Store
 .idea
 .gradle
+gradle
 build
 run
+bin
 gradlew
 gradlew.bat

README.md

@@ -8,23 +8,25 @@ basically just a reimplementation of originblacklist but for eaglerxserver
 ### Features
 - [x] Origin Blacklisting
 - [x] Brand Blacklisting
+- [x] Username blacklisting
+- [x] IP blacklisting
 - [x] Custom kick message
 - [x] Custom blacklist MOTD
 - [x] MiniMessage formatting for messages
-- [x] Velocity, *Bungee, and *Bukkit support
+- [x] Velocity, Bungee, and Bukkit support
-  <br>_<sub><span style="color:gray">Bungee and Bukkit are should work, but have bugs.</span></sub>_
 - [x] Send blacklists to a discord webhook
+- [x] Simple blacklist command
 - [ ] Blacklist subscription URLs
 - [ ] Blacklist -> Whitelist
-- [ ] IP blacklisting
+- [ ] Update system
 
 ### Download
-**[https://github.com/colbster937/originblacklist/releases](https://github.com/colbster937/originblacklist/releases)**
+**[https://github.com/colbster937/originblacklist/releases/latest/](https://github.com/colbster937/originblacklist/releases/latest/)**
 
 ### Building
 ```
 $ git clone https://github.com/colbster937/originblacklist.git
 $ cd originblacklist
 $ gradle wrapper
-$ ./gradle.<bat|sh> shadowJar
+$ ./gradlew shadowJar
 ```

build.gradle

@@ -8,7 +8,9 @@ plugins {
 
 
 group = 'dev.colbster937'
-version = '1.0.1'
+version = '1.1.2'
+description = 'A reimplementation of OriginBlacklist for EaglerXServer'
+def targetJavaVersion = 17
 
 repositories {
     mavenCentral()
@@ -47,47 +49,38 @@ dependencies {
     compileOnly("net.lax1dude.eaglercraft.backend:api-bungee:1.0.0")
     compileOnly("net.lax1dude.eaglercraft.backend:api-bukkit:1.0.0")
     implementation("org.yaml:snakeyaml:2.2")
-    implementation("net.kyori:adventure-api:4.20.0")
     implementation("net.kyori:adventure-text-serializer-legacy:4.20.0")
     implementation("net.kyori:adventure-text-minimessage:4.20.0")
+    implementation("com.github.seancfoley:ipaddress:5.3.4")
 }
 
 tasks {
     runVelocity {
-        // Configure the Velocity version for our task.
-        // This is the only required configuration besides applying the plugin.
-        // Your plugin's jar (or shadowJar if present) will be used automatically.
         velocityVersion("3.3.0-SNAPSHOT")
     }
 }
 
-def targetJavaVersion = 17
 java {
     toolchain.languageVersion = JavaLanguageVersion.of(targetJavaVersion)
 }
 
+processResources {
+    filesMatching(['plugin.yml', 'bungee.yml', 'velocity-plugin.json', 'Base.java']) {
+        expand(
+                version: project.version,
+                description: project.description
+        )
+    }
+}
+
 shadowJar {
     relocate 'org.yaml.snakeyaml', 'dev.colbster937.shaded.snakeyaml'
-    archiveClassifier.set('all')
+    relocate 'inet.ipaddr', 'dev.colbster937.shaded.ipaddr'
+    archiveVersion.set('')
+    archiveClassifier.set('')
 }
 
 tasks.withType(JavaCompile).configureEach {
     options.encoding = 'UTF-8'
     options.release.set(targetJavaVersion)
 }
-
-/*def templateSource = file('src/main/templates')
-def templateDest = layout.buildDirectory.dir('generated/sources/templates')
-def generateTemplates = tasks.register('generateTemplates', Copy) { task ->
-    def props = ['version': project.version]
-    task.inputs.properties props
-
-    task.from templateSource
-    task.into templateDest
-    task.expand props
-}
-
-sourceSets.main.java.srcDir(generateTemplates.map { it.outputs })
-
-project.idea.project.settings.taskTriggers.afterSync generateTemplates
-project.eclipse.synchronizationTasks(generateTemplates)*/

gradle/wrapper/gradle-wrapper.properties

@@ -1,7 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-bin.zip
-networkTimeout=10000
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

src/main/java/dev/colbster937/originblacklist/base/Base.java

@@ -1,31 +1,28 @@
 package dev.colbster937.originblacklist.base;
 
+import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
-import net.lax1dude.eaglercraft.backend.server.api.IEaglerXServerAPI;
+import net.lax1dude.eaglercraft.backend.server.api.*;
-import net.lax1dude.eaglercraft.backend.server.api.IEaglerPlayer;
+import net.lax1dude.eaglercraft.backend.server.api.event.IEaglercraftLoginEvent;
-import net.lax1dude.eaglercraft.backend.server.api.EnumWebSocketHeader;
-import net.lax1dude.eaglercraft.backend.server.api.event.IEaglercraftInitializePlayerEvent;
 import net.lax1dude.eaglercraft.backend.server.api.event.IEaglercraftMOTDEvent;
 import net.lax1dude.eaglercraft.backend.server.api.query.IMOTDConnection;
 
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.net.HttpURLConnection;
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
-import java.io.File;
+import java.io.*;
-import java.io.IOException;
+import java.net.HttpURLConnection;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
 import java.util.List;
+import java.util.concurrent.CompletableFuture;
 import java.util.stream.Collectors;
 
 public class Base {
     private static LoggerAdapter adapter;
     private static IEaglerXServerAPI api;
-    private static ConfigManager config;
+    private static IPBlacklist ipblacklist;
 
     public static void setLogger(LoggerAdapter log) {
         adapter = log;
@@ -35,67 +32,151 @@ public class Base {
         api = api1;
     }
 
+    public static ConfigManager config;
+
+    public static String pluginVer = "1.0.2";
+
+    public static boolean checkVer(String v1, String v2) {
+        String[] c = v1.split("\\.");
+        String[] r = v2.split("\\.");
+        for (int i = 0; i < Math.max(c.length, r.length); i++) {
+            int c1 = i < c.length ? Integer.parseInt(c[i]) : 0;
+            int r1 = i < r.length ? Integer.parseInt(r[i]) : 0;
+            if (c1 < r1)
+                return false;
+            if (c1 > r1)
+                return true;
+        }
+        return true;
+    }
+
     public static LoggerAdapter getLogger() {
-        if (adapter == null) throw new IllegalStateException("Logger not initialized!");
+        if (adapter == null)
+            throw new IllegalStateException("Logger not initialized!");
         return adapter;
     }
 
     public interface LoggerAdapter {
         void info(String msg);
+
         void warn(String msg);
+
         void error(String msg);
     }
 
-    public static void handleConnection(IEaglercraftInitializePlayerEvent e) {
+    public static void handleConnection(IEaglercraftLoginEvent e) {
-        IEaglerPlayer plr = e.getPlayer();
+        IEaglerLoginConnection conn = e.getLoginConnection();
-        String origin = plr.getWebSocketHeader(EnumWebSocketHeader.HEADER_ORIGIN);
+        String origin = conn.getWebSocketHeader(EnumWebSocketHeader.HEADER_ORIGIN);
-        String brand = plr.getEaglerBrandString();
+        String brand = conn.getEaglerBrandString();
-        if ((origin != "null" || origin != null) && !config.blacklist.missing_origin) {
+        String name = conn.getUsername();
+        String ip = getAddr(conn);
+        String notAllowed1 = "not allowed on the server";
+        String notAllowed2 = "not allowed";
+
+        if (origin != null && !origin.equals("null")) {
             for (String origin1 : config.blacklist.origins) {
                 if (matches(origin, origin1)) {
-                    plr.disconnect(kick("origin", "website", origin));
+                    setKick(e, formatKickMessage("origin", "website", notAllowed1, notAllowed2, origin, conn.getWebSocketHost()));
-                    webhook(plr, origin, brand, "origin");
+                    webhook(conn, origin, brand, "origin");
                     return;
                 }
             }
-        } else {
-            plr.disconnect(kick("origin", "website", origin));
-            webhook(plr, "null", brand, "origin");
         }
-        if (brand != "null" && brand != null) {
+
+        if (brand != null && !brand.equals("null")) {
             for (String brand1 : config.blacklist.brands) {
                 if (matches(brand, brand1)) {
-                    plr.disconnect(kick("brand", "client", brand));
+                    setKick(e, formatKickMessage("brand", "client", notAllowed1, notAllowed2, brand, conn.getWebSocketHost()));
-                    webhook(plr, origin, brand, "brand");
+                    webhook(conn, origin, brand, "brand");
                     return;
                 }
             }
         }
+
+        if (name != null && !name.equals("null")) {
+            for (String name1 : config.blacklist.players) {
+                if (matches(name, name1) || (name.length() > 16 || name.length() < 3)) {
+                    setKick(e, formatKickMessage("player", "username", notAllowed1, notAllowed2, name, conn.getWebSocketHost()));
+                    webhook(conn, origin, brand, "player");
+                    return;
+                }
+            }
+        }
+
+        if (ip != null && !ip.equalsIgnoreCase("null")) {
+            if (ipblacklist.check(ip)) {
+                setKick(e, formatKickMessage("ip address", "ip", notAllowed1, notAllowed2, ip, conn.getWebSocketHost()));
+                webhook(conn, origin, brand, "ip");
+            }
+        }
+    }
+
+    public static void setKick(IEaglercraftLoginEvent e, Component msg) {
+        try {
+            getLogger().info("Kicked " + e.getProfileUsername());
+            e.setKickMessage(msg);
+        } catch (Throwable ignored) {
+            String msg1 = LegacyComponentSerializer.legacySection().serialize(msg);
+            e.setKickMessage(msg1);
+        }
     }
 
     public static void handleMOTD(IEaglercraftMOTDEvent e) {
-        if (config.messages.motd.enabled) {
+        if (!config.messages.motd.enabled) return;
+
         IMOTDConnection conn = e.getMOTDConnection();
         String origin = conn.getWebSocketHeader(EnumWebSocketHeader.HEADER_ORIGIN);
+        String host = conn.getWebSocketHost() != null ? conn.getWebSocketHost() : "";
+        String ip = getAddr(conn);
+
+        String blocktype1 = null;
+        String easyblocktype1 = null;
+        String blocked1 = null;
+
+        if (origin != null && !"null".equals(origin)) {
+            for (String origin2 : config.blacklist.origins) {
+                if (matches(origin, origin2)) {
+                    blocktype1 = "origin";
+                    easyblocktype1 = "website";
+                    blocked1 = origin;
+                    break;
+                }
+            }
+        }
+
+        if (blocktype1 == null && ip != null && !"null".equalsIgnoreCase(ip)) {
+            boolean blocked = ipblacklist != null && ipblacklist.check(ip);
+            if (!blocked) {
+                for (String ip2 : config.blacklist.ips) {
+                    if (matches(ip, ip2)) { blocked = true; break; }
+                }
+            }
+            if (blocked) {
+                blocktype1 = "ip address";
+                easyblocktype1 = "ip";
+                blocked1 = ip;
+            }
+        }
+
+        if (blocktype1 == null) return;
+
+        final String finalBlocktype = blocktype1;
+        final String finalEasyblocktype = easyblocktype1;
+        final String finalBlocked = blocked1;
+
         List<String> m = List.of(config.messages.motd.text.split("\n")).stream()
                 .map(line -> line
-                            .replace("%blocktype%", "origin")
+                        .replace("%blocktype%", finalBlocktype)
-                            .replace("%easyblocktype%", "website")
+                        .replace("%easyblocktype%", finalEasyblocktype)
-                            .replace("%blocked%", origin))
+                        .replace("%notallowed1%", "blacklisted")
+                        .replace("%notallowed2%", "blacklisted")
+                        .replace("%blocked%", finalBlocked)
+                        .replace("%host%", host))
                 .map(line -> LegacyComponentSerializer.legacySection()
                         .serialize(MiniMessage.miniMessage().deserialize(line)))
                 .collect(Collectors.toList());
-            if ((origin != "null" || origin != null) && !config.blacklist.missing_origin) {
+
-                for (String origin1 : config.blacklist.origins) {
-                    if (matches(origin, origin1)) {
         setMOTD(conn, m);
-                        return;
-                    }
-                }
-            } else {
-                setMOTD(conn, m);
-            }
-        }
     }
 
     public static void setMOTD(IMOTDConnection conn, List<String> m) {
@@ -103,13 +184,15 @@ public class Base {
         conn.setPlayerTotal(0);
         conn.setPlayerMax(0);
         conn.setPlayerList(List.of());
-        if (config.messages.motd.icon != null && !config.messages.motd.icon.isEmpty())
+
+        if (config.messages.motd.icon != null && !config.messages.motd.icon.isEmpty()) {
             try {
                 BufferedImage img = ImageIO.read(new File(config.messages.motd.icon));
                 if (img.getWidth() != 64 || img.getHeight() != 64) {
                     getLogger().warn("Icon must be 64x64");
                     return;
                 }
+
                 byte[] bytes = new byte[64 * 64 * 4];
                 for (int y = 0; y < 64; y++) {
                     for (int x = 0; x < 64; x++) {
@@ -126,46 +209,59 @@ public class Base {
                 getLogger().error(ex.toString());
             }
         }
+    }
 
     public static boolean matches(String text1, String text2) {
         return text1.toLowerCase().matches(text2.replace(".", "\\.").replaceAll("\\*", ".*").toLowerCase());
     }
 
-    public static String kick(String type, String easytype, String value) {
+    public static Component formatKickMessage(String type, String easytype, String notAllowed1, String notAllowed2, String value, String host) {
-        return LegacyComponentSerializer.legacySection().serialize(
+        String help = "";
-                MiniMessage.miniMessage().deserialize(
+        if ("player".equals(type)) {
+            help = config.messages.help.player;
+        } else if ("ip address".equals(type)) {
+            help = config.messages.help.ip;
+        } else {
+            help = config.messages.help.generic;
+        }
+        return MiniMessage.miniMessage().deserialize(
                 config.messages.kick
-                                .replace("%blocktype%", type)
+                        .replaceAll("%help%", help)
-                                .replace("%easyblocktype%", easytype)
+                        .replaceAll("%blocktype%", type)
-                                .replace("%blocked%", value)
+                        .replaceAll("%easyblocktype%", easytype)
-                )
+                        .replaceAll("%notallowed1%", notAllowed1)
-        );
+                        .replaceAll("%notallowed2%", notAllowed2)
+                        .replaceAll("%blocked%", value)
+                        .replaceAll("%host%", host));
     }
 
-
+    public static void webhook(IEaglerLoginConnection plr, String origin, String brand, String type) {
-    public static void webhook(IEaglerPlayer plr, String origin, String brand, String type) {
         String webhook = config.discord.webhook;
-        if (webhook == null || webhook.isBlank()) return;
+        if (webhook == null || webhook.isBlank())
+            return;
 
-        String addr = plr.getPlayerAddress() != null ? plr.getPlayerAddress().toString().substring(1) : "undefined";
+        CompletableFuture.runAsync(() -> {
-        String protocol = plr.isEaglerXRewindPlayer()
+            String addr = getAddr(plr);
-                ? (String.valueOf(plr.getRewindProtocolVersion()) != null ? String.valueOf(plr.getRewindProtocolVersion()) : "undefined")
+            int protocol = !plr.isEaglerXRewindPlayer() ? plr.getMinecraftProtocol() : plr.getRewindProtocolVersion();
-                : (String.valueOf(plr.getMinecraftProtocol()) != null ? String.valueOf(plr.getMinecraftProtocol()) : "undefined");
+            String host = plr.getWebSocketHost();
-        String rewind = plr.isEaglerXRewindPlayer() ? "Yes" : "No";
             String userAgent = plr.getWebSocketHeader(EnumWebSocketHeader.HEADER_USER_AGENT);
-        if (userAgent == null || userAgent.isEmpty()) userAgent = "undefined";
+            Boolean rewind = plr.isEaglerXRewindPlayer();
+            if (userAgent == null || userAgent.isEmpty())
+                userAgent = "undefined";
 
-        String payload = String.format("""
+            String payload = String.format(
+                    """
                             {
                               "content": "Blocked a blacklisted %s from joining",
                               "embeds": [
                                 {
                                   "title": "Player Information",
-              "description": "🎮 **Name:** %s\\n🏠 **Address:** %s\\n🌄 **PVN:** %s\\n🌐 **Origin:** %s\\n🔋 **Brand:** %s\\n🧊 **User Agent:** %s\\n⏪ **Rewind:** %s"
+                                  "description": "🎮 **Name:** %s\\n🏠 **IP:** %s\\n🌄 **PVN:** %s\\n🌐 **Origin:** %s\\n🔋 **Brand:** %s\\n🪑 **Host:** %s\\n🧊 **UA:** %s\\n⏪ **Rewind:** %s"
                                 }
                               ]
                             }
-        """, type, plr.getUsername(), addr, protocol, origin, brand, userAgent, rewind);
+                            """,
+                    type, plr.getUsername(), addr, protocol, origin, brand, plr.isWebSocketSecure() ? "wss://" : "ws://" + host, userAgent, rewind ? "Yes" : "No");
 
             try {
                 HttpURLConnection conn = (HttpURLConnection) new URL(webhook).openConnection();
@@ -183,6 +279,19 @@ public class Base {
             } catch (Exception e) {
                 getLogger().warn("Failed to send webhook: " + e);
             }
+        });
+    }
+
+    public static String getAddr(IEaglerLoginConnection conn) {
+        var addr1 = conn.getPlayerAddress() != null ? conn.getPlayerAddress().toString().substring(1) : "0.0.0.0:0";
+        var addr2 = addr1.lastIndexOf(':') != -1 ? addr1.substring(0, addr1.lastIndexOf(':')) : addr1;
+        return addr2;
+    }
+
+    public static String getAddr(IMOTDConnection conn) {
+        var addr1 = conn.getSocketAddress() != null ? conn.getSocketAddress().toString().substring(1) : "0.0.0.0:0";
+        var addr2 = addr1.lastIndexOf(':') != -1 ? addr1.substring(0, addr1.lastIndexOf(':')) : addr1;
+        return addr2;
     }
 
     public static void init() {
@@ -196,6 +305,7 @@ public class Base {
                 getLogger().warn(e.toString());
             }
         }
+        ipblacklist = new IPBlacklist();
     }
 
     public static void reloadConfig() {

src/main/java/dev/colbster937/originblacklist/base/Command.java

@@ -1,6 +1,16 @@
 package dev.colbster937.originblacklist.base;
 
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+import static dev.colbster937.originblacklist.base.Base.config;
+
 public class Command {
+    private static final String permission = "<red>You do not have permission to use this command.</red>";
 
     public interface CommandContext {
         String getName();
@@ -9,16 +19,18 @@ public class Command {
         String[] getArgs();
     }
 
-
     public static void usage(CommandContext ctx) {
         ctx.reply("<aqua>Commands:</aqua>");
         ctx.reply("<gray>  - /originblacklist reload</gray>");
+        ctx.reply("<gray>  - /originblacklist add <brand/origin/name/ip> <value></gray>");
+        ctx.reply("<gray>  - /originblacklist remove <brand/origin/name/ip> <value></gray>");
+        ctx.reply("<gray>  - /originblacklist list</gray>");
     }
 
     public static void handle(CommandContext ctx) {
         String[] args = ctx.getArgs();
-        if (!ctx.hasPermission("originblacklist.reload")) {
+        if (!ctx.hasPermission("originblacklist.command")) {
-            ctx.reply("<red>You do not have permission to use this command.</red>");
+            ctx.reply(permission);
             return;
         } else if (args.length == 0) {
             usage(ctx);
@@ -26,14 +38,136 @@ public class Command {
         }
 
         String sub = args[0].toLowerCase();
+        String sub1 = args.length > 1 ? args[1].toLowerCase() : "";
+        String sub2 = args.length > 2 ? args[2].toLowerCase() : "";
 
         switch (sub) {
             case "reload" -> {
+                if (ctx.hasPermission("originblacklist.reload")) {
                     Base.reloadConfig();
                     ctx.reply("<green>Reloaded.</green>");
+                } else {
+                    ctx.reply(permission);
+                    return;
+                }
+            }
+
+            case "add" -> {
+                if (!ctx.hasPermission("originblacklist.add")) {
+                    ctx.reply(permission);
+                    return;
+                }
+
+                if (sub1.isEmpty() || sub2.isEmpty()) {
+                    usage(ctx);
+                    return;
+                }
+
+                List<String> list = switch (sub1) {
+                    case "brand" -> Base.config.blacklist.brands;
+                    case "origin" -> Base.config.blacklist.origins;
+                    case "player" -> Base.config.blacklist.players;
+                    case "ip" -> Base.config.blacklist.ips;
+                    default -> null;
+                };
+
+                if (list == null) {
+                    usage(ctx);
+                    return;
+                }
+
+                if (!list.contains(sub2)) {
+                    list.add(sub2);
+                    ctx.reply("<green>Added " + sub2 + " to " + sub1 + " blacklist.</green>");
+                } else {
+                    ctx.reply("<yellow>Already blacklisted.</yellow>");
+                }
+                try {
+                    config.saveConfig(Base.config.toMap(), new File("plugins/originblacklist/config.yml"));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                Base.reloadConfig();
+            }
+
+            case "remove" -> {
+                if (!ctx.hasPermission("originblacklist.remove")) {
+                    ctx.reply(permission);
+                    return;
+                }
+
+                if (sub1.isEmpty() || sub2.isEmpty()) {
+                    usage(ctx);
+                    return;
+                }
+
+                List<String> list = switch (sub1) {
+                    case "brand" -> Base.config.blacklist.brands;
+                    case "origin" -> Base.config.blacklist.origins;
+                    case "player" -> Base.config.blacklist.players;
+                    case "ip" -> Base.config.blacklist.ips;
+                    default -> null;
+                };
+
+                if (list == null) {
+                    usage(ctx);
+                    return;
+                }
+
+                if (list.remove(sub2)) {
+                    ctx.reply("<green>Removed " + sub2 + " from " + sub1 + " blacklist.</green>");
+                } else {
+                    ctx.reply("<yellow>Entry not found in " + sub1 + ".</yellow>");
+                }
+                try {
+                    config.saveConfig(Base.config.toMap(), new File("plugins/originblacklist/config.yml"));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+                Base.reloadConfig();
+            }
+
+            case "list" -> {
+                if (!ctx.hasPermission("originblacklist.view")) {
+                    ctx.reply(permission);
+                    return;
+                }
+
+                ctx.reply("<aqua>Blacklist:</aqua>");
+
+                ctx.reply("<gray>  Brands:</gray>");
+                for (String s : Base.config.blacklist.brands) ctx.reply("<gray>   - " + s + "</gray>");
+
+                ctx.reply("<gray>  Origins:</gray>");
+                for (String s : Base.config.blacklist.origins) ctx.reply("<gray>   - " + s + "</gray>");
+
+                ctx.reply("<gray>  Players:</gray>");
+                for (String s : Base.config.blacklist.players) ctx.reply("<gray>   - " + s + "</gray>");
+
+                ctx.reply("<gray>  IPs:</gray>");
+                for (String s : Base.config.blacklist.ips) ctx.reply("<gray>   - " + s + "</gray>");
             }
 
             default -> usage(ctx);
         }
     }
+
+    public static List<String> suggest(CommandContext ctx) {
+        String[] args = ctx.getArgs();
+
+        if (args.length == 1) {
+            return List.of("reload", "add", "remove", "list");
+        }
+
+        if (args.length == 2 && args[0].equalsIgnoreCase("add")) {
+            return List.of("brand", "origin", "player", "ip");
+        }
+
+        return List.of();
+    }
+
+    public Map<String, Object> toMap() {
+        Yaml yaml = new Yaml();
+        return yaml.load(yaml.dump(this));
+    }
 }

src/main/java/dev/colbster937/originblacklist/base/ConfigManager.java

@@ -3,47 +3,117 @@ package dev.colbster937.originblacklist.base;
 import org.yaml.snakeyaml.Yaml;
 import org.yaml.snakeyaml.LoaderOptions;
 import org.yaml.snakeyaml.constructor.Constructor;
-import java.io.File;
+import org.yaml.snakeyaml.DumperOptions;
-import java.io.InputStream;
+import java.io.*;
-import java.io.FileInputStream;
-import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.StandardCopyOption;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import inet.ipaddr.IPAddress;
 
 public class ConfigManager {
     public Messages messages = new Messages();
-    public List<String> subscriptions;
+    //public List<String> subscriptions = List.of();
     public Blacklist blacklist = new Blacklist();
     public Discord discord = new Discord();
 
     public static ConfigManager loadConfig(Base.LoggerAdapter logger) {
-        File conf = new File("plugins/originblacklist/config.yml");
+        File f = new File("plugins/originblacklist/config.yml");
 
         try {
-            if (!conf.exists()) {
+            if (!f.exists()) {
-                conf.getParentFile().mkdirs();
+                f.getParentFile().mkdirs();
                 try (InputStream in = ConfigManager.class.getResourceAsStream("/config.yml")) {
-                    if (in != null) {
+                    if (in != null) Files.copy(in, f.toPath(), StandardCopyOption.REPLACE_EXISTING);
-                        Files.copy(in, conf.toPath(), StandardCopyOption.REPLACE_EXISTING);
-                    }
                 }
             }
 
-            LoaderOptions options = new LoaderOptions();
+            Constructor constructor = new Constructor(ConfigManager.class, new LoaderOptions());
-            Constructor constructor = new Constructor(ConfigManager.class, options);
+            constructor.setPropertyUtils(new org.yaml.snakeyaml.introspector.PropertyUtils() {{
-            Yaml yaml = new Yaml(constructor);
+                setSkipMissingProperties(true);
-            return yaml.load(new FileInputStream(conf));
+            }});
+            Yaml y = new Yaml(constructor);
+            ConfigManager l = null;
+
+            try (InputStream in = new FileInputStream(f)) {
+                l = y.load(in);
+            } catch (Exception ex) {
+                logger.warn("Error loading config: " + ex.getMessage());
+            }
+
+            if (l == null) {
+                l = new ConfigManager();
+            }
+
+            try {
+                Yaml raw = new Yaml();
+                Map<String, Object> u = raw.load(new FileInputStream(f));
+                Map<String, Object> d = raw.load(ConfigManager.class.getResourceAsStream("/config.yml"));
+                if (mergeConfig(u, d)) saveConfig(u, f);
+            } catch (Exception ex) {
+                logger.warn("YAML merge error: " + ex.getMessage());
+            }
+
+            l.blacklist.resolveIPS(logger);
+
+            return l;
         } catch (IOException e) {
             return new ConfigManager();
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private static boolean mergeConfig(Map<String, Object> u, Map<String, Object> d) {
+        boolean c = false;
+        for (String k : d.keySet()) {
+            if (!u.containsKey(k)) {
+                u.put(k, d.get(k));
+                c = true;
+            } else if (u.get(k) instanceof Map && d.get(k) instanceof Map)
+                c |= mergeConfig((Map<String, Object>) u.get(k), (Map<String, Object>) d.get(k));
+        }
+        return c;
+    }
+
+    public static void saveConfig(Map<String, Object> m, File f) throws IOException {
+        DumperOptions o = new DumperOptions();
+        o.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        o.setPrettyFlow(true);
+        new Yaml(o).dump(m, new FileWriter(f));
+    }
+
+    public Map<String, Object> toMap() {
+        DumperOptions options = new DumperOptions();
+        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+        options.setPrettyFlow(true);
+        options.setAllowReadOnlyProperties(true);
+
+        Yaml yaml = new Yaml(options);
+        String yaml1 = yaml.dumpAsMap(this);
+        Yaml parser = new Yaml();
+        Object yaml2 = parser.load(yaml1);
+
+        return (Map<String, Object>) yaml2;
+    }
+
     public static class Blacklist {
         public List<String> origins;
         public List<String> brands;
         public List<String> players;
+        public List<String> ips = List.of();
+        public transient Set<IPAddress> ips1 = new CopyOnWriteArraySet<>();
         public boolean missing_origin;
+        //public String blacklist_redirect;
+
+        public void resolveIPS(Base.LoggerAdapter logger) {
+            for (String line : ips) {
+                try {
+                    ips1.add(new inet.ipaddr.IPAddressString(line).toAddress());
+                } catch (Throwable ignored) {}
+            }
+        }
     }
 
     public static class Discord {
@@ -53,6 +123,7 @@ public class ConfigManager {
     public static class Messages {
         public String kick;
         public MOTD motd;
+        public Help help;
     }
 
     public static class MOTD {
@@ -60,4 +131,10 @@ public class ConfigManager {
         public String text;
         public String icon;
     }
+
+    public static class Help {
+        public String generic;
+        public String player;
+        public String ip;
+    }
 }

src/main/java/dev/colbster937/originblacklist/base/IPBlacklist.java

@@ -0,0 +1,38 @@
+package dev.colbster937.originblacklist.base;
+
+import java.util.logging.Logger;
+
+import inet.ipaddr.AddressStringException;
+import inet.ipaddr.IPAddress;
+import inet.ipaddr.IPAddressString;
+
+import static dev.colbster937.originblacklist.base.Base.config;
+
+public class IPBlacklist {
+    private Logger logger = null;
+
+    public IPBlacklist() {
+        this.logger = logger;
+    }
+
+    public boolean check(String addr) {
+        IPAddress ip;
+        String addr1 = addr;
+        try {
+            if (addr.startsWith("/")) {
+                addr1 = addr.substring(1);
+            }
+            ip = new IPAddressString(addr1).toAddress();
+        } catch (AddressStringException e) {
+            throw new RuntimeException("Invalid IP address: " + addr, e);
+        }
+
+        return config.blacklist.ips1.stream().anyMatch(s -> {
+            try {
+                return s.contains(ip);
+            } catch (Exception e) {
+                return false;
+            }
+        });
+    }
+}

src/main/java/dev/colbster937/originblacklist/bukkit/CommandBukkit.java

@@ -1,20 +1,33 @@
 package dev.colbster937.originblacklist.bukkit;
 
-import dev.colbster937.originblacklist.base.Command;
 import dev.colbster937.originblacklist.base.Command.CommandContext;
-import org.bukkit.command.CommandSender;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
 import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
 
 public class CommandBukkit implements CommandExecutor {
 
     @Override
     public boolean onCommand(CommandSender sender, org.bukkit.command.Command command, String label, String[] args) {
-        Command.handle(new CommandContext() {
+        dev.colbster937.originblacklist.base.Command.handle(new CommandContext() {
-            public String getName() { return sender.getName(); }
+            @Override
-            public void reply(String msg) { sender.sendMessage(msg); }
+            public String getName() {
+                return sender.getName();
+            }
+
+            @Override
+            public void reply(String msg) {
+                sender.sendMessage(LegacyComponentSerializer.legacySection()
+                        .serialize(MiniMessage.miniMessage().deserialize(msg)));
+            }
+
+            @Override
             public boolean hasPermission(String permission) {
                 return sender.hasPermission(permission);
             }
+
+            @Override
             public String[] getArgs() {
                 return args;
             }

src/main/java/dev/colbster937/originblacklist/bukkit/OriginBlacklistBukkit.java

@@ -2,16 +2,30 @@ package dev.colbster937.originblacklist.bukkit;
 
 import dev.colbster937.originblacklist.base.Base;
 import net.lax1dude.eaglercraft.backend.server.api.bukkit.EaglerXServerAPI;
-import net.lax1dude.eaglercraft.backend.server.api.bukkit.event.EaglercraftInitializePlayerEvent;
+import net.lax1dude.eaglercraft.backend.server.api.bukkit.event.EaglercraftLoginEvent;
 import net.lax1dude.eaglercraft.backend.server.api.bukkit.event.EaglercraftMOTDEvent;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
 import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.plugin.Plugin;
 
 public class OriginBlacklistBukkit extends JavaPlugin implements Listener {
 
     @Override
     public void onEnable() {
+        Plugin plugin = getServer().getPluginManager().getPlugin("EaglercraftXServer");
+        if (plugin != null) {
+            String version = plugin.getDescription().getVersion();
+            if (!Base.checkVer(version, Base.pluginVer)) {
+                getLogger().severe("EaglerXServer " + Base.pluginVer + " is required!");
+                throw new RuntimeException("Incompatible plugin version");
+            }
+        } else {
+            throw new RuntimeException("Missing EaglerXServer");
+        }
+
+
         Base.setLogger(new Base.LoggerAdapter() {
             @Override public void info(String msg)  { getLogger().info(msg); }
             @Override public void warn(String msg)  { getLogger().warning(msg); }
@@ -29,7 +43,7 @@ public class OriginBlacklistBukkit extends JavaPlugin implements Listener {
     }
 
     @EventHandler
-    public void onLogin(EaglercraftInitializePlayerEvent event) {
+    public void onLogin(EaglercraftLoginEvent event) {
         Base.handleConnection(event);
     }
 

src/main/java/dev/colbster937/originblacklist/bungee/CommandBungee.java

@@ -1,8 +1,8 @@
 package dev.colbster937.originblacklist.bungee;
 
-import dev.colbster937.originblacklist.base.Command;
 import dev.colbster937.originblacklist.base.Command.CommandContext;
 import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.chat.TextComponent;
 
 public class CommandBungee extends net.md_5.bungee.api.plugin.Command {
 
@@ -12,12 +12,19 @@ public class CommandBungee extends net.md_5.bungee.api.plugin.Command {
 
     @Override
     public void execute(CommandSender sender, String[] args) {
-        Command.handle(new CommandContext() {
+        dev.colbster937.originblacklist.base.Command.handle(new CommandContext() {
-            public String getName() { return sender.getName(); }
+            public String getName() {
-            public void reply(String msg) { sender.sendMessage(msg); }
+                return sender.getName();
+            }
+
+            public void reply(String msg) {
+                sender.sendMessage(TextComponent.fromLegacyText(msg));
+            }
+
             public boolean hasPermission(String permission) {
                 return sender.hasPermission(permission);
             }
+
             public String[] getArgs() {
                 return args;
             }

src/main/java/dev/colbster937/originblacklist/bungee/OriginBlacklistBungee.java

@@ -2,8 +2,9 @@ package dev.colbster937.originblacklist.bungee;
 
 import dev.colbster937.originblacklist.base.Base;
 import net.lax1dude.eaglercraft.backend.server.api.bungee.EaglerXServerAPI;
-import net.lax1dude.eaglercraft.backend.server.api.bungee.event.EaglercraftInitializePlayerEvent;
+import net.lax1dude.eaglercraft.backend.server.api.bungee.event.EaglercraftLoginEvent;
 import net.lax1dude.eaglercraft.backend.server.api.bungee.event.EaglercraftMOTDEvent;
+import net.md_5.bungee.api.event.PreLoginEvent;
 import net.md_5.bungee.api.plugin.Plugin;
 import net.md_5.bungee.api.plugin.Listener;
 import net.md_5.bungee.event.EventHandler;
@@ -12,6 +13,18 @@ public class OriginBlacklistBungee extends Plugin implements Listener {
 
     @Override
     public void onEnable() {
+        Plugin plugin = getProxy().getPluginManager().getPlugin("EaglercraftXServer");
+        if (plugin != null) {
+            String version = plugin.getDescription().getVersion();
+            if (!Base.checkVer(version, Base.pluginVer)) {
+                getLogger().severe("EaglerXServer " + Base.pluginVer + " is required!");
+                throw new RuntimeException("Incompatible plugin version");
+            }
+        } else {
+            throw new RuntimeException("Missing EaglerXServer");
+        }
+
+
         Base.setLogger(new Base.LoggerAdapter() {
             @Override public void info(String msg)  { getLogger().info(msg); }
             @Override public void warn(String msg)  { getLogger().warning(msg); }
@@ -29,7 +42,7 @@ public class OriginBlacklistBungee extends Plugin implements Listener {
     }
 
     @EventHandler
-    public void onLogin(EaglercraftInitializePlayerEvent event) {
+    public void onLogin(EaglercraftLoginEvent event) {
         Base.handleConnection(event);
     }
 

src/main/java/dev/colbster937/originblacklist/velocity/CommandVelocity.java

@@ -1,34 +1,49 @@
 package dev.colbster937.originblacklist.velocity;
 
 import com.velocitypowered.api.command.SimpleCommand;
+import dev.colbster937.originblacklist.base.Command;
 import dev.colbster937.originblacklist.base.Command.CommandContext;
 import net.kyori.adventure.text.minimessage.MiniMessage;
-import com.velocitypowered.api.command.CommandSource;
+
+import java.util.List;
 
 public class CommandVelocity implements SimpleCommand {
 
     @Override
     public void execute(Invocation invocation) {
-        CommandSource source = invocation.source();
+        Command.handle(new VelocityCommandContext(invocation));
-        dev.colbster937.originblacklist.base.Command.handle(new CommandContext() {
-            @Override
-            public String getName() {
-                return source.toString();
     }
 
     @Override
-            public void reply(String msg) {
+    public List<String> suggest(Invocation invocation) {
-                source.sendMessage(MiniMessage.miniMessage().deserialize(msg));
+        return Command.suggest(new VelocityCommandContext(invocation));
+    }
+
+    public static class VelocityCommandContext implements CommandContext {
+        private final Invocation invocation;
+
+        public VelocityCommandContext(Invocation invocation) {
+            this.invocation = invocation;
+        }
+
+        @Override
+        public String getName() {
+            return invocation.source().toString();
+        }
+
+        @Override
+        public void reply(String message) {
+            invocation.source().sendMessage(MiniMessage.miniMessage().deserialize(message));
         }
 
         @Override
         public boolean hasPermission(String permission) {
-                return source.hasPermission(permission);
+            return invocation.source().hasPermission(permission);
         }
 
+        @Override
         public String[] getArgs() {
             return invocation.arguments();
         }
-        });
     }
 }

src/main/java/dev/colbster937/originblacklist/velocity/OriginBlacklistVelocity.java

@@ -1,26 +1,18 @@
 package dev.colbster937.originblacklist.velocity;
 
 import com.google.inject.Inject;
+import com.velocitypowered.api.event.connection.PreLoginEvent;
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.event.Subscribe;
-import com.velocitypowered.api.plugin.Plugin;
-import com.velocitypowered.api.plugin.Dependency;
 import com.velocitypowered.api.proxy.ProxyServer;
 import dev.colbster937.originblacklist.base.Base;
+import net.kyori.adventure.text.Component;
 import net.lax1dude.eaglercraft.backend.server.api.velocity.EaglerXServerAPI;
-import net.lax1dude.eaglercraft.backend.server.api.velocity.event.EaglercraftInitializePlayerEvent;
+import net.lax1dude.eaglercraft.backend.server.api.velocity.event.EaglercraftLoginEvent;
-import net.lax1dude.eaglercraft.backend.server.api.event.IEaglercraftMOTDEvent;
 import net.lax1dude.eaglercraft.backend.server.api.velocity.event.EaglercraftMOTDEvent;
+import java.net.InetAddress;
 import org.slf4j.Logger;
 
-@Plugin(
-        id = "originblacklist",
-        name = "OriginBlacklist",
-        version = "1.0.1",
-        authors = {"Colbster937"},
-        description = "A reimplementation of OriginBlacklist for EaglerXServer",
-        dependencies = {@Dependency(id = "eaglerxserver")}
-)
 public class OriginBlacklistVelocity {
 
     private final ProxyServer proxy;
@@ -39,6 +31,14 @@ public class OriginBlacklistVelocity {
 
     @Subscribe
     public void onProxyInitialization(ProxyInitializeEvent event) {
+        proxy.getPluginManager().getPlugin("eaglerxserver").ifPresentOrElse(plugin -> {
+            if (!Base.checkVer(plugin.getDescription().getVersion().orElse("1.0.0"), Base.pluginVer)) {
+                logger.error("EaglerXServer " + Base.pluginVer + " is required!");
+                throw new RuntimeException("Incompatible plugin version");
+            }
+        }, () -> {
+            throw new RuntimeException("Missing EaglerXServer");
+        });
         Base.setApi(EaglerXServerAPI.instance());
         Base.reloadConfig();
         Base.init();
@@ -47,12 +47,12 @@ public class OriginBlacklistVelocity {
     }
 
     @Subscribe
-    public void onLogin(EaglercraftInitializePlayerEvent event) {
+    public void onLogin(EaglercraftLoginEvent event) {
         Base.handleConnection(event);
     }
 
     @Subscribe
-    public void onMOTD(IEaglercraftMOTDEvent event) {
+    public void onMOTD(EaglercraftMOTDEvent event) {
         Base.handleMOTD(event);
     }
 }

src/main/resources/bungee.yml

@@ -1,7 +1,7 @@
 name: OriginBlacklist
-version: 1.0.1
+version: ${version}
 main: dev.colbster937.originblacklist.bungee.OriginBlacklistBungee
-description: A reimplementation of OriginBlacklist for EaglerXServer
+description: ${description}
 author: Colbster937
 depends:
   - EaglercraftXServer

src/main/resources/config.yml

@@ -3,30 +3,47 @@ messages:
   #   - %blocked% - The player's origin/brand that was blocked
   #   - %blocktype% - Shows what the player was blocked for
   #   - %easyblocktype% - Shows what the player was blocked for in an eagler-kid readable form
+  #   - %notallowed1% - Longer "not allowed" message
+  #   - %notallowed2% - Shorter "not allowed" message
+  #   - %host% - The IP the player pinged
+  #   - %help% - The configured help message for the block type
 
   kick: |
-    <red>This %easyblocktype% is not allowed on the server!</red>
+    <red>This %easyblocktype% is %notallowed1%!</red>
     <dark_gray>»</dark_gray> <gray>%blocked%</gray> <dark_gray>«</dark_gray>
 
+    %help%
+    
     <gray>Think this is a mistake? Join our discord:</gray>
     <blue>discord.gg/changethisintheconfig</blue>
   
+  # Please note that help is only supported in the kick message, not the MOTD
+  help:
+    generic: "<gray>Please switch to a different %easyblocktype%.</gray>"
+    player: "<gray>Please change your %easyblocktype%.</gray>"
+    ip: "<gray>Please contact staff for assistance.</gray>"
+
   motd:
     enabled: true
     text: |
-      <red>This %easyblocktype% is not allowed!</red>
+      <red>This %easyblocktype% is %notallowed2%!</red>
-      <dark_gray>»</dark_gray> <gray>%blocked%</gray> <dark_gray>«</dark_gray>
+      <dark_gray>»</dark_gray> <gray>%blocked%</gray>
     icon: "blacklisted.png"
 
 # Origin + Brand blacklist supports wildcards
 # Everything should be lowercase
 blacklist:
   origins:
-    - "hack.example.com"
+    - "*eagler-clients.vercel.app*"
+    - "*eaglerhackedclients.vercel.app*"
+    - "*eaglerhacks.github.io*"
   brands:
     - "*dragonx*"
     - "*piclient*"
-  missing_origin: false
+  players:
+    - "Admin"
+  ips:
+    - "192.0.2.0/24"
 
 discord:
   webhook: ""
@@ -45,23 +62,6 @@ discord:
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 
 

src/main/resources/plugin.yml

@@ -1,7 +1,7 @@
 name: OriginBlacklist
-version: 1.0.1
+version: ${version}
 main: dev.colbster937.originblacklist.bukkit.OriginBlacklistBukkit
-description: A reimplementation of OriginBlacklist for EaglerXServer
+description: ${description}
 author: Colbster937
 depend:
   - EaglercraftXServer

src/main/resources/velocity-plugin.json

@@ -0,0 +1,14 @@
+{
+  "id": "originblacklist",
+  "name": "OriginBlacklist",
+  "version": "${version}",
+  "description": "${description}",
+  "main": "dev.colbster937.originblacklist.velocity.OriginBlacklistVelocity",
+  "authors": ["Colbster937"],
+  "dependencies": [
+    {
+      "id": "eaglerxserver",
+      "optional": false
+    }
+  ]
+}