diff --git a/Essentials/src/main/resources/config.yml b/Essentials/src/main/resources/config.yml index 3d3f6ff5d0..0f693511a0 100644 --- a/Essentials/src/main/resources/config.yml +++ b/Essentials/src/main/resources/config.yml @@ -1045,6 +1045,27 @@ chat: # You must restart your server after changing this setting. paper-chat-events: true + #When enabled the plugin sends a message to the player letting them know not to send similar messages. + #Whether duplicate messages should be blocked. + duplicate-prevention: true + + #Whether we run a command in response to duplicate messages. Leave empty for no punishment. + #Use {player} to insert the player that triggered this punishment + duplicate-punish: + + #Whether chat should have a cooldown per player. + chat-cooldown-enable: false + chat-cooldown-time: 0 + + #When enabled the plugin sends a message to the player letting them know not to use too many capitol letters. + #Message is converted to lowercase before being sent + #Whether messages containing lots of capitols should be changed to lowercase + chat-caps-filter: true + + #Use {player} to insert the player that triggered this punishment + #Whether we run a command in response to too many capitol letters. Leave empty for no punishment. + caps-punishment: + ############################################################ # +------------------------------------------------------+ # # | EssentialsX Protect | # diff --git a/EssentialsChat/build.gradle b/EssentialsChat/build.gradle index e0b9454d23..e2ad7d7ad2 100644 --- a/EssentialsChat/build.gradle +++ b/EssentialsChat/build.gradle @@ -4,4 +4,8 @@ plugins { dependencies { compileOnly project(':EssentialsX') -} + testImplementation project(':EssentialsX') + + testImplementation 'org.junit.jupiter:junit-jupiter-api:5.10.2' + testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.2' +} \ No newline at end of file diff --git a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/EssentialsChat.java b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/EssentialsChat.java index f7db3796d2..7b136d39dc 100644 --- a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/EssentialsChat.java +++ b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/EssentialsChat.java @@ -2,8 +2,10 @@ import com.earth2me.essentials.Essentials; import com.earth2me.essentials.EssentialsLogger; +import com.earth2me.essentials.chat.processing.AntiSpam; import com.earth2me.essentials.chat.processing.ChatHandler; import com.earth2me.essentials.chat.processing.PaperChatHandler; +import com.earth2me.essentials.chat.processing.PlayerDisconnectListner; import com.earth2me.essentials.metrics.MetricsWrapper; import com.earth2me.essentials.utils.VersionUtil; import net.ess3.api.IEssentials; @@ -19,6 +21,7 @@ public class EssentialsChat extends JavaPlugin { private transient IEssentials ess; private transient MetricsWrapper metrics = null; + public transient AntiSpam antiSpam; @Override public void onEnable() { @@ -44,6 +47,8 @@ public void onEnable() { if (metrics == null) { metrics = new MetricsWrapper(this, 3814, false); } + antiSpam = new AntiSpam(ess); + pluginManager.registerEvents(new PlayerDisconnectListner(), this); } @Override diff --git a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/AntiSpam.java b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/AntiSpam.java new file mode 100644 index 0000000000..1fb7a5faf8 --- /dev/null +++ b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/AntiSpam.java @@ -0,0 +1,170 @@ +package com.earth2me.essentials.chat.processing; + +import com.earth2me.essentials.IEssentials; +import net.ess3.provider.AbstractChatEvent; +import org.bukkit.ChatColor; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.entity.Player; + +import java.util.Locale; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + +public class AntiSpam { + private static AntiSpam antiSpam; + private final IEssentials ess; + + private final FileConfiguration config; + private final Map lastMessage; + private final Map cooldowns; + + public AntiSpam(IEssentials ess) { + this.ess = ess; + antiSpam = this; + config = ess.getConfig(); + lastMessage = new ConcurrentHashMap<>(); + cooldowns = new ConcurrentHashMap<>(); + } + + public void newMessage(AbstractChatEvent event) { + if (event.isCancelled()) { + return; + } + + final Player player = event.getPlayer(); + final String message = event.getMessage(); + + event.setMessage(capsFilter(message, player)); + + if (duplicationFilter(message, player)) { + event.setCancelled(true); + return; + } + + if (chatCooldown(player)) { + event.setCancelled(true); + return; + } + + lastMessage.put(player.getUniqueId(), message.toLowerCase(Locale.ROOT)); + } + + private String capsFilter(String message, Player player) { + if(ess.getConfig().getBoolean("chat.chat-caps-filter")) { + int count = 0; + for (int i = 0; i < message.length(); i++) { + if (Character.isUpperCase(message.charAt(i))) { + count++; + } + } + if (message.length() * 0.70 < count) { + //return the message to chat with lowercase replaced + player.sendMessage(ChatColor.RED + "Please do not spam capital letters in chat"); + final String command = config.getString("caps-punish"); + + if (command != null && !command.trim().isEmpty()) { + ess.getServer().dispatchCommand( + ess.getServer().getConsoleSender(), + command.replace("{player}", player.getName()) + ); + } + return message.toLowerCase(Locale.ROOT); + } + } + return message; + + } + + private boolean duplicationFilter(String message, Player player) { + if (!config.getBoolean("chat.duplicate-prevention")) { + return false; + } + + final UUID uuid = player.getUniqueId(); + final String normalizedMessage = message.toLowerCase(Locale.ROOT); + final String previousMessage = lastMessage.get(uuid); + + if (previousMessage != null && isSimilar(previousMessage, normalizedMessage)) { + final String command = config.getString("duplication-punish"); + if (command != null && !command.trim().isEmpty()) { + ess.getServer().dispatchCommand( + ess.getServer().getConsoleSender(), + command.replace("{player}", player.getName()) + ); + } + player.sendMessage(ChatColor.RED + "Please do not send the same message twice."); + return true; + } + return false; + } + + private boolean chatCooldown(Player player) { + if (player.hasPermission("essentials.chat.bypass.cooldown") + || !config.getBoolean("chat.chat-cooldown-enable")) { + return false; + } + final long cooldownTime = config.getInt("chat.chat-cooldown-time") * 1000L; + final UUID uuid = player.getUniqueId(); + final long currentTime = System.currentTimeMillis(); + final long lastMessageTime = cooldowns.getOrDefault(uuid, 0L); + final long remaining = cooldownTime - (currentTime - lastMessageTime); + + if (remaining > 0) { + player.sendMessage(ChatColor.RED + "Please wait " + + (remaining / 1000 + 1) + + " seconds before sending another message."); + return true; + } + + cooldowns.put(uuid, currentTime); + return false; + } + + public static AntiSpam getAntiSpam(){ + return antiSpam; + } + + public void unloadPlayer(Player player){ + lastMessage.remove(player.getUniqueId()); + cooldowns.remove(player.getUniqueId()); + } + + private int levenshteinDistance(String a, String b) { + final int[] costs = new int[b.length() + 1]; + + for (int j = 0; j <= b.length(); j++) { + costs[j] = j; + } + + for (int i = 1; i <= a.length(); i++) { + costs[0] = i; + int previousCost = i - 1; + + for (int j = 1; j <= b.length(); j++) { + final int currentCost = costs[j]; + + costs[j] = Math.min( + Math.min(costs[j] + 1, costs[j - 1] + 1), + previousCost + (a.charAt(i - 1) == b.charAt(j - 1) ? 0 : 1) + ); + + previousCost = currentCost; + } + } + + return costs[b.length()]; + } + + private boolean isSimilar(String a, String b) { + if (a.equals(b)) { + return true; + } + + final int distance = levenshteinDistance(a, b); + final int maxLength = Math.max(a.length(), b.length()); + + return distance <= 1 + || 1.0 - (double) distance / maxLength >= 0.85; + } +} diff --git a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/ChatHandler.java b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/ChatHandler.java index eb53654525..0e7d713491 100644 --- a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/ChatHandler.java +++ b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/ChatHandler.java @@ -45,6 +45,7 @@ private final class ChatHighest implements ChatListener { @EventHandler(priority = EventPriority.HIGHEST) public void onPlayerChat(AsyncPlayerChatEvent event) { final AbstractChatEvent absEvent = wrap(event); + AntiSpam.getAntiSpam().newMessage(absEvent); handleChatPostFormat(absEvent); handleChatSubmit(absEvent); } diff --git a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PaperChatHandler.java b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PaperChatHandler.java index 989816f069..f0853bdfd8 100644 --- a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PaperChatHandler.java +++ b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PaperChatHandler.java @@ -29,6 +29,7 @@ public void onChatNormal(AbstractChatEvent event) { @Override public void onChatHighest(AbstractChatEvent event) { + AntiSpam.getAntiSpam().newMessage(event); handleChatPostFormat(event); handleChatSubmit(event); } diff --git a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PlayerDisconnectListner.java b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PlayerDisconnectListner.java new file mode 100644 index 0000000000..39e9c4348d --- /dev/null +++ b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/PlayerDisconnectListner.java @@ -0,0 +1,12 @@ +package com.earth2me.essentials.chat.processing; + +import org.bukkit.event.EventHandler; +import org.bukkit.event.Listener; +import org.bukkit.event.player.PlayerQuitEvent; + +public class PlayerDisconnectListner implements Listener { + @EventHandler + public void onPlayerDisconnect(PlayerQuitEvent event){ + AntiSpam.getAntiSpam().unloadPlayer(event.getPlayer()); + } +} diff --git a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/SpigotChatEvent.java b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/SpigotChatEvent.java index 04ee58f376..37e3ca5c7a 100644 --- a/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/SpigotChatEvent.java +++ b/EssentialsChat/src/main/java/com/earth2me/essentials/chat/processing/SpigotChatEvent.java @@ -69,4 +69,5 @@ public void removeRecipients(Predicate predicate) { public void addRecipient(Player player) { event.getRecipients().add(player); } + } diff --git a/EssentialsChat/src/main/resources/plugin.yml b/EssentialsChat/src/main/resources/plugin.yml index a6b5103403..4113b45c08 100644 --- a/EssentialsChat/src/main/resources/plugin.yml +++ b/EssentialsChat/src/main/resources/plugin.yml @@ -43,3 +43,6 @@ permissions: essentials.chat.receive.question: default: true description: Allows access to receiving global question chat messages + essentials.chat.bypass.cooldown: + default: false + description: Allows a player to bypass chat cooldowns diff --git a/EssentialsChat/src/test/java/com/earth2me/essentials/chat/processing/AntiSpamTests.java b/EssentialsChat/src/test/java/com/earth2me/essentials/chat/processing/AntiSpamTests.java new file mode 100644 index 0000000000..9618b2d7ce --- /dev/null +++ b/EssentialsChat/src/test/java/com/earth2me/essentials/chat/processing/AntiSpamTests.java @@ -0,0 +1,321 @@ +package com.earth2me.essentials.chat.processing; + +import com.earth2me.essentials.Essentials; +import net.ess3.provider.AbstractChatEvent; +import org.bukkit.Server; +import org.bukkit.command.ConsoleCommandSender; +import org.bukkit.configuration.file.FileConfiguration; +import org.bukkit.entity.Player; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.util.UUID; + +import static org.mockito.ArgumentMatchers.contains; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +class AntiSpamTests { + + private Essentials ess; + private FileConfiguration config; + private Server server; + private ConsoleCommandSender console; + private Player player; + private AntiSpam antiSpam; + + @BeforeEach + void setUp() { + ess = mock(Essentials.class); + config = mock(FileConfiguration.class); + server = mock(Server.class); + console = mock(ConsoleCommandSender.class); + player = mock(Player.class); + + when(ess.getConfig()).thenReturn(config); + when(ess.getServer()).thenReturn(server); + when(server.getConsoleSender()).thenReturn(console); + + when(config.getBoolean("chat.chat-caps-filter")).thenReturn(false); + when(config.getBoolean("chat.duplicate-prevention")).thenReturn(true); + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(false); + when(config.getInt("chat.chat-cooldown-time")).thenReturn(5); + + when(player.getUniqueId()).thenReturn(UUID.randomUUID()); + when(player.getName()).thenReturn("TestPlayer"); + when(player.hasPermission("essentials.chat.bypass.cooldown")).thenReturn(false); + + antiSpam = new AntiSpam(ess); + } + + private AbstractChatEvent createEvent(String message) { + final AbstractChatEvent event = mock(AbstractChatEvent.class); + + when(event.getPlayer()).thenReturn(player); + when(event.getMessage()).thenReturn(message); + when(event.isCancelled()).thenReturn(false); + + return event; + } + + private void assertMessageCancelled(String message, boolean cancelled) { + final AbstractChatEvent event = createEvent(message); + + antiSpam.newMessage(event); + + if (cancelled) { + verify(event).setCancelled(true); + } else { + verify(event, never()).setCancelled(true); + } + } + + // Duplicate prevention + + @Test + void firstMessageShouldBeAllowed() { + assertMessageCancelled("Hello everyone", false); + } + + @Test + void identicalMessageShouldBeCancelled() { + assertMessageCancelled("Hello everyone", false); + assertMessageCancelled("Hello everyone", true); + } + + @Test + void duplicateMessageShouldIgnoreCapitalization() { + assertMessageCancelled("Hello Everyone", false); + assertMessageCancelled("HELLO EVERYONE", true); + } + + @Test + void similarMessageWithOneCharacterChangedShouldBeCancelled() { + assertMessageCancelled("Hello everyone", false); + assertMessageCancelled("Hello everyonf", true); + } + + @Test + void similarMessageWithCharacterInsertedShouldBeCancelled() { + assertMessageCancelled("buy cheap diamonds", false); + assertMessageCancelled("buy cheap diamondss", true); + } + + @Test + void similarMessageWithCharacterRemovedShouldBeCancelled() { + assertMessageCancelled("buy cheap diamondss", false); + assertMessageCancelled("buy cheap diamonds", true); + } + + @Test + void similarMessageWithCharacterSubstitutedShouldBeCancelled() { + assertMessageCancelled("Hello everyone", false); + assertMessageCancelled("Hello evetyone", true); + } + + @Test + void messageStartingWithPreviousMessageShouldBeAllowed() { + assertMessageCancelled("Hello", false); + assertMessageCancelled("Hello everyone", false); + } + + @Test + void messageEndingWithPreviousMessageShouldBeAllowed() { + assertMessageCancelled("everyone", false); + assertMessageCancelled("Hello everyone", false); + } + + @Test + void completelyDifferentMessageShouldBeAllowed() { + assertMessageCancelled("Hello everyone", false); + assertMessageCancelled("Goodbye world", false); + } + + @Test + void similarityExactlyAtThresholdShouldBeCancelled() { + assertMessageCancelled("abcdefghijklmnopqrst", false); + assertMessageCancelled("abcXXXghijklmnopqrst", true); + } + + @Test + void similarityBelowThresholdShouldBeAllowed() { + assertMessageCancelled("abcdefghijklmnopqrst", false); + assertMessageCancelled("abcdXXXXijklmnopqrst", false); + } + + @Test + void duplicatePreventionDisabledShouldAllowDuplicates() { + when(config.getBoolean("chat.duplicate-prevention")).thenReturn(false); + + assertMessageCancelled("Hello", false); + assertMessageCancelled("Hello", false); + } + + // Chat cooldown + + @Test + void firstMessageShouldNotTriggerCooldown() { + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(true); + + assertMessageCancelled("Hello", false); + } + + @Test + void secondMessageDuringCooldownShouldBeCancelled() { + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(true); + + assertMessageCancelled("Hello", false); + assertMessageCancelled("Goodbye", true); + } + + @Test + void cooldownBypassPermissionShouldAllowMessages() { + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(true); + when(player.hasPermission("essentials.chat.bypass.cooldown")).thenReturn(true); + + assertMessageCancelled("Hello", false); + assertMessageCancelled("Goodbye", false); + } + + @Test + void disabledCooldownShouldAllowMessages() { + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(false); + + assertMessageCancelled("Hello", false); + assertMessageCancelled("Goodbye", false); + } + + @Test + void cooldownRejectedMessageShouldNotReplaceLastAcceptedMessage() { + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(true); + + assertMessageCancelled("First message", false); + assertMessageCancelled("Second message", true); + + when(player.hasPermission("essentials.chat.bypass.cooldown")).thenReturn(true); + + assertMessageCancelled("First message", true); + } + + // Caps filter + + @Test + void excessiveCapitalizationShouldBeConvertedToLowercase() { + when(config.getBoolean("chat.chat-caps-filter")).thenReturn(true); + + final AbstractChatEvent event = createEvent("HELLO"); + + antiSpam.newMessage(event); + + verify(event).setMessage("hello"); + } + + @Test + void normalCapitalizationShouldRemainUnchanged() { + when(config.getBoolean("chat.chat-caps-filter")).thenReturn(true); + + final AbstractChatEvent event = createEvent("Hello everyone"); + + antiSpam.newMessage(event); + + verify(event).setMessage("Hello everyone"); + } + + @Test + void disabledCapsFilterShouldLeaveMessageUnchanged() { + final AbstractChatEvent event = createEvent("HELLO"); + + antiSpam.newMessage(event); + + verify(event).setMessage("HELLO"); + } + + @Test + void capsFilterShouldSendWarning() { + when(config.getBoolean("chat.chat-caps-filter")).thenReturn(true); + + antiSpam.newMessage(createEvent("HELLO")); + + verify(player).sendMessage(contains("capital letters")); + } + + @Test + void capsPunishmentShouldReplacePlayerPlaceholder() { + when(config.getBoolean("chat.chat-caps-filter")).thenReturn(true); + when(config.getString("caps-punish")).thenReturn("mute {player} 10m"); + + antiSpam.newMessage(createEvent("HELLO")); + + verify(server).dispatchCommand(console, "mute TestPlayer 10m"); + } + + @Test + void emptyCapsPunishmentShouldNotDispatchCommand() { + when(config.getBoolean("chat.chat-caps-filter")).thenReturn(true); + when(config.getString("caps-punish")).thenReturn(" "); + + antiSpam.newMessage(createEvent("HELLO")); + + verifyNoInteractions(server); + } + + // Duplicate punishment + + @Test + void duplicatePunishmentShouldReplacePlayerPlaceholder() { + when(config.getString("duplication-punish")).thenReturn("mute {player} 10m"); + + assertMessageCancelled("Hello", false); + assertMessageCancelled("Hello", true); + + verify(server).dispatchCommand(console, "mute TestPlayer 10m"); + } + + @Test + void emptyDuplicatePunishmentShouldNotDispatchCommand() { + when(config.getString("duplication-punish")).thenReturn(""); + + assertMessageCancelled("Hello", false); + assertMessageCancelled("Hello", true); + + verifyNoInteractions(server); + } + + // Event handling + + @Test + void alreadyCancelledEventShouldRemainCancelled() { + final AbstractChatEvent event = createEvent("Hello"); + when(event.isCancelled()).thenReturn(true); + + antiSpam.newMessage(event); + + verify(event, never()).setCancelled(false); + verify(event, never()).setCancelled(true); + } + + // Player cleanup + + @Test + void unloadPlayerShouldClearDuplicateHistory() { + assertMessageCancelled("Hello", false); + + antiSpam.unloadPlayer(player); + + assertMessageCancelled("Hello", false); + } + + @Test + void unloadPlayerShouldClearCooldownHistory() { + when(config.getBoolean("chat.chat-cooldown-enable")).thenReturn(true); + + assertMessageCancelled("Hello", false); + + antiSpam.unloadPlayer(player); + + assertMessageCancelled("Hello", false); + } +}