From e48049a1787bb16f19aee2a6b10c2375fe112b38 Mon Sep 17 00:00:00 2001 From: joethei Date: Fri, 29 Apr 2016 12:54:03 +0200 Subject: [PATCH] added some antihack systems. --- Core.iml | 22 ++--- pom.xml | 1 + .../univento/cloud/client/CloudMessenger.java | 22 +++++ src/main/java/eu/univento/core/Core.java | 4 +- .../eu/univento/core/antihack/AntiHack.java | 47 ++++++++++ .../java/eu/univento/core/antihack/Hack.java | 26 ++++++ .../core/antihack/modules/AutoClicker.java | 26 ++++++ .../core/antihack/modules/AutoRespawn.java | 33 +++++++ .../core/antihack/modules/Criticals.java | 55 ++++++++++++ .../core/antihack/modules/FastPlace.java | 27 ++++++ .../univento/core/antihack/modules/Fly.java | 21 +++++ .../univento/core/antihack/modules/Glide.java | 21 +++++ .../core/antihack/modules/KillAura.java | 36 ++++++++ .../core/antihack/modules/NoSlowDown.java | 35 ++++++++ .../univento/core/antihack/modules/Reach.java | 39 ++++++++ .../univento/core/antihack/modules/Regen.java | 53 +++++++++++ .../core/antihack/utils/PacketHandler.java | 88 ++++++++++++++++++ .../core/antihack/utils/PacketInjector.java | 75 ++++++++++++++++ .../core/antihack/utils/PacketReader.java | 41 +++++++++ .../core/antihack/utils/Reflection.java | 89 +++++++++++++++++++ .../core/api/fakeplayer/FakePlayer.java | 14 ++- .../core/api/player/CustomPlayer.java | 82 ++++++++--------- 22 files changed, 801 insertions(+), 56 deletions(-) create mode 100644 src/main/java/eu/univento/cloud/client/CloudMessenger.java create mode 100644 src/main/java/eu/univento/core/antihack/AntiHack.java create mode 100644 src/main/java/eu/univento/core/antihack/Hack.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/AutoClicker.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/AutoRespawn.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/Criticals.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/FastPlace.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/Fly.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/Glide.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/KillAura.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/NoSlowDown.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/Reach.java create mode 100644 src/main/java/eu/univento/core/antihack/modules/Regen.java create mode 100644 src/main/java/eu/univento/core/antihack/utils/PacketHandler.java create mode 100644 src/main/java/eu/univento/core/antihack/utils/PacketInjector.java create mode 100644 src/main/java/eu/univento/core/antihack/utils/PacketReader.java create mode 100644 src/main/java/eu/univento/core/antihack/utils/Reflection.java diff --git a/Core.iml b/Core.iml index 0db5ae1..dff817f 100644 --- a/Core.iml +++ b/Core.iml @@ -20,16 +20,16 @@ - - - - - - - - - - - + + + + + + + + + + + \ No newline at end of file diff --git a/pom.xml b/pom.xml index a32cdad..b12116c 100644 --- a/pom.xml +++ b/pom.xml @@ -96,6 +96,7 @@ org.spigotmc spigot-api 1.9.2-R0.1-SNAPSHOT + provided diff --git a/src/main/java/eu/univento/cloud/client/CloudMessenger.java b/src/main/java/eu/univento/cloud/client/CloudMessenger.java new file mode 100644 index 0000000..832c7e3 --- /dev/null +++ b/src/main/java/eu/univento/cloud/client/CloudMessenger.java @@ -0,0 +1,22 @@ +package eu.univento.cloud.client; + +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; + +public class CloudMessenger { + + public static void sendModModeMessage(ModModePrefix prefix, String message) { + //TODO: add stuff + server + } + + public static void sendHackMessage(Hack hack, CustomPlayer player) { + //add function + } + + public enum ModModePrefix { + HACK, + CMD, + AD, + ERROR; + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/Core.java b/src/main/java/eu/univento/core/Core.java index 0dd6b4b..2f53d90 100644 --- a/src/main/java/eu/univento/core/Core.java +++ b/src/main/java/eu/univento/core/Core.java @@ -1,5 +1,6 @@ package eu.univento.core; +import eu.univento.core.antihack.AntiHack; import eu.univento.core.api.Blackscreen; import eu.univento.core.api.Config; import eu.univento.core.api.database.MongoDB; @@ -32,7 +33,7 @@ public class Core extends JavaPlugin{ /** * plugin instance */ - public static Core instance; + private static Core instance; /** * @return plugin instance */ @@ -106,6 +107,7 @@ public class Core extends JavaPlugin{ new Build(this, "build", "build", "b"); pm.registerEvents(new Blocks(), this); } + AntiHack.registerListeners(); new RunAs(this, "RunAs", "runas"); new SystemInfo(this, "SystemInfo", "systeminfo"); diff --git a/src/main/java/eu/univento/core/antihack/AntiHack.java b/src/main/java/eu/univento/core/antihack/AntiHack.java new file mode 100644 index 0000000..71b0fd8 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/AntiHack.java @@ -0,0 +1,47 @@ +package eu.univento.core.antihack; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.Core; +import eu.univento.core.antihack.modules.*; +import eu.univento.core.antihack.utils.PacketInjector; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.Bukkit; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerJoinEvent; +import org.bukkit.plugin.PluginManager; + +import java.util.Map; + +public class AntiHack implements Listener{ + + public static PacketInjector packetInjector = new PacketInjector(); + + public static void registerListeners() { + PluginManager pm = Bukkit.getPluginManager(); + pm.registerEvents(new AntiHack(), Core.getInstance()); + pm.registerEvents(new Glide(), Core.getInstance()); + pm.registerEvents(new Fly(), Core.getInstance()); + pm.registerEvents(new AutoClicker(), Core.getInstance()); + pm.registerEvents(new Criticals(), Core.getInstance()); + pm.registerEvents(new Reach(), Core.getInstance()); + pm.registerEvents(new NoSlowDown(), Core.getInstance()); + pm.registerEvents(new Regen(), Core.getInstance()); + pm.registerEvents(new AutoRespawn(), Core.getInstance()); + pm.registerEvents(new FastPlace(), Core.getInstance()); + pm.registerEvents(new KillAura(), Core.getInstance()); + + for(Map.Entry entry : AutoClicker.clicks.entrySet()) { + if(entry.getValue() > 16) { + CloudMessenger.sendHackMessage(Hack.AUTOCLICKER, entry.getKey()); + entry.getKey().warn(Hack.AUTOCLICKER); + } + AutoClicker.clicks.remove(entry.getKey()); + } + } + + @EventHandler + public void onJoin(PlayerJoinEvent e) { + packetInjector.addPlayer(e.getPlayer()); + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/Hack.java b/src/main/java/eu/univento/core/antihack/Hack.java new file mode 100644 index 0000000..6ba5a08 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/Hack.java @@ -0,0 +1,26 @@ +package eu.univento.core.antihack; + +public enum Hack { + //int represents warn points + CRITICALS(10), + AUTOCLICKER(10), + GLIDE(10), + REACH(10), + NOSLOWDOWN(10), + REGEN(10), + AUTORESPAWN(10), + FASTPLACE(10), + KILLAURA(10), + FLY(10); + + private int id; + private Hack(int id) { + this.setId(id); + } + public int getId() { + return id; + } + public void setId(int id) { + this.id = id; + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/AutoClicker.java b/src/main/java/eu/univento/core/antihack/modules/AutoClicker.java new file mode 100644 index 0000000..ef2b1cc --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/AutoClicker.java @@ -0,0 +1,26 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.Action; +import org.bukkit.event.player.PlayerInteractEvent; + +import java.util.HashMap; + +public class AutoClicker implements Listener { + + public static HashMap clicks = new HashMap<>(); + + @EventHandler + public void onClick(PlayerInteractEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + if(e.getAction() == Action.LEFT_CLICK_AIR ||e.getAction() == Action.LEFT_CLICK_BLOCK) { + if(clicks.containsKey(p)) { + clicks.put(p, clicks.get(p) + 1); + }else{ + clicks.put(p, 1); + } + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/AutoRespawn.java b/src/main/java/eu/univento/core/antihack/modules/AutoRespawn.java new file mode 100644 index 0000000..7ab947d --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/AutoRespawn.java @@ -0,0 +1,33 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.PlayerDeathEvent; +import org.bukkit.event.player.PlayerRespawnEvent; + +import java.util.HashMap; + +public class AutoRespawn implements Listener { + + private HashMap time = new HashMap<>(); + + @EventHandler + public void onDeath(PlayerDeathEvent e) { + time.put(CustomPlayer.getPlayer(e.getEntity()), System.currentTimeMillis()); + } + + @EventHandler + public void onRespawn(PlayerRespawnEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + if(time.containsKey(p)) { + if(System.currentTimeMillis() - time.get(p) <= 200L) { + CloudMessenger.sendHackMessage(Hack.AUTORESPAWN, p); + p.warn(Hack.AUTORESPAWN); + } + time.remove(p); + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/Criticals.java b/src/main/java/eu/univento/core/antihack/modules/Criticals.java new file mode 100644 index 0000000..9c9ad1e --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/Criticals.java @@ -0,0 +1,55 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.Core; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; +import org.bukkit.event.player.PlayerMoveEvent; + +import java.util.ArrayList; + +public class Criticals implements Listener { + + private ArrayList players = new ArrayList<>(); + + @EventHandler + public void onEntityDamageByEntity(EntityDamageByEntityEvent e) { + if(e.getDamager() instanceof Player && e.getEntity() instanceof Player) { + CustomPlayer damager = CustomPlayer.getPlayer((Player) e.getDamager()); + CustomPlayer p = CustomPlayer.getPlayer((Player) e.getEntity()); + if(!players.contains(p)) { + players.add(p); + Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> players.remove(p), 5L); + } + } + } + + @EventHandler + public void onMove(PlayerMoveEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> { + final double x1 = e.getFrom().getY(); + final double x2 = p.getLocation().getY(); + double fark = 0.0; + if (x1 > x2) { + fark = x1 - x2; + } else if (x2 > x1) { + fark = x2 - x1; + } else { + fark = 200.0; + } + if (!players.contains(p)) { + return; + } + if (fark == 0.125 || fark == 1.0 || fark == 1.3 || fark == 0.6190840103302007 || fark == 0.4414162352399398 || fark == 200.0) { + CloudMessenger.sendHackMessage(Hack.CRITICALS, p); + p.warn(Hack.CRITICALS); + } + }, 6L); + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/FastPlace.java b/src/main/java/eu/univento/core/antihack/modules/FastPlace.java new file mode 100644 index 0000000..87eca15 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/FastPlace.java @@ -0,0 +1,27 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockPlaceEvent; + +import java.util.HashMap; + +public class FastPlace implements Listener{ + + private HashMap time = new HashMap<>(); + + @EventHandler + public void onPlace(BlockPlaceEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + if(time.containsKey(p)) { + if(System.currentTimeMillis() - time.get(p) <= 110L) { + CloudMessenger.sendHackMessage(Hack.FASTPLACE, p); + p.warn(Hack.FASTPLACE); + } + } + time.put(p, System.currentTimeMillis()); + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/Fly.java b/src/main/java/eu/univento/core/antihack/modules/Fly.java new file mode 100644 index 0000000..6430946 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/Fly.java @@ -0,0 +1,21 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.GameMode; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerMoveEvent; + +public class Fly implements Listener{ + + @EventHandler + public void onFly(PlayerMoveEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + if(p.getGameMode() != GameMode.CREATIVE && e.getTo().getY() > e.getFrom().getY() + 1.5) { + CloudMessenger.sendHackMessage(Hack.FLY, p); + p.warn(Hack.FLY); + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/Glide.java b/src/main/java/eu/univento/core/antihack/modules/Glide.java new file mode 100644 index 0000000..ebdf334 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/Glide.java @@ -0,0 +1,21 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.Material; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerMoveEvent; + +public class Glide implements Listener{ + + @EventHandler + public void onGlide(PlayerMoveEvent e) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + if(e.getTo().getY() - e.getFrom().getY() == -0.125 && e.getTo().clone().subtract(0.0, 1.0, 0.0).getBlock().getType().equals(Material.AIR)) { + CloudMessenger.sendHackMessage(Hack.GLIDE, p); + p.warn(Hack.GLIDE); + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/KillAura.java b/src/main/java/eu/univento/core/antihack/modules/KillAura.java new file mode 100644 index 0000000..bc3fb0c --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/KillAura.java @@ -0,0 +1,36 @@ +package eu.univento.core.antihack.modules; + +import com.mojang.authlib.GameProfile; +import eu.univento.core.Core; +import eu.univento.core.api.fakeplayer.FakePlayer; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityDamageByEntityEvent; + +import java.util.HashMap; +import java.util.Random; +import java.util.UUID; + +public class KillAura implements Listener{ + + public static HashMap players = new HashMap<>(); + + @EventHandler + public void onEntityDamage(EntityDamageByEntityEvent e) { + if (e.getDamager() instanceof Player && e.getEntity() instanceof Player) { + CustomPlayer damager = CustomPlayer.getPlayer((Player) e.getDamager()); + CustomPlayer p = CustomPlayer.getPlayer((Player) e.getEntity()); + FakePlayer fp = new FakePlayer(new GameProfile(UUID.randomUUID(), ""), false, p); + players.put(p, fp); + fp.spawn(p.getLocation().add((double) new Random().nextInt(2), 0.01, (double) new Random().nextInt(2))); + Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> { + fp.removeTablist(); + fp.despawn(); + if(players.containsKey(p)) players.remove(p); + }, 5L); + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/NoSlowDown.java b/src/main/java/eu/univento/core/antihack/modules/NoSlowDown.java new file mode 100644 index 0000000..8482b61 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/NoSlowDown.java @@ -0,0 +1,35 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityShootBowEvent; +import org.bukkit.event.entity.FoodLevelChangeEvent; + +public class NoSlowDown implements Listener{ + + @EventHandler + public void onShootBow(EntityShootBowEvent e) { + if(e.getEntity() instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer((Player) e.getEntity()); + if(p.isSprinting()) { + CloudMessenger.sendHackMessage(Hack.NOSLOWDOWN, p); + p.warn(Hack.NOSLOWDOWN); + } + } + } + + @EventHandler + public void onFoodChange(FoodLevelChangeEvent e) { + if(e.getEntity() instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer((Player) e.getEntity()); + if(e.getFoodLevel() > p.getFoodLevel() && p.isSprinting()) { + CloudMessenger.sendHackMessage(Hack.NOSLOWDOWN, p); + p.warn(Hack.NOSLOWDOWN); + } + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/Reach.java b/src/main/java/eu/univento/core/antihack/modules/Reach.java new file mode 100644 index 0000000..83b748a --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/Reach.java @@ -0,0 +1,39 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.block.Block; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.block.BlockBreakEvent; +import org.bukkit.event.entity.EntityDamageByEntityEvent; + +public class Reach implements Listener{ + + @EventHandler + public void onEntityDamageByEntity(EntityDamageByEntityEvent e) { + if(e.getDamager() instanceof Player && e.getEntity() instanceof Player) { + CustomPlayer damager = CustomPlayer.getPlayer((Player) e.getDamager()); + CustomPlayer p = CustomPlayer.getPlayer((Player) e.getEntity()); + if(damager.getLocation().distance(p.getLocation()) > 4.0) { + e.setCancelled(true); + CloudMessenger.sendHackMessage(Hack.REACH, damager); + p.warn(Hack.REACH); + } + } + } + + @EventHandler + public void onBlockBreak(BlockBreakEvent e ) { + CustomPlayer p = CustomPlayer.getPlayer(e.getPlayer()); + Block b = e.getBlock(); + if(p.getLocation().distance(b.getLocation()) > 6.1) { + e.setCancelled(true); + CloudMessenger.sendHackMessage(Hack.REACH, p); + p.warn(Hack.REACH); + } + } + +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/modules/Regen.java b/src/main/java/eu/univento/core/antihack/modules/Regen.java new file mode 100644 index 0000000..f637b0f --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/modules/Regen.java @@ -0,0 +1,53 @@ +package eu.univento.core.antihack.modules; + +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.Core; +import eu.univento.core.antihack.Hack; +import eu.univento.core.api.player.CustomPlayer; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.entity.EntityRegainHealthEvent; + +import java.util.ArrayList; + +public class Regen implements Listener { + + private ArrayList a = new ArrayList<>(); + private ArrayList b = new ArrayList<>(); + + @EventHandler + public void onRegainHealth(EntityRegainHealthEvent e) { + if (e.getEntity() instanceof Player) { + CustomPlayer p = CustomPlayer.getPlayer((Player) e.getEntity()); + + if (p.getFoodLevel() > 16 && e.getRegainReason() == EntityRegainHealthEvent.RegainReason.SATIATED) { + if (a.contains(p) && b.contains(p)) { + a.remove(p); + } + if (e.getAmount() > 1.0) { + p.setFoodLevel(0); + CloudMessenger.sendHackMessage(Hack.REGEN, p); + p.warn(Hack.REGEN); + return; + } + if (!b.contains(p) && !a.contains(p)) { + a.add(p); + b.add(p); + Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> { + if (!a.contains(p)) { + p.setFoodLevel(0); + b.remove(p); + CloudMessenger.sendHackMessage(Hack.REGEN, p); + p.warn(Hack.REGEN); + } else if (a.contains(p)) { + a.remove(p); + b.remove(p); + } + }, 10L); + } + } + } + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/utils/PacketHandler.java b/src/main/java/eu/univento/core/antihack/utils/PacketHandler.java new file mode 100644 index 0000000..f93b5a4 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/utils/PacketHandler.java @@ -0,0 +1,88 @@ +package eu.univento.core.antihack.utils; + +import com.mojang.authlib.GameProfile; +import eu.univento.cloud.client.CloudMessenger; +import eu.univento.core.Core; +import eu.univento.core.antihack.Hack; +import eu.univento.core.antihack.modules.KillAura; +import eu.univento.core.api.fakeplayer.FakePlayer; +import eu.univento.core.api.player.CustomPlayer; +import io.netty.channel.ChannelDuplexHandler; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelPromise; +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Random; +import java.util.UUID; + +public class PacketHandler extends ChannelDuplexHandler { + private Player player; + private HashMap killAura = new HashMap<>(); + private HashMap count = new HashMap<>(); + private HashMap inventory = new HashMap<>(); + private ArrayList swing = new ArrayList<>(); + + public PacketHandler(final Player player) { + this.player = player; + } + + public void write(final ChannelHandlerContext ctx, final Object msg, final ChannelPromise promise) throws Exception { + super.write(ctx, msg, promise); + } + + public void destroy(final FakePlayer fp, Player p) { + Bukkit.getScheduler().runTaskLater(Core.getInstance(), () -> { + fp.removeTablist(); + fp.despawn(); + if (KillAura.players.containsKey(p)) { + KillAura.players.remove(p); + } + }, 5L); + } + + public void channelRead(final ChannelHandlerContext c, final Object m) throws Exception { + if (m.getClass().getSimpleName().equalsIgnoreCase("PacketPlayInArmAnimation")) { + swing.add(player); + } + if (m.getClass().getSimpleName().equalsIgnoreCase("PacketPlayInUseEntity")) { + final int id = (int) Reflection.getFieldValue(m, "a"); + if (Reflection.getFieldValue(m, "action").toString().equals("ATTACK") && KillAura.players.containsKey(player) && id == KillAura.players.get(player).getEntityID()) { + if (!killAura.containsKey(player)) { + final FakePlayer fp = new FakePlayer(new GameProfile(UUID.randomUUID(), ""), false, player); + KillAura.players.put(player, fp); + fp.spawn(player.getLocation().subtract((double) new Random().nextInt(2), 0.01, (double) new Random().nextInt(2))); + destroy(fp, player); + killAura.put(player, 1); + return; + } + if (killAura.containsKey(player) && killAura.get(player) == 1) { + final FakePlayer fp = new FakePlayer(new GameProfile(UUID.randomUUID(), ""), false, player); + KillAura.players.put(player, fp); + fp.spawn(player.getLocation().subtract((double) new Random().nextInt(2), 0.01, (double) new Random().nextInt(2))); + destroy(fp, player); + killAura.put(player, 2); + return; + } + if (count.get(player) < 4) { + count.put(player, count.get(player) + 1); + } else { + count.remove(player); + CustomPlayer p = CustomPlayer.getPlayer(player); + CloudMessenger.sendHackMessage(Hack.KILLAURA, p); + p.warn(Hack.KILLAURA); + } + killAura.remove(player); + } + } + if (m.getClass().getSimpleName().equalsIgnoreCase("PacketPlayInClientCommand")) { + final String s = Reflection.getFieldValue(m, "a").toString(); + if (s.equals("OPEN_INVENTORY_ACHIEVEMENT")) { + inventory.put(player, System.currentTimeMillis()); + } + } + super.channelRead(c, m); + } +} diff --git a/src/main/java/eu/univento/core/antihack/utils/PacketInjector.java b/src/main/java/eu/univento/core/antihack/utils/PacketInjector.java new file mode 100644 index 0000000..2f5c1de --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/utils/PacketInjector.java @@ -0,0 +1,75 @@ +package eu.univento.core.antihack.utils; + +import io.netty.channel.Channel; +import org.bukkit.entity.Player; + +import java.lang.reflect.Field; + +public class PacketInjector { + + private Field EntityPlayer_playerConnection; + private Class PlayerConnection; + private Field PlayerConnection_networkManager; + private Class NetworkManager; + private Field k; + private Field m; + + public PacketInjector() { + try { + this.EntityPlayer_playerConnection = Reflection.getField(Reflection.getClass("{nms}.EntityPlayer"), "playerConnection"); + this.PlayerConnection = Reflection.getClass("{nms}.PlayerConnection"); + this.PlayerConnection_networkManager = Reflection.getField(this.PlayerConnection, "networkManager"); + this.NetworkManager = Reflection.getClass("{nms}.NetworkManager"); + Field[] fields2; + for (int length = (fields2 = this.NetworkManager.getFields()).length, i = 0; i < length; ++i) { + final Field fields = fields2[i]; + if (fields.getType().equals(Channel.class)) { + this.k = fields; + } + } + if (this.k == null) { + this.k = Reflection.getField(this.NetworkManager, "i"); + } + this.m = Reflection.getField(this.NetworkManager, "m"); + } catch (Throwable t) { + t.printStackTrace(); + } + } + + public void addPlayer(final Player p) { + try { + final Channel ch = this.getChannel(this.getNetworkManager(Reflection.getNmsPlayer(p))); + if (ch.pipeline().get("PacketInjector") == null) { + final PacketHandler h = new PacketHandler(p); + ch.pipeline().addBefore("packet_handler", "PacketInjector", h); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + + public void removePlayer(final Player p) { + try { + final Channel ch = this.getChannel(this.getNetworkManager(Reflection.getNmsPlayer(p))); + if (ch.pipeline().get("PacketInjector") != null) { + ch.pipeline().remove("PacketInjector"); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + + private Object getNetworkManager(final Object ep) { + return Reflection.getFieldValue(this.PlayerConnection_networkManager, (Object) Reflection.getFieldValue(this.EntityPlayer_playerConnection, ep)); + } + + private Channel getChannel(final Object networkManager) { + Channel ch = null; + try { + ch = Reflection.getFieldValue(this.k, networkManager); + } catch (Exception e) { + ch = Reflection.getFieldValue(this.m, networkManager); + } + return ch; + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/utils/PacketReader.java b/src/main/java/eu/univento/core/antihack/utils/PacketReader.java new file mode 100644 index 0000000..aab388f --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/utils/PacketReader.java @@ -0,0 +1,41 @@ +package eu.univento.core.antihack.utils; + +import io.netty.channel.Channel; +import io.netty.channel.ChannelHandler; +import io.netty.channel.ChannelHandlerContext; +import io.netty.handler.codec.MessageToMessageDecoder; +import net.minecraft.server.v1_9_R1.Packet; +import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer; +import org.bukkit.entity.Player; + +import java.util.List; + +public class PacketReader { + + Player player; + Channel channel; + + public PacketReader(final Player player) { + this.player = player; + } + + public void inject() { + final CraftPlayer player = (CraftPlayer) this.player; + this.channel = player.getHandle().playerConnection.networkManager.channel; + this.channel.pipeline().addAfter("decoder", "PacketInjector", (ChannelHandler) new MessageToMessageDecoder>() { + protected void decode(final ChannelHandlerContext arg0, final Packet packet, final List arg2) throws Exception { + arg2.add(packet); + PacketReader.this.readPackets(packet); + } + }); + } + + public void uninject() { + if (this.channel.pipeline().get("PacketInjector") != null) { + this.channel.pipeline().remove("PacketInjector"); + } + } + + private void readPackets(final Packet packet) { + } +} \ No newline at end of file diff --git a/src/main/java/eu/univento/core/antihack/utils/Reflection.java b/src/main/java/eu/univento/core/antihack/utils/Reflection.java new file mode 100644 index 0000000..4aac220 --- /dev/null +++ b/src/main/java/eu/univento/core/antihack/utils/Reflection.java @@ -0,0 +1,89 @@ +package eu.univento.core.antihack.utils; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; +import org.bukkit.scoreboard.Scoreboard; + +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.util.List; + +public class Reflection { + public static Class getClass(final String classname) { + try { + final String version = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3]; + final String path = classname.replace("{nms}", "net.minecraft.server." + version).replace("{nm}", "net.minecraft." + version).replace("{cb}", "org.bukkit.craftbukkit.." + version); + return Class.forName(path); + } catch (Throwable t) { + t.printStackTrace(); + return null; + } + } + + public static Object getNmsPlayer(final Player p) throws Exception { + final Method getHandle = p.getClass().getMethod("getHandle", (Class[]) new Class[0]); + return getHandle.invoke(p, new Object[0]); + } + + public static Object getNmsScoreboard(final Scoreboard s) throws Exception { + final Method getHandle = s.getClass().getMethod("getHandle", (Class[]) new Class[0]); + return getHandle.invoke(s, new Object[0]); + } + + public static Object getFieldValue(final Object instance, final String fieldName) throws Exception { + final Field field = instance.getClass().getDeclaredField(fieldName); + field.setAccessible(true); + return field.get(instance); + } + + public static T getFieldValue(final Field field, final Object obj) { + try { + return (T) field.get(obj); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + public static Field getField(final Class clazz, final String fieldName) throws Exception { + final Field field = clazz.getDeclaredField(fieldName); + field.setAccessible(true); + return field; + } + + public static void setValue(final Object instance, final String field, final Object value) { + try { + final Field f = instance.getClass().getDeclaredField(field); + f.setAccessible(true); + f.set(instance, value); + } catch (Throwable t) { + t.printStackTrace(); + } + } + + public static void sendAllPacket(final Object packet) throws Exception { + for (final Player p : Bukkit.getOnlinePlayers()) { + final Object nmsPlayer = getNmsPlayer(p); + final Object connection = nmsPlayer.getClass().getField("playerConnection").get(nmsPlayer); + connection.getClass().getMethod("sendPacket", getClass("{nms}.Packet")).invoke(connection, packet); + } + } + + public static void sendListPacket(final List players, final Object packet) { + try { + for (final String name : players) { + final Object nmsPlayer = getNmsPlayer(Bukkit.getPlayer(name)); + final Object connection = nmsPlayer.getClass().getField("playerConnection").get(nmsPlayer); + connection.getClass().getMethod("sendPacket", getClass("{nms}.Packet")).invoke(connection, packet); + } + } catch (Throwable t) { + t.printStackTrace(); + } + } + + public static void sendPlayerPacket(final Player p, final Object packet) throws Exception { + final Object nmsPlayer = getNmsPlayer(p); + final Object connection = nmsPlayer.getClass().getField("playerConnection").get(nmsPlayer); + connection.getClass().getMethod("sendPacket", getClass("{nms}.Packet")).invoke(connection, packet); + } +} diff --git a/src/main/java/eu/univento/core/api/fakeplayer/FakePlayer.java b/src/main/java/eu/univento/core/api/fakeplayer/FakePlayer.java index 8ed0956..cc839bb 100644 --- a/src/main/java/eu/univento/core/api/fakeplayer/FakePlayer.java +++ b/src/main/java/eu/univento/core/api/fakeplayer/FakePlayer.java @@ -14,6 +14,7 @@ import org.bukkit.scheduler.BukkitTask; import java.lang.reflect.Field; import java.util.Arrays; +import java.util.Collections; /** * @author joethei @@ -54,6 +55,14 @@ public class FakePlayer { //this.dataWatcher.a(6, 20F); } + public Location getLocation() { + return location; + } + + public int getEntityID() { + return entityId; + } + private final BukkitRunnable tickTask = new BukkitRunnable() { private int ticksLiving = 0; @@ -139,7 +148,6 @@ public class FakePlayer { } public void spawn(Location location) { - PacketPlayOutNamedEntitySpawn playerSpawn = new PacketPlayOutNamedEntitySpawn(); set(playerSpawn, "a", this.entityId); set(playerSpawn, "b", this.gameProfile.getId()); @@ -152,7 +160,7 @@ public class FakePlayer { set(playerSpawn, "i", this.dataWatcher); PacketPlayOutPlayerInfo playerInfo = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.ADD_PLAYER); - set(playerInfo, "b", Arrays.asList(playerInfo.new PlayerInfoData(this.gameProfile, 0, WorldSettings.EnumGamemode.NOT_SET, new ChatComponentText(this.gameProfile.getName())))); + set(playerInfo, "b", Collections.singletonList(playerInfo.new PlayerInfoData(this.gameProfile, 0, WorldSettings.EnumGamemode.NOT_SET, new ChatComponentText(this.gameProfile.getName())))); sendPackets(playerInfo, playerSpawn); this.location = location; @@ -165,7 +173,7 @@ public class FakePlayer { public void despawn() { PacketPlayOutPlayerInfo playerInfo = new PacketPlayOutPlayerInfo(PacketPlayOutPlayerInfo.EnumPlayerInfoAction.REMOVE_PLAYER); - set(playerInfo, "b", Arrays.asList(playerInfo.new PlayerInfoData(this.gameProfile, 0, null, null))); + set(playerInfo, "b", Collections.singletonList(playerInfo.new PlayerInfoData(this.gameProfile, 0, null, null))); sendPackets(new PacketPlayOutEntityDestroy(this.entityId), playerInfo); this.armorStand.remove(); diff --git a/src/main/java/eu/univento/core/api/player/CustomPlayer.java b/src/main/java/eu/univento/core/api/player/CustomPlayer.java index 537983c..427941f 100644 --- a/src/main/java/eu/univento/core/api/player/CustomPlayer.java +++ b/src/main/java/eu/univento/core/api/player/CustomPlayer.java @@ -5,6 +5,7 @@ import com.mongodb.CursorType; import com.mongodb.client.FindIterable; import com.mongodb.client.MongoCollection; import eu.univento.core.Core; +import eu.univento.core.antihack.Hack; import eu.univento.core.api.Actionbar; import eu.univento.core.api.Utils; import eu.univento.core.api.database.MongoDB; @@ -14,9 +15,7 @@ import eu.univento.core.api.server.Game; import eu.univento.core.api.server.Servers; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; -import net.minecraft.server.v1_9_R1.EnumParticle; -import net.minecraft.server.v1_9_R1.PacketDataSerializer; -import net.minecraft.server.v1_9_R1.PacketPlayOutCustomPayload; +import net.minecraft.server.v1_9_R1.*; import org.bson.Document; import org.bukkit.Bukkit; import org.bukkit.Color; @@ -96,9 +95,10 @@ public class CustomPlayer extends CraftPlayer { } public void insertToDatabase() { - Document doc = new Document("uuid", getUniqueId()); + Document doc = new Document("uuid", getUniqueId().toString()); Date date = new Date(); + doc.put("lastName", getName()); doc.put("rank", "Player"); doc.put("firstLogin", date); doc.put("lastLogin", date); @@ -138,7 +138,7 @@ public class CustomPlayer extends CraftPlayer { @Override public boolean hasPlayedBefore() { - FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId())); + FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId().toString())); cursor.cursorType(CursorType.NonTailable); Object obj = cursor.first(); @@ -349,7 +349,7 @@ public class CustomPlayer extends CraftPlayer { } public ArrayList getFriends() { - FindIterable cursor = friendCollection.find(new Document("uuid", getUniqueId())); + FindIterable cursor = friendCollection.find(new Document("uuid", getUniqueId().toString())); cursor.cursorType(CursorType.NonTailable); Document doc = cursor.first(); @@ -359,7 +359,7 @@ public class CustomPlayer extends CraftPlayer { } private void setFriends(ArrayList friends) { - friendCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document("friends", friends))); + friendCollection.updateOne(new Document("uuid", getUniqueId().toString()), new Document("$set", new Document("friends", friends))); } public boolean isFriend(UUID uuid) { @@ -372,6 +372,10 @@ public class CustomPlayer extends CraftPlayer { setFriends(list); } + public void warn(Hack hack) { + //TODO: add actual function + } + /** @@ -438,7 +442,7 @@ public class CustomPlayer extends CraftPlayer { return getTeam(getRank()); } - //TODO: add function + //TODO: add function back in public boolean isNicked() { return false; } @@ -545,11 +549,11 @@ public class CustomPlayer extends CraftPlayer { } private void setInDatabase(String name, Object obj) { - userCollection.updateOne(new Document("uuid", getUniqueId()), new Document("$set", new Document(name, obj))); + userCollection.updateOne(new Document("uuid", getUniqueId().toString()), new Document("$set", new Document(name, obj))); } private Object getObjectFromDatbase(String name) { - FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId())); + FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId().toString())); cursor.cursorType(CursorType.NonTailable); Document doc = cursor.first(); @@ -559,7 +563,7 @@ public class CustomPlayer extends CraftPlayer { } private int getIntegerFromDatabase(String name) { - FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId())); + FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId().toString())); cursor.cursorType(CursorType.NonTailable); Document doc = cursor.first(); @@ -569,7 +573,7 @@ public class CustomPlayer extends CraftPlayer { } private String getStringFromDatabase(String name) { - FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId())); + FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId().toString())); cursor.cursorType(CursorType.NonTailable); Document doc = cursor.first(); @@ -579,7 +583,7 @@ public class CustomPlayer extends CraftPlayer { } private Date getDateFromDatabase(String name) { - FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId())); + FindIterable cursor = userCollection.find(new Document("uuid", getUniqueId().toString())); cursor.cursorType(CursorType.NonTailable); Document doc = cursor.first(); @@ -596,10 +600,10 @@ public class CustomPlayer extends CraftPlayer { return (Map) getObjectFromDatbase(name); } - public String getPrefix(Ranks r) { + private String getPrefix(Ranks r) { switch(r) { case Admin: return "§8[§4Admin§8]§4 "; - case SrDeveloper: return "§8[§3Dev+§8]§3 "; + case SrDeveloper: return "§8[§3SrDev§8]§3 "; case Developer: return "§8[§3Dev§8]§3 "; case SrModerator: return "§8[§cSrMod§8]§c "; case HeadBuilder: return "§8[§aHead-Builder§8]§a "; @@ -613,7 +617,7 @@ public class CustomPlayer extends CraftPlayer { } } - public String getSuffix(Ranks r) { + private String getSuffix(Ranks r) { switch(r) { case Admin: return "§8 »§7 "; case SrDeveloper: return "§8 »§7"; @@ -630,7 +634,7 @@ public class CustomPlayer extends CraftPlayer { } } - public String getColor(Ranks r) { + private String getColor(Ranks r) { switch(r) { case Admin: return "§4"; case SrDeveloper: return "§3"; @@ -662,33 +666,22 @@ public class CustomPlayer extends CraftPlayer { } public Team getTeam(Ranks r) { + Scoreboard board = getScoreboard(); switch (r) { - case Admin: return Admin; - case SrDeveloper: return SrDeveloper; - case Developer: return Developer; - case SrModerator: return SrModerator; - case HeadBuilder: return HeadBuilder; - case Moderator: return Moderator; - case Builder: return Builder; - case Supporter: return Supporter; - case Youtuber: return Youtuber; - case Premium: return Premium; - case Player: return Player; - default: return Player; + case Admin: return board.getTeam("a"); + case SrDeveloper: return board.getTeam("b"); + case Developer: return board.getTeam("c"); + case SrModerator: return board.getTeam("d"); + case HeadBuilder: return board.getTeam("e"); + case Moderator: return board.getTeam("f"); + case Builder: return board.getTeam("g"); + case Supporter: return board.getTeam("h"); + case Youtuber: return board.getTeam("i"); + case Premium: return board.getTeam("j"); + case Player: return board.getTeam("k"); + default: return board.getTeam("k"); } } - private Scoreboard board = getScoreboard(); - private Team Admin = board.getTeam("a"); - private Team SrDeveloper = board.getTeam("b"); - private Team Developer = board.getTeam("c"); - private Team SrModerator = board.getTeam("d"); - private Team HeadBuilder = board.getTeam("e"); - private Team Moderator = board.getTeam("f"); - private Team Builder = board.getTeam("g"); - private Team Supporter = board.getTeam("h"); - private Team Youtuber = board.getTeam("i"); - private Team Premium = board.getTeam("j"); - private Team Player = board.getTeam("k"); public void initScoreboard() { Scoreboard board = getScoreboard(); @@ -770,4 +763,11 @@ public class CustomPlayer extends CraftPlayer { } } + + public void crashClient() { + getHandle().playerConnection.sendPacket(new PacketPlayOutExplosion(9999999999D, + 9999999999D, 9999999999D, 9999999999F, + new ArrayList<>(), new Vec3D(9999999999D, + 9999999999D, 9999999999D))); + } } \ No newline at end of file