Meishin/LoginSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #118 from AuthMe-Team/432-remove-public-ip-map

Browse Source 
432 remove public ip map
This commit is contained in:
ljacqu 2016-03-06 16:19:36 +01:00
commit 1003e0b62d
43 changed files with 814 additions and 597 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
src/main/java/fr/xephi/authme/AuthMe.java
View File

@ -1,8 +1,6 @@
package fr.xephi.authme; package fr.xephi.authme;
import com.earth2me.essentials.Essentials; import com.earth2me.essentials.Essentials;
import com.google.common.base.Charsets;
import com.google.common.io.Resources;
import com.onarandombox.MultiverseCore.MultiverseCore; import com.onarandombox.MultiverseCore.MultiverseCore;
import fr.xephi.authme.api.API; import fr.xephi.authme.api.API;
import fr.xephi.authme.api.NewAPI; import fr.xephi.authme.api.NewAPI;
@ -35,6 +33,7 @@ import fr.xephi.authme.listener.AuthMeServerListener;
import fr.xephi.authme.listener.AuthMeTabCompletePacketAdapter; import fr.xephi.authme.listener.AuthMeTabCompletePacketAdapter;
import fr.xephi.authme.listener.AuthMeTablistPacketAdapter; import fr.xephi.authme.listener.AuthMeTablistPacketAdapter;
import fr.xephi.authme.mail.SendMailSSL; import fr.xephi.authme.mail.SendMailSSL;
import fr.xephi.authme.cache.IpAddressManager;
import fr.xephi.authme.output.ConsoleFilter; import fr.xephi.authme.output.ConsoleFilter;
import fr.xephi.authme.output.Log4JFilter; import fr.xephi.authme.output.Log4JFilter;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
@ -53,6 +52,7 @@ import fr.xephi.authme.settings.properties.DatabaseSettings;
import fr.xephi.authme.settings.properties.EmailSettings; import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.HooksSettings; import fr.xephi.authme.settings.properties.HooksSettings;
import fr.xephi.authme.settings.properties.PluginSettings; import fr.xephi.authme.settings.properties.PluginSettings;
import fr.xephi.authme.settings.properties.PurgeSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings; import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings; import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.util.CollectionUtils; import fr.xephi.authme.util.CollectionUtils;
@ -73,8 +73,6 @@ import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
import java.io.File; import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.sql.SQLException; import java.sql.SQLException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Calendar; import java.util.Calendar;
@ -112,7 +110,7 @@ public class AuthMe extends JavaPlugin {
public final ConcurrentHashMap<String, BukkitTask> sessions = new ConcurrentHashMap<>(); public final ConcurrentHashMap<String, BukkitTask> sessions = new ConcurrentHashMap<>();
public final ConcurrentHashMap<String, Integer> captcha = new ConcurrentHashMap<>(); public final ConcurrentHashMap<String, Integer> captcha = new ConcurrentHashMap<>();
public final ConcurrentHashMap<String, String> cap = new ConcurrentHashMap<>(); public final ConcurrentHashMap<String, String> cap = new ConcurrentHashMap<>();
public final ConcurrentHashMap<String, String> realIp = new ConcurrentHashMap<>();
/* /*
* Public Instances * Public Instances
* TODO #432: Encapsulation * TODO #432: Encapsulation
@ -139,6 +137,7 @@ public class AuthMe extends JavaPlugin {
private JsonCache playerBackup; private JsonCache playerBackup;
private PasswordSecurity passwordSecurity; private PasswordSecurity passwordSecurity;
private DataSource database; private DataSource database;
private IpAddressManager ipAddressManager;
/** /**
* Get the plugin's instance. * Get the plugin's instance.
@ -251,10 +250,11 @@ public class AuthMe extends JavaPlugin {
MigrationService.changePlainTextToSha256(newSettings, database, new SHA256()); MigrationService.changePlainTextToSha256(newSettings, database, new SHA256());
passwordSecurity = new PasswordSecurity(getDataSource(), newSettings.getProperty(SecuritySettings.PASSWORD_HASH), passwordSecurity = new PasswordSecurity(getDataSource(), newSettings.getProperty(SecuritySettings.PASSWORD_HASH),
Bukkit.getPluginManager(), newSettings.getProperty(SecuritySettings.SUPPORT_OLD_PASSWORD_HASH)); Bukkit.getPluginManager(), newSettings.getProperty(SecuritySettings.SUPPORT_OLD_PASSWORD_HASH));
ipAddressManager = new IpAddressManager(newSettings);
// Set up the permissions manager and command handler // Set up the permissions manager and command handler
permsMan = initializePermissionsManager(); permsMan = initializePermissionsManager();
commandHandler = initializeCommandHandler(permsMan, messages, passwordSecurity, newSettings); commandHandler = initializeCommandHandler(permsMan, messages, passwordSecurity, newSettings, ipAddressManager);
// Set up Metrics // Set up Metrics
MetricsStarter.setupMetrics(plugin, newSettings); MetricsStarter.setupMetrics(plugin, newSettings);
@ -300,11 +300,12 @@ public class AuthMe extends JavaPlugin {
setupApi(); setupApi();
// Set up the management // Set up the management
ProcessService processService = new ProcessService(newSettings, messages, this); ProcessService processService = new ProcessService(newSettings, messages, this, ipAddressManager,
passwordSecurity);
management = new Management(this, processService, database, PlayerCache.getInstance()); management = new Management(this, processService, database, PlayerCache.getInstance());
// Set up the BungeeCord hook // Set up the BungeeCord hook
setupBungeeCordHook(); setupBungeeCordHook(newSettings, ipAddressManager);
// Reload support hook // Reload support hook
reloadSupportHook(); reloadSupportHook();
@ -375,7 +376,7 @@ public class AuthMe extends JavaPlugin {
// Set up the permissions manager and command handler // Set up the permissions manager and command handler
permsMan = initializePermissionsManager(); permsMan = initializePermissionsManager();
commandHandler = initializeCommandHandler(permsMan, messages, passwordSecurity, newSettings); commandHandler = initializeCommandHandler(permsMan, messages, passwordSecurity, newSettings, ipAddressManager);
// Download and load GeoIp.dat file if absent // Download and load GeoIp.dat file if absent
GeoLiteAPI.isDataAvailable(); GeoLiteAPI.isDataAvailable();
@ -400,11 +401,12 @@ public class AuthMe extends JavaPlugin {
dataManager = new DataManager(this); dataManager = new DataManager(this);
ProcessService processService = new ProcessService(newSettings, messages, this); ProcessService processService = new ProcessService(newSettings, messages, this,
ipAddressManager, passwordSecurity);
management = new Management(this, processService, database, PlayerCache.getInstance()); management = new Management(this, processService, database, PlayerCache.getInstance());
// Set up the BungeeCord hook // Set up the BungeeCord hook
setupBungeeCordHook(); setupBungeeCordHook(newSettings, ipAddressManager);
// Reload support hook // Reload support hook
reloadSupportHook(); reloadSupportHook();
@ -490,20 +492,22 @@ public class AuthMe extends JavaPlugin {
/** /**
* Set up the BungeeCord hook. * Set up the BungeeCord hook.
*/ */
private void setupBungeeCordHook() { private void setupBungeeCordHook(NewSetting settings, IpAddressManager ipAddressManager) {
if (newSettings.getProperty(HooksSettings.BUNGEECORD)) { if (settings.getProperty(HooksSettings.BUNGEECORD)) {
Bukkit.getMessenger().registerOutgoingPluginChannel(this, "BungeeCord"); Bukkit.getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");
Bukkit.getMessenger().registerIncomingPluginChannel(this, "BungeeCord", new BungeeCordMessage(this)); Bukkit.getMessenger().registerIncomingPluginChannel(
this, "BungeeCord", new BungeeCordMessage(this, ipAddressManager));
} }
} }
private CommandHandler initializeCommandHandler(PermissionsManager permissionsManager, Messages messages, private CommandHandler initializeCommandHandler(PermissionsManager permissionsManager, Messages messages,
PasswordSecurity passwordSecurity, NewSetting settings) { PasswordSecurity passwordSecurity, NewSetting settings,
IpAddressManager ipAddressManager) {
HelpProvider helpProvider = new HelpProvider(permissionsManager, settings.getProperty(HELP_HEADER)); HelpProvider helpProvider = new HelpProvider(permissionsManager, settings.getProperty(HELP_HEADER));
Set<CommandDescription> baseCommands = CommandInitializer.buildCommands(); Set<CommandDescription> baseCommands = CommandInitializer.buildCommands();
CommandMapper mapper = new CommandMapper(baseCommands, permissionsManager); CommandMapper mapper = new CommandMapper(baseCommands, permissionsManager);
CommandService commandService = new CommandService( CommandService commandService = new CommandService(
this, mapper, helpProvider, messages, passwordSecurity, permissionsManager, settings); this, mapper, helpProvider, messages, passwordSecurity, permissionsManager, settings, ipAddressManager);
return new CommandHandler(commandService); return new CommandHandler(commandService);
} }
@ -811,8 +815,8 @@ public class AuthMe extends JavaPlugin {
} }
Utils.addNormal(player, limbo.getGroup()); Utils.addNormal(player, limbo.getGroup());
player.setOp(limbo.getOperator()); player.setOp(limbo.isOperator());
limbo.getTimeoutTaskId().cancel(); limbo.getTimeoutTask().cancel();
LimboCache.getInstance().deleteLimboPlayer(name); LimboCache.getInstance().deleteLimboPlayer(name);
if (this.playerBackup.doesCacheExist(player)) { if (this.playerBackup.doesCacheExist(player)) {
this.playerBackup.removeCache(player); this.playerBackup.removeCache(player);
@ -833,26 +837,26 @@ public class AuthMe extends JavaPlugin {
// Purge inactive players from the database, as defined in the configuration // Purge inactive players from the database, as defined in the configuration
private void autoPurge() { private void autoPurge() {
if (!Settings.usePurge) { if (!newSettings.getProperty(PurgeSettings.USE_AUTO_PURGE)) {
return; return;
} }
Calendar calendar = Calendar.getInstance(); Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.DATE, -(Settings.purgeDelay)); calendar.add(Calendar.DATE, -newSettings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER));
long until = calendar.getTimeInMillis(); long until = calendar.getTimeInMillis();
List<String> cleared = database.autoPurgeDatabase(until); List<String> cleared = database.autoPurgeDatabase(until);
if (CollectionUtils.isEmpty(cleared)) { if (CollectionUtils.isEmpty(cleared)) {
return; return;
} }
ConsoleLogger.info("AutoPurging the Database: " + cleared.size() + " accounts removed!"); ConsoleLogger.info("AutoPurging the Database: " + cleared.size() + " accounts removed!");
if (Settings.purgeEssentialsFile && this.ess != null) if (newSettings.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES) && this.ess != null)
dataManager.purgeEssentials(cleared); dataManager.purgeEssentials(cleared);
if (Settings.purgePlayerDat) if (newSettings.getProperty(PurgeSettings.REMOVE_PLAYER_DAT))
dataManager.purgeDat(cleared); dataManager.purgeDat(cleared);
if (Settings.purgeLimitedCreative) if (newSettings.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES))
dataManager.purgeLimitedCreative(cleared); dataManager.purgeLimitedCreative(cleared);
if (Settings.purgeAntiXray) if (newSettings.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE))
dataManager.purgeAntiXray(cleared); dataManager.purgeAntiXray(cleared);
if (Settings.purgePermissions) if (newSettings.getProperty(PurgeSettings.REMOVE_PERMISSIONS))
dataManager.purgePermissions(cleared); dataManager.purgePermissions(cleared);
} }
@ -884,59 +888,28 @@ public class AuthMe extends JavaPlugin {
public String replaceAllInfo(String message, Player player) { public String replaceAllInfo(String message, Player player) {
String playersOnline = Integer.toString(Utils.getOnlinePlayers().size()); String playersOnline = Integer.toString(Utils.getOnlinePlayers().size());
String ipAddress = ipAddressManager.getPlayerIp(player);
return message return message
.replace("&", "\u00a7") .replace("&", "\u00a7")
.replace("{PLAYER}", player.getName()) .replace("{PLAYER}", player.getName())
.replace("{ONLINE}", playersOnline) .replace("{ONLINE}", playersOnline)
.replace("{MAXPLAYERS}", Integer.toString(server.getMaxPlayers())) .replace("{MAXPLAYERS}", Integer.toString(server.getMaxPlayers()))
.replace("{IP}", getIP(player)) .replace("{IP}", ipAddress)
.replace("{LOGINS}", Integer.toString(PlayerCache.getInstance().getLogged())) .replace("{LOGINS}", Integer.toString(PlayerCache.getInstance().getLogged()))
.replace("{WORLD}", player.getWorld().getName()) .replace("{WORLD}", player.getWorld().getName())
.replace("{SERVER}", server.getServerName()) .replace("{SERVER}", server.getServerName())
.replace("{VERSION}", server.getBukkitVersion()) .replace("{VERSION}", server.getBukkitVersion())
.replace("{COUNTRY}", GeoLiteAPI.getCountryName(getIP(player))); .replace("{COUNTRY}", GeoLiteAPI.getCountryName(ipAddress));
}
/**
* Gets a player's real IP through VeryGames method.
*
* @param player The player to process.
*/
@Deprecated
public void getVerygamesIp(final Player player) {
final String name = player.getName().toLowerCase();
String currentIp = player.getAddress().getAddress().getHostAddress();
if (realIp.containsKey(name)) {
currentIp = realIp.get(name);
}
String sUrl = "http://monitor-1.verygames.net/api/?action=ipclean-real-ip&out=raw&ip=%IP%&port=%PORT%";
sUrl = sUrl.replace("%IP%", currentIp).replace("%PORT%", "" + player.getAddress().getPort());
try {
String result = Resources.toString(new URL(sUrl), Charsets.UTF_8);
if (!StringUtils.isEmpty(result) && !result.equalsIgnoreCase("error") && !result.contains("error")) {
currentIp = result;
realIp.put(name, currentIp);
}
} catch (IOException e) {
ConsoleLogger.showError("Could not fetch Very Games API with URL '" +
sUrl + "' - " + StringUtils.formatException(e));
}
}
public String getIP(final Player player) {
final String name = player.getName().toLowerCase();
String ip = player.getAddress().getAddress().getHostAddress();
if (realIp.containsKey(name)) {
ip = realIp.get(name);
}
return ip;
} }
public boolean isLoggedIp(String name, String ip) { public boolean isLoggedIp(String name, String ip) {
int count = 0; int count = 0;
for (Player player : Utils.getOnlinePlayers()) { for (Player player : Utils.getOnlinePlayers()) {
if (ip.equalsIgnoreCase(getIP(player)) && database.isLogged(player.getName().toLowerCase()) && !player.getName().equalsIgnoreCase(name)) if (ip.equalsIgnoreCase(ipAddressManager.getPlayerIp(player))
count++; && database.isLogged(player.getName().toLowerCase())
&& !player.getName().equalsIgnoreCase(name)) {
++count;
}
} }
return count >= Settings.getMaxLoginPerIp; return count >= Settings.getMaxLoginPerIp;
} }

81
src/main/java/fr/xephi/authme/cache/CaptchaManager.java vendored Normal file
View File

@ -0,0 +1,81 @@
package fr.xephi.authme.cache;
import fr.xephi.authme.security.RandomString;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.SecuritySettings;
import java.util.concurrent.ConcurrentHashMap;
/**
* Manager for the handling of captchas.
*/
public class CaptchaManager {
private final int threshold;
private final int captchaLength;
private final ConcurrentHashMap<String, Integer> playerCounts;
private final ConcurrentHashMap<String, String> captchaCodes;
public CaptchaManager(NewSetting settings) {
this.playerCounts = new ConcurrentHashMap<>();
this.captchaCodes = new ConcurrentHashMap<>();
this.threshold = settings.getProperty(SecuritySettings.MAX_LOGIN_TRIES_BEFORE_CAPTCHA);
this.captchaLength = settings.getProperty(SecuritySettings.CAPTCHA_LENGTH);
}
public void increaseCount(String player) {
String playerLower = player.toLowerCase();
Integer currentCount = playerCounts.get(playerLower);
if (currentCount == null) {
playerCounts.put(playerLower, 1);
} else {
playerCounts.put(playerLower, currentCount + 1);
}
}
/**
* Return whether the given player is required to solve a captcha.
*
* @param player The player to verify
* @return True if the player has to solve a captcha, false otherwise
*/
public boolean isCaptchaRequired(String player) {
Integer count = playerCounts.get(player.toLowerCase());
return count != null && count >= threshold;
}
/**
* Return the captcha code for the player. Creates one if none present, so call only after
* checking with {@link #isCaptchaRequired}.
*
* @param player The player
* @return The code required for the player
*/
public String getCaptchaCode(String player) {
String code = captchaCodes.get(player.toLowerCase());
if (code == null) {
code = RandomString.generate(captchaLength);
captchaCodes.put(player.toLowerCase(), code);
}
return code;
}
/**
* Return whether the supplied code is correct for the given player.
*
* @param player The player to check
* @param code The supplied code
* @return True if the code matches or if no captcha is required for the player, false otherwise
*/
public boolean checkCode(String player, String code) {
String savedCode = captchaCodes.get(player.toLowerCase());
if (savedCode == null) {
return true;
} else if (savedCode.equalsIgnoreCase(code)) {
captchaCodes.remove(player.toLowerCase());
return true;
}
return false;
}
}

99
src/main/java/fr/xephi/authme/cache/IpAddressManager.java vendored Normal file
View File

@ -0,0 +1,99 @@
package fr.xephi.authme.cache;
import com.google.common.base.Charsets;
import com.google.common.io.Resources;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.HooksSettings;
import fr.xephi.authme.util.StringUtils;
import org.bukkit.entity.Player;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.ConcurrentHashMap;
/**
* Stateful manager for looking up IP address appropriately, including caching.
*/
public class IpAddressManager {
/** Whether or not to use the VeryGames API for IP lookups. */
private final boolean useVeryGamesIpCheck;
/** Cache for lookups via the VeryGames API. */
private final ConcurrentHashMap<String, String> ipCache;
/**
* Constructor.
*
* @param settings The settings instance
*/
public IpAddressManager(NewSetting settings) {
this.useVeryGamesIpCheck = settings.getProperty(HooksSettings.ENABLE_VERYGAMES_IP_CHECK);
this.ipCache = new ConcurrentHashMap<>();
}
/**
* Return the player's IP address. If enabled in the settings, the IP address returned by the
* VeryGames API will be returned.
*
* @param player The player to look up
* @return The IP address of the player
*/
public String getPlayerIp(Player player) {
if (useVeryGamesIpCheck) {
final String playerName = player.getName().toLowerCase();
final String cachedValue = ipCache.get(playerName);
if (cachedValue != null) {
return cachedValue;
}
final String plainIp = player.getAddress().getAddress().getHostAddress();
String veryGamesResult = getVeryGamesIp(plainIp, player.getAddress().getPort());
if (veryGamesResult != null) {
ipCache.put(playerName, veryGamesResult);
return veryGamesResult;
}
}
return player.getAddress().getAddress().getHostAddress();
}
/**
* Add a player to the IP address cache.
*
* @param player The player to add or update the cache entry for
* @param ip The IP address to add
*/
public void addCache(String player, String ip) {
if (useVeryGamesIpCheck) {
ipCache.put(player.toLowerCase(), ip);
}
}
/**
* Remove a player's cache entry.
*
* @param player The player to remove
*/
public void removeCache(String player) {
if (useVeryGamesIpCheck) {
ipCache.remove(player.toLowerCase());
}
}
// returns null if IP could not be looked up
private String getVeryGamesIp(final String plainIp, final int port) {
final String sUrl = String.format("http://monitor-1.verygames.net/api/?action=ipclean-real-ip"
+ "&out=raw&ip=%s&port=%d", plainIp, port);
try {
String result = Resources.toString(new URL(sUrl), Charsets.UTF_8);
if (!StringUtils.isEmpty(result) && !result.contains("error")) {
return result;
}
} catch (IOException e) {
ConsoleLogger.logException("Could not fetch Very Games API with URL '" + sUrl + "':", e);
}
return null;
}
}

12
src/main/java/fr/xephi/authme/cache/auth/PlayerAuth.java vendored
View File

@ -30,18 +30,6 @@ public class PlayerAuth {
this.deserialize(serialized); this.deserialize(serialized);
} }
/**
* Constructor for PlayerAuth.
*
* @param nickname String
* @param ip String
* @param lastLogin long
* @param realName String
*/
public PlayerAuth(String nickname, String ip, long lastLogin, String realName) {
this(nickname, new HashedPassword(""), -1, ip, lastLogin, 0, 0, 0, "world", "your@email.com", realName);
}
/** /**
* Constructor for PlayerAuth. * Constructor for PlayerAuth.
* *

6
src/main/java/fr/xephi/authme/cache/limbo/LimboCache.java vendored
View File

@ -16,8 +16,8 @@ import static com.google.common.base.Preconditions.checkNotNull;
public class LimboCache { public class LimboCache {
private volatile static LimboCache singleton; private volatile static LimboCache singleton;
public final ConcurrentHashMap<String, LimboPlayer> cache; private final ConcurrentHashMap<String, LimboPlayer> cache;
public final AuthMe plugin; private final AuthMe plugin;
private final JsonCache jsonCache; private final JsonCache jsonCache;
/** /**
@ -84,7 +84,7 @@ public class LimboCache {
checkNotNull(name); checkNotNull(name);
name = name.toLowerCase(); name = name.toLowerCase();
if (cache.containsKey(name)) { if (cache.containsKey(name)) {
cache.get(name).clearTask(); cache.get(name).clearTasks();
cache.remove(name); cache.remove(name);
} }
} }

91
src/main/java/fr/xephi/authme/cache/limbo/LimboPlayer.java vendored
View File

@ -4,14 +4,16 @@ import org.bukkit.Location;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
/** /**
* Represents a player which is not logged in and keeps track of certain states (like OP status, flying)
* which may be revoked from the player until he has logged in or registered.
*/ */
public class LimboPlayer { public class LimboPlayer {
private final String name; private final String name;
private final boolean fly; private final boolean fly;
private Location loc = null; private Location loc = null;
private BukkitTask timeoutTaskId = null; private BukkitTask timeoutTask = null;
private BukkitTask messageTaskId = null; private BukkitTask messageTask = null;
private boolean operator = false; private boolean operator = false;
private String group; private String group;
@ -25,36 +27,36 @@ public class LimboPlayer {
} }
/** /**
* Method getName. * Return the name of the player.
* *
* @return String * @return The player's name
*/ */
public String getName() { public String getName() {
return name; return name;
} }
/** /**
* Method getLoc. * Return the player's original location.
* *
* @return Location * @return The player's location
*/ */
public Location getLoc() { public Location getLoc() {
return loc; return loc;
} }
/** /**
* Method getOperator. * Return whether the player is an operator or not (i.e. whether he is an OP).
* *
* @return boolean * @return True if the player has OP status, false otherwise
*/ */
public boolean getOperator() { public boolean isOperator() {
return operator; return operator;
} }
/** /**
* Method getGroup. * Return the player's permissions group.
* *
* @return String * @return The permissions group the player belongs to
*/ */
public String getGroup() { public String getGroup() {
return group; return group;
@ -64,54 +66,61 @@ public class LimboPlayer {
return fly; return fly;
} }
public BukkitTask getTimeoutTaskId() {
return timeoutTaskId;
}
/** /**
* Method setTimeoutTaskId. * Return the timeout task, which kicks the player if he hasn't registered or logged in
* after a configurable amount of time.
* *
* @param i BukkitTask * @return The timeout task associated to the player
*/ */
public void setTimeoutTaskId(BukkitTask i) { public BukkitTask getTimeoutTask() {
if (this.timeoutTaskId != null) { return timeoutTask;
this.timeoutTaskId.cancel();
}
this.timeoutTaskId = i;
} }
/** /**
* Method getMessageTaskId. * Set the timeout task of the player. The timeout task kicks the player after a configurable
* amount of time if he hasn't logged in or registered.
* *
* @return BukkitTask * @param timeoutTask The task to set
*/ */
public BukkitTask getMessageTaskId() { public void setTimeoutTask(BukkitTask timeoutTask) {
return messageTaskId; if (this.timeoutTask != null) {
this.timeoutTask.cancel();
}
this.timeoutTask = timeoutTask;
} }
/** /**
* Method setMessageTaskId. * Return the message task reminding the player to log in or register.
* *
* @param messageTaskId BukkitTask * @return The task responsible for sending the message regularly
*/ */
public void setMessageTaskId(BukkitTask messageTaskId) { public BukkitTask getMessageTask() {
if (this.messageTaskId != null) { return messageTask;
this.messageTaskId.cancel();
}
this.messageTaskId = messageTaskId;
} }
/** /**
* Method clearTask. * Set the messages task responsible for telling the player to log in or register.
*
* @param messageTask The message task to set
*/ */
public void clearTask() { public void setMessageTask(BukkitTask messageTask) {
if (messageTaskId != null) { if (this.messageTask != null) {
messageTaskId.cancel(); this.messageTask.cancel();
} }
messageTaskId = null; this.messageTask = messageTask;
if (timeoutTaskId != null) { }
timeoutTaskId.cancel();
/**
* Clears all tasks associated to the player.
*/
public void clearTasks() {
if (messageTask != null) {
messageTask.cancel();
} }
timeoutTaskId = null; messageTask = null;
if (timeoutTask != null) {
timeoutTask.cancel();
}
timeoutTask = null;
} }
} }

17
src/main/java/fr/xephi/authme/command/CommandService.java
View File

@ -1,8 +1,10 @@
package fr.xephi.authme.command; package fr.xephi.authme.command;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.command.help.HelpProvider; import fr.xephi.authme.command.help.HelpProvider;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.cache.IpAddressManager;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.output.Messages;
import fr.xephi.authme.permission.PermissionsManager; import fr.xephi.authme.permission.PermissionsManager;
@ -27,6 +29,7 @@ public class CommandService {
private final PasswordSecurity passwordSecurity; private final PasswordSecurity passwordSecurity;
private final PermissionsManager permissionsManager; private final PermissionsManager permissionsManager;
private final NewSetting settings; private final NewSetting settings;
private final IpAddressManager ipAddressManager;
/** /**
* Constructor. * Constructor.
@ -38,10 +41,11 @@ public class CommandService {
* @param passwordSecurity The Password Security instance * @param passwordSecurity The Password Security instance
* @param permissionsManager The permissions manager * @param permissionsManager The permissions manager
* @param settings The settings manager * @param settings The settings manager
* @param ipAddressManager The IP address manager
*/ */
public CommandService(AuthMe authMe, CommandMapper commandMapper, HelpProvider helpProvider, Messages messages, public CommandService(AuthMe authMe, CommandMapper commandMapper, HelpProvider helpProvider, Messages messages,
PasswordSecurity passwordSecurity, PermissionsManager permissionsManager, PasswordSecurity passwordSecurity, PermissionsManager permissionsManager, NewSetting settings,
NewSetting settings) { IpAddressManager ipAddressManager) {
this.authMe = authMe; this.authMe = authMe;
this.messages = messages; this.messages = messages;
this.helpProvider = helpProvider; this.helpProvider = helpProvider;
@ -49,6 +53,7 @@ public class CommandService {
this.passwordSecurity = passwordSecurity; this.passwordSecurity = passwordSecurity;
this.permissionsManager = permissionsManager; this.permissionsManager = permissionsManager;
this.settings = settings; this.settings = settings;
this.ipAddressManager = ipAddressManager;
} }
/** /**
@ -182,4 +187,12 @@ public class CommandService {
return settings; return settings;
} }
public IpAddressManager getIpAddressManager() {
return ipAddressManager;
}
public PlayerCache getPlayerCache() {
return PlayerCache.getInstance();
}
} }

3
src/main/java/fr/xephi/authme/command/CommandUtils.java
View File

@ -8,6 +8,9 @@ import java.util.List;
public final class CommandUtils { public final class CommandUtils {
private CommandUtils() {
}
public static int getMinNumberOfArguments(CommandDescription command) { public static int getMinNumberOfArguments(CommandDescription command) {
int mandatoryArguments = 0; int mandatoryArguments = 0;
for (CommandArgumentDescription argument : command.getArguments()) { for (CommandArgumentDescription argument : command.getArguments()) {

22
src/main/java/fr/xephi/authme/command/executable/authme/GetIpCommand.java
View File

@ -1,21 +1,18 @@
package fr.xephi.authme.command.executable.authme; package fr.xephi.authme.command.executable.authme;
import java.util.List; import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.ExecutableCommand;
import fr.xephi.authme.settings.properties.HooksSettings;
import fr.xephi.authme.util.Utils;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import fr.xephi.authme.AuthMe; import java.util.List;
import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.ExecutableCommand;
import fr.xephi.authme.util.Utils;
public class GetIpCommand implements ExecutableCommand { public class GetIpCommand implements ExecutableCommand {
@Override @Override
public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) { public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) {
final AuthMe plugin = AuthMe.getInstance();
// Get the player query // Get the player query
String playerName = (arguments.size() >= 1) ? arguments.get(0) : sender.getName(); String playerName = (arguments.size() >= 1) ? arguments.get(0) : sender.getName();
@ -25,9 +22,12 @@ public class GetIpCommand implements ExecutableCommand {
return; return;
} }
// TODO ljacqu 20151212: Revise the messages (actual IP vs. real IP...?) sender.sendMessage(player.getName() + "'s IP is: " + player.getAddress().getAddress().getHostAddress()
sender.sendMessage(player.getName() + "'s actual IP is : " + player.getAddress().getAddress().getHostAddress()
+ ":" + player.getAddress().getPort()); + ":" + player.getAddress().getPort());
sender.sendMessage(player.getName() + "'s real IP is : " + plugin.getIP(player));
if (commandService.getProperty(HooksSettings.ENABLE_VERYGAMES_IP_CHECK)) {
sender.sendMessage(player.getName() + "'s real IP is: "
+ commandService.getIpAddressManager().getPlayerIp(player));
}
} }
} }

12
src/main/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommand.java
View File

@ -3,7 +3,7 @@ package fr.xephi.authme.command.executable.authme;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.command.CommandService; import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.ExecutableCommand; import fr.xephi.authme.command.ExecutableCommand;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.properties.PurgeSettings;
import org.bukkit.OfflinePlayer; import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
@ -15,7 +15,7 @@ public class PurgeBannedPlayersCommand implements ExecutableCommand {
@Override @Override
public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) { public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) {
// AuthMe plugin instance // AuthMe plugin instance
final AuthMe plugin = AuthMe.getInstance(); final AuthMe plugin = commandService.getAuthMe();
// Get the list of banned players // Get the list of banned players
List<String> bannedPlayers = new ArrayList<>(); List<String> bannedPlayers = new ArrayList<>();
@ -25,13 +25,13 @@ public class PurgeBannedPlayersCommand implements ExecutableCommand {
// Purge the banned players // Purge the banned players
plugin.getDataSource().purgeBanned(bannedPlayers); plugin.getDataSource().purgeBanned(bannedPlayers);
if (Settings.purgeEssentialsFile && plugin.ess != null) if (commandService.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES) && plugin.ess != null)
plugin.dataManager.purgeEssentials(bannedPlayers); plugin.dataManager.purgeEssentials(bannedPlayers);
if (Settings.purgePlayerDat) if (commandService.getProperty(PurgeSettings.REMOVE_PLAYER_DAT))
plugin.dataManager.purgeDat(bannedPlayers); plugin.dataManager.purgeDat(bannedPlayers);
if (Settings.purgeLimitedCreative) if (commandService.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES))
plugin.dataManager.purgeLimitedCreative(bannedPlayers); plugin.dataManager.purgeLimitedCreative(bannedPlayers);
if (Settings.purgeAntiXray) if (commandService.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE))
plugin.dataManager.purgeAntiXray(bannedPlayers); plugin.dataManager.purgeAntiXray(bannedPlayers);
// Show a status message // Show a status message

12
src/main/java/fr/xephi/authme/command/executable/authme/PurgeCommand.java
View File

@ -3,7 +3,7 @@ package fr.xephi.authme.command.executable.authme;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.command.CommandService; import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.ExecutableCommand; import fr.xephi.authme.command.ExecutableCommand;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.properties.PurgeSettings;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
@ -15,7 +15,7 @@ public class PurgeCommand implements ExecutableCommand {
@Override @Override
public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) { public void executeCommand(CommandSender sender, List<String> arguments, CommandService commandService) {
// AuthMe plugin instance // AuthMe plugin instance
AuthMe plugin = AuthMe.getInstance(); AuthMe plugin = commandService.getAuthMe();
// Get the days parameter // Get the days parameter
String daysStr = arguments.get(0); String daysStr = arguments.get(0);
@ -47,13 +47,13 @@ public class PurgeCommand implements ExecutableCommand {
sender.sendMessage(ChatColor.GOLD + "Deleted " + purged.size() + " user accounts"); sender.sendMessage(ChatColor.GOLD + "Deleted " + purged.size() + " user accounts");
// Purge other data // Purge other data
if (Settings.purgeEssentialsFile && plugin.ess != null) if (commandService.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES) && plugin.ess != null)
plugin.dataManager.purgeEssentials(purged); plugin.dataManager.purgeEssentials(purged);
if (Settings.purgePlayerDat) if (commandService.getProperty(PurgeSettings.REMOVE_PLAYER_DAT))
plugin.dataManager.purgeDat(purged); plugin.dataManager.purgeDat(purged);
if (Settings.purgeLimitedCreative) if (commandService.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES))
plugin.dataManager.purgeLimitedCreative(purged); plugin.dataManager.purgeLimitedCreative(purged);
if (Settings.purgeAntiXray) if (commandService.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE))
plugin.dataManager.purgeAntiXray(purged); plugin.dataManager.purgeAntiXray(purged);
// Show a status message // Show a status message

7
src/main/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommand.java
View File

@ -8,6 +8,7 @@ import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.ExecutableCommand; import fr.xephi.authme.command.ExecutableCommand;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.task.MessageTask; import fr.xephi.authme.task.MessageTask;
import fr.xephi.authme.task.TimeoutTask; import fr.xephi.authme.task.TimeoutTask;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
@ -59,14 +60,14 @@ public class UnregisterAdminCommand implements ExecutableCommand {
BukkitScheduler scheduler = sender.getServer().getScheduler(); BukkitScheduler scheduler = sender.getServer().getScheduler();
if (timeOut != 0) { if (timeOut != 0) {
BukkitTask id = scheduler.runTaskLater(plugin, new TimeoutTask(plugin, playerNameLowerCase, target), timeOut); BukkitTask id = scheduler.runTaskLater(plugin, new TimeoutTask(plugin, playerNameLowerCase, target), timeOut);
LimboCache.getInstance().getLimboPlayer(playerNameLowerCase).setTimeoutTaskId(id); LimboCache.getInstance().getLimboPlayer(playerNameLowerCase).setTimeoutTask(id);
} }
LimboCache.getInstance().getLimboPlayer(playerNameLowerCase).setMessageTaskId( LimboCache.getInstance().getLimboPlayer(playerNameLowerCase).setMessageTask(
scheduler.runTask( scheduler.runTask(
plugin, new MessageTask(plugin, playerNameLowerCase, MessageKey.REGISTER_MESSAGE, interval) plugin, new MessageTask(plugin, playerNameLowerCase, MessageKey.REGISTER_MESSAGE, interval)
) )
); );
if (Settings.applyBlindEffect) { if (commandService.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
target.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2)); target.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
} }
commandService.send(target, MessageKey.UNREGISTERED_SUCCESS); commandService.send(target, MessageKey.UNREGISTERED_SUCCESS);

10
src/main/java/fr/xephi/authme/command/executable/authme/VersionCommand.java
View File

@ -3,15 +3,15 @@ package fr.xephi.authme.command.executable.authme;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.command.CommandService; import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.command.ExecutableCommand; import fr.xephi.authme.command.ExecutableCommand;
import static fr.xephi.authme.settings.properties.PluginSettings.HELP_HEADER;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import java.util.List;
import org.bukkit.ChatColor; import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import java.util.List;
import static fr.xephi.authme.settings.properties.PluginSettings.HELP_HEADER;
public class VersionCommand implements ExecutableCommand { public class VersionCommand implements ExecutableCommand {
@Override @Override
@ -71,8 +71,6 @@ public class VersionCommand implements ExecutableCommand {
* @return True if the player is online, false otherwise. * @return True if the player is online, false otherwise.
*/ */
private static boolean isPlayerOnline(String minecraftName) { private static boolean isPlayerOnline(String minecraftName) {
// Note ljacqu 20151121: Generally you should use Utils#getOnlinePlayers to retrieve the list of online players.
// If it's only used in a for-each loop such as here, it's fine. For other purposes, go through the Utils class.
for (Player player : Utils.getOnlinePlayers()) { for (Player player : Utils.getOnlinePlayers()) {
if (player.getName().equalsIgnoreCase(minecraftName)) { if (player.getName().equalsIgnoreCase(minecraftName)) {
return true; return true;

6
src/main/java/fr/xephi/authme/command/executable/captcha/CaptchaCommand.java
View File

@ -7,7 +7,6 @@ import fr.xephi.authme.command.PlayerCommand;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.security.RandomString; import fr.xephi.authme.security.RandomString;
import fr.xephi.authme.settings.properties.SecuritySettings; import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.util.Wrapper;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import java.util.List; import java.util.List;
@ -18,9 +17,8 @@ public class CaptchaCommand extends PlayerCommand {
public void runCommand(Player player, List<String> arguments, CommandService commandService) { public void runCommand(Player player, List<String> arguments, CommandService commandService) {
final String playerNameLowerCase = player.getName().toLowerCase(); final String playerNameLowerCase = player.getName().toLowerCase();
final String captcha = arguments.get(0); final String captcha = arguments.get(0);
Wrapper wrapper = Wrapper.getInstance(); final AuthMe plugin = commandService.getAuthMe();
final AuthMe plugin = wrapper.getAuthMe(); PlayerCache playerCache = PlayerCache.getInstance();
PlayerCache playerCache = wrapper.getPlayerCache();
// Command logic // Command logic
if (playerCache.isAuthenticated(playerNameLowerCase)) { if (playerCache.isAuthenticated(playerNameLowerCase)) {

4
src/main/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommand.java
View File

@ -8,7 +8,6 @@ import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.settings.properties.RestrictionSettings; import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings; import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.task.ChangePasswordTask; import fr.xephi.authme.task.ChangePasswordTask;
import fr.xephi.authme.util.Wrapper;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import java.util.List; import java.util.List;
@ -24,8 +23,7 @@ public class ChangePasswordCommand extends PlayerCommand {
String newPassword = arguments.get(1); String newPassword = arguments.get(1);
String name = player.getName().toLowerCase(); String name = player.getName().toLowerCase();
Wrapper wrapper = Wrapper.getInstance(); final PlayerCache playerCache = commandService.getPlayerCache();
final PlayerCache playerCache = wrapper.getPlayerCache();
if (!playerCache.isAuthenticated(name)) { if (!playerCache.isAuthenticated(name)) {
commandService.send(player, MessageKey.NOT_LOGGED_IN); commandService.send(player, MessageKey.NOT_LOGGED_IN);
return; return;

3
src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java
View File

@ -7,6 +7,7 @@ import fr.xephi.authme.process.Management;
import fr.xephi.authme.security.HashAlgorithm; import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.security.RandomString; import fr.xephi.authme.security.RandomString;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
@ -17,7 +18,7 @@ public class RegisterCommand extends PlayerCommand {
@Override @Override
public void runCommand(Player player, List<String> arguments, CommandService commandService) { public void runCommand(Player player, List<String> arguments, CommandService commandService) {
if (Settings.getPasswordHash == HashAlgorithm.TWO_FACTOR) { if (commandService.getProperty(SecuritySettings.PASSWORD_HASH) == HashAlgorithm.TWO_FACTOR) {
//for two factor auth we don't need to check the usage //for two factor auth we don't need to check the usage
commandService.getManagement().performRegister(player, "", ""); commandService.getManagement().performRegister(player, "", "");
return; return;

21
src/main/java/fr/xephi/authme/hooks/BungeeCordMessage.java
View File

@ -7,6 +7,7 @@ import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.auth.PlayerAuth; import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache; import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.cache.IpAddressManager;
import fr.xephi.authme.security.crypts.HashedPassword; import fr.xephi.authme.security.crypts.HashedPassword;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.plugin.messaging.PluginMessageListener; import org.bukkit.plugin.messaging.PluginMessageListener;
@ -15,30 +16,32 @@ import org.bukkit.plugin.messaging.PluginMessageListener;
*/ */
public class BungeeCordMessage implements PluginMessageListener { public class BungeeCordMessage implements PluginMessageListener {
public final AuthMe plugin; private final AuthMe plugin;
private final IpAddressManager ipAddressManager;
/** /**
* Constructor for BungeeCordMessage. * Constructor for BungeeCordMessage.
* *
* @param plugin AuthMe * @param plugin AuthMe
*/ */
public BungeeCordMessage(AuthMe plugin) { public BungeeCordMessage(AuthMe plugin, IpAddressManager ipAddressManager) {
this.plugin = plugin; this.plugin = plugin;
this.ipAddressManager = ipAddressManager;
} }
@Override @Override
public void onPluginMessageReceived(String channel, Player player, byte[] message) { public void onPluginMessageReceived(String channel, Player player, byte[] message) {
if (!channel.equals("BungeeCord")) { if (!"BungeeCord".equals(channel)) {
return; return;
} }
ByteArrayDataInput in = ByteStreams.newDataInput(message); ByteArrayDataInput in = ByteStreams.newDataInput(message);
String subChannel = in.readUTF(); String subChannel = in.readUTF();
if (subChannel.equals("IP")) { // We need only the IP channel if ("IP".equals(subChannel)) { // We need only the IP channel
String ip = in.readUTF(); String ip = in.readUTF();
// Put the IP (only the ip not the port) in the hashMap // Put the IP (only the ip not the port) in the hashMap
plugin.realIp.put(player.getName().toLowerCase(), ip); ipAddressManager.addCache(player.getName(), ip);
} }
if (subChannel.equalsIgnoreCase("AuthMe")) { if ("AuthMe".equalsIgnoreCase(subChannel)) {
String str = in.readUTF(); String str = in.readUTF();
final String[] args = str.split(";"); final String[] args = str.split(";");
final String act = args[0]; final String act = args[0];
@ -65,10 +68,10 @@ public class BungeeCordMessage implements PluginMessageListener {
ConsoleLogger.info("Player " + auth.getNickname() ConsoleLogger.info("Player " + auth.getNickname()
+ " has registered out from one of your server!"); + " has registered out from one of your server!");
} else if ("changepassword".equals(act)) { } else if ("changepassword".equals(act)) {
final String password = args[2]; final String password = args[2];
final String salt = args.length >= 4 ? args[3] : null; final String salt = args.length >= 4 ? args[3] : null;
auth.setPassword(new HashedPassword(password, salt)); auth.setPassword(new HashedPassword(password, salt));
PlayerCache.getInstance().updatePlayer(auth); PlayerCache.getInstance().updatePlayer(auth);
dataSource.updatePassword(auth); dataSource.updatePassword(auth);
} }

8
src/main/java/fr/xephi/authme/permission/PlayerPermission.java
View File

@ -55,10 +55,10 @@ public enum PlayerPermission implements PermissionNode {
*/ */
CAN_LOGIN_BE_FORCED("authme.player.canbeforced"), CAN_LOGIN_BE_FORCED("authme.player.canbeforced"),
/** /**
* Permission to use to see own other accounts. * Permission to use to see own other accounts.
*/ */
SEE_OWN_ACCOUNTS("authme.player.seeownaccounts"); SEE_OWN_ACCOUNTS("authme.player.seeownaccounts");
/** /**
* The permission node. * The permission node.

59
src/main/java/fr/xephi/authme/process/Management.java
View File

@ -11,7 +11,6 @@ import fr.xephi.authme.process.logout.AsynchronousLogout;
import fr.xephi.authme.process.quit.AsynchronousQuit; import fr.xephi.authme.process.quit.AsynchronousQuit;
import fr.xephi.authme.process.register.AsyncRegister; import fr.xephi.authme.process.register.AsyncRegister;
import fr.xephi.authme.process.unregister.AsynchronousUnregister; import fr.xephi.authme.process.unregister.AsynchronousUnregister;
import fr.xephi.authme.settings.NewSetting;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitScheduler; import org.bukkit.scheduler.BukkitScheduler;
@ -24,63 +23,29 @@ public class Management {
private final ProcessService processService; private final ProcessService processService;
private final DataSource dataSource; private final DataSource dataSource;
private final PlayerCache playerCache; private final PlayerCache playerCache;
private final NewSetting settings;
/**
* Constructor for Management.
*
* @param plugin AuthMe
*/
public Management(AuthMe plugin, ProcessService processService, DataSource dataSource, PlayerCache playerCache) { public Management(AuthMe plugin, ProcessService processService, DataSource dataSource, PlayerCache playerCache) {
this.plugin = plugin; this.plugin = plugin;
this.sched = this.plugin.getServer().getScheduler(); this.sched = this.plugin.getServer().getScheduler();
this.processService = processService; this.processService = processService;
this.dataSource = dataSource; this.dataSource = dataSource;
this.playerCache = playerCache; this.playerCache = playerCache;
// FIXME don't pass settings anymore -> go through the service in the processes
this.settings = processService.getSettings();
} }
public void performLogin(final Player player, final String password, final boolean forceLogin) { public void performLogin(final Player player, final String password, final boolean forceLogin) {
sched.runTaskAsynchronously(plugin, new Runnable() { runTask(new AsynchronousLogin(player, password, forceLogin, plugin, dataSource, processService));
@Override
public void run() {
new AsynchronousLogin(player, password, forceLogin, plugin, dataSource, settings)
.process();
}
});
} }
public void performLogout(final Player player) { public void performLogout(final Player player) {
sched.runTaskAsynchronously(plugin, new Runnable() { runTask(new AsynchronousLogout(player, plugin, dataSource, processService));
@Override
public void run() {
new AsynchronousLogout(player, plugin, plugin.getDataSource()).process();
}
});
} }
public void performRegister(final Player player, final String password, final String email) { public void performRegister(final Player player, final String password, final String email) {
sched.runTaskAsynchronously(plugin, new Runnable() { runTask(new AsyncRegister(player, password, email, plugin, dataSource, processService));
@Override
public void run() {
new AsyncRegister(player, password, email, plugin, dataSource, settings).process();
}
});
} }
public void performUnregister(final Player player, final String password, final boolean force) { public void performUnregister(final Player player, final String password, final boolean force) {
sched.runTaskAsynchronously(plugin, new Runnable() { runTask(new AsynchronousUnregister(player, password, force, plugin, processService));
@Override
public void run() {
new AsynchronousUnregister(player, password, force, plugin).process();
}
});
} }
public void performJoin(final Player player) { public void performJoin(final Player player) {
@ -88,14 +53,7 @@ public class Management {
} }
public void performQuit(final Player player, final boolean isKick) { public void performQuit(final Player player, final boolean isKick) {
sched.runTaskAsynchronously(plugin, new Runnable() { runTask(new AsynchronousQuit(player, plugin, dataSource, isKick, processService));
@Override
public void run() {
new AsynchronousQuit(player, plugin, dataSource, isKick).process();
}
});
} }
public void performAddEmail(final Player player, final String newEmail) { public void performAddEmail(final Player player, final String newEmail) {
@ -103,12 +61,7 @@ public class Management {
} }
public void performChangeEmail(final Player player, final String oldEmail, final String newEmail) { public void performChangeEmail(final Player player, final String oldEmail, final String newEmail) {
sched.runTaskAsynchronously(plugin, new Runnable() { runTask(new AsyncChangeEmail(player, oldEmail, newEmail, dataSource, playerCache, processService));
@Override
public void run() {
new AsyncChangeEmail(player, plugin, oldEmail, newEmail, dataSource, playerCache, settings).process();
}
});
} }
private void runTask(Process process) { private void runTask(Process process) {

28
src/main/java/fr/xephi/authme/process/ProcessService.java
View File

@ -1,8 +1,11 @@
package fr.xephi.authme.process; package fr.xephi.authme.process;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.IpAddressManager;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.output.Messages;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.settings.NewSetting; import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.domain.Property; import fr.xephi.authme.settings.domain.Property;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
@ -17,11 +20,16 @@ public class ProcessService {
private final NewSetting settings; private final NewSetting settings;
private final Messages messages; private final Messages messages;
private final AuthMe authMe; private final AuthMe authMe;
private final IpAddressManager ipAddressManager;
private final PasswordSecurity passwordSecurity;
public ProcessService(NewSetting settings, Messages messages, AuthMe authMe) { public ProcessService(NewSetting settings, Messages messages, AuthMe authMe, IpAddressManager ipAddressManager,
PasswordSecurity passwordSecurity) {
this.settings = settings; this.settings = settings;
this.messages = messages; this.messages = messages;
this.authMe = authMe; this.authMe = authMe;
this.ipAddressManager = ipAddressManager;
this.passwordSecurity = passwordSecurity;
} }
public <T> T getProperty(Property<T> property) { public <T> T getProperty(Property<T> property) {
@ -36,7 +44,15 @@ public class ProcessService {
messages.send(sender, key); messages.send(sender, key);
} }
public String retrieveMessage(MessageKey key) { public void send(CommandSender sender, MessageKey key, String... replacements) {
messages.send(sender, key, replacements);
}
public String[] retrieveMessage(MessageKey key) {
return messages.retrieve(key);
}
public String retrieveSingleMessage(MessageKey key) {
return messages.retrieveSingle(key); return messages.retrieveSingle(key);
} }
@ -60,4 +76,12 @@ public class ProcessService {
return authMe; return authMe;
} }
public IpAddressManager getIpAddressManager() {
return ipAddressManager;
}
public HashedPassword computeHash(String password, String username) {
return passwordSecurity.computeHash(password, username);
}
} }

44
src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java
View File

@ -1,54 +1,52 @@
package fr.xephi.authme.process.email; package fr.xephi.authme.process.email;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth; import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache; import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.Process;
import fr.xephi.authme.settings.NewSetting; import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
/** /**
* Async task for changing the email. * Async task for changing the email.
*/ */
public class AsyncChangeEmail { public class AsyncChangeEmail implements Process {
private final Player player; private final Player player;
private final String oldEmail; private final String oldEmail;
private final String newEmail; private final String newEmail;
private final Messages m; private final ProcessService service;
private final NewSetting settings;
private final PlayerCache playerCache; private final PlayerCache playerCache;
private final DataSource dataSource; private final DataSource dataSource;
public AsyncChangeEmail(Player player, AuthMe plugin, String oldEmail, String newEmail, DataSource dataSource, public AsyncChangeEmail(Player player, String oldEmail, String newEmail, DataSource dataSource,
PlayerCache playerCache, NewSetting settings) { PlayerCache playerCache, ProcessService service) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.oldEmail = oldEmail; this.oldEmail = oldEmail;
this.newEmail = newEmail; this.newEmail = newEmail;
this.playerCache = playerCache; this.playerCache = playerCache;
this.dataSource = dataSource; this.dataSource = dataSource;
this.settings = settings; this.service = service;
} }
public void process() { @Override
public void run() {
String playerName = player.getName().toLowerCase(); String playerName = player.getName().toLowerCase();
if (playerCache.isAuthenticated(playerName)) { if (playerCache.isAuthenticated(playerName)) {
PlayerAuth auth = playerCache.getAuth(playerName); PlayerAuth auth = playerCache.getAuth(playerName);
final String currentEmail = auth.getEmail(); final String currentEmail = auth.getEmail();
if (currentEmail == null) { if (currentEmail == null) {
m.send(player, MessageKey.USAGE_ADD_EMAIL); service.send(player, MessageKey.USAGE_ADD_EMAIL);
} else if (newEmail == null || !Utils.isEmailCorrect(newEmail, settings)) { } else if (newEmail == null || !Utils.isEmailCorrect(newEmail, service.getSettings())) {
m.send(player, MessageKey.INVALID_NEW_EMAIL); service.send(player, MessageKey.INVALID_NEW_EMAIL);
} else if (!oldEmail.equals(currentEmail)) { } else if (!oldEmail.equals(currentEmail)) {
m.send(player, MessageKey.INVALID_OLD_EMAIL); service.send(player, MessageKey.INVALID_OLD_EMAIL);
} else if (dataSource.isEmailStored(newEmail)) { } else if (dataSource.isEmailStored(newEmail)) {
m.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR); service.send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
} else { } else {
saveNewEmail(auth); saveNewEmail(auth);
} }
@ -61,20 +59,20 @@ public class AsyncChangeEmail {
auth.setEmail(newEmail); auth.setEmail(newEmail);
if (dataSource.updateEmail(auth)) { if (dataSource.updateEmail(auth)) {
playerCache.updatePlayer(auth); playerCache.updatePlayer(auth);
m.send(player, MessageKey.EMAIL_CHANGED_SUCCESS); service.send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
} else { } else {
m.send(player, MessageKey.ERROR); service.send(player, MessageKey.ERROR);
auth.setEmail(newEmail); auth.setEmail(newEmail);
} }
} }
private void outputUnloggedMessage() { private void outputUnloggedMessage() {
if (dataSource.isAuthAvailable(player.getName())) { if (dataSource.isAuthAvailable(player.getName())) {
m.send(player, MessageKey.LOGIN_MESSAGE); service.send(player, MessageKey.LOGIN_MESSAGE);
} else if (Settings.emailRegistration) { } else if (service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)) {
m.send(player, MessageKey.REGISTER_EMAIL_MESSAGE); service.send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
} else { } else {
m.send(player, MessageKey.REGISTER_MESSAGE); service.send(player, MessageKey.REGISTER_MESSAGE);
} }
} }
} }

22
src/main/java/fr/xephi/authme/process/join/AsynchronousJoin.java
View File

@ -59,23 +59,17 @@ public class AsynchronousJoin implements Process {
return; return;
} }
if (service.getProperty(HooksSettings.ENABLE_VERYGAMES_IP_CHECK)) {
plugin.getVerygamesIp(player);
}
if (plugin.ess != null && service.getProperty(HooksSettings.DISABLE_SOCIAL_SPY)) { if (plugin.ess != null && service.getProperty(HooksSettings.DISABLE_SOCIAL_SPY)) {
plugin.ess.getUser(player).setSocialSpyEnabled(false); plugin.ess.getUser(player).setSocialSpyEnabled(false);
} }
final String ip = plugin.getIP(player); final String ip = service.getIpAddressManager().getPlayerIp(player);
if (isNameRestricted(name, ip, player.getAddress().getHostName(), service.getSettings())) { if (isNameRestricted(name, ip, player.getAddress().getHostName(), service.getSettings())) {
service.scheduleSyncDelayedTask(new Runnable() { service.scheduleSyncDelayedTask(new Runnable() {
@Override @Override
public void run() { public void run() {
AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true); AuthMePlayerListener.causeByAuthMe.putIfAbsent(name, true);
player.kickPlayer(service.retrieveMessage(MessageKey.NOT_OWNER_ERROR)); player.kickPlayer(service.retrieveSingleMessage(MessageKey.NOT_OWNER_ERROR));
if (Settings.banUnsafeIp) { if (Settings.banUnsafeIp) {
plugin.getServer().banIP(ip); plugin.getServer().banIP(ip);
} }
@ -87,7 +81,7 @@ public class AsynchronousJoin implements Process {
&& !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS) && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)
&& !"127.0.0.1".equalsIgnoreCase(ip) && !"127.0.0.1".equalsIgnoreCase(ip)
&& !"localhost".equalsIgnoreCase(ip) && !"localhost".equalsIgnoreCase(ip)
&& hasJoinedIp(player.getName(), ip, service.getSettings(), service.getAuthMe())) { && hasJoinedIp(player.getName(), ip, service.getSettings())) {
service.scheduleSyncDelayedTask(new Runnable() { service.scheduleSyncDelayedTask(new Runnable() {
@Override @Override
public void run() { public void run() {
@ -200,7 +194,7 @@ public class AsynchronousJoin implements Process {
int msgInterval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL); int msgInterval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
if (registrationTimeout > 0) { if (registrationTimeout > 0) {
BukkitTask id = service.runTaskLater(new TimeoutTask(plugin, name, player), registrationTimeout); BukkitTask id = service.runTaskLater(new TimeoutTask(plugin, name, player), registrationTimeout);
LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id); LimboCache.getInstance().getLimboPlayer(name).setTimeoutTask(id);
} }
MessageKey msg; MessageKey msg;
@ -213,7 +207,7 @@ public class AsynchronousJoin implements Process {
} }
if (msgInterval > 0 && LimboCache.getInstance().getLimboPlayer(name) != null) { if (msgInterval > 0 && LimboCache.getInstance().getLimboPlayer(name) != null) {
BukkitTask msgTask = service.runTask(new MessageTask(plugin, name, msg, msgInterval)); BukkitTask msgTask = service.runTask(new MessageTask(plugin, name, msg, msgInterval));
LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgTask); LimboCache.getInstance().getLimboPlayer(name).setMessageTask(msgTask);
} }
} }
@ -295,11 +289,13 @@ public class AsynchronousJoin implements Process {
return nameFound; return nameFound;
} }
private boolean hasJoinedIp(String name, String ip, NewSetting settings, AuthMe authMe) { private boolean hasJoinedIp(String name, String ip, NewSetting settings) {
int count = 0; int count = 0;
for (Player player : Utils.getOnlinePlayers()) { for (Player player : Utils.getOnlinePlayers()) {
if (ip.equalsIgnoreCase(authMe.getIP(player)) && !player.getName().equalsIgnoreCase(name)) if (ip.equalsIgnoreCase(service.getIpAddressManager().getPlayerIp(player))
&& !player.getName().equalsIgnoreCase(name)) {
count++; count++;
}
} }
return count >= settings.getProperty(RestrictionSettings.MAX_JOIN_PER_IP); return count >= settings.getProperty(RestrictionSettings.MAX_JOIN_PER_IP);
} }

94
src/main/java/fr/xephi/authme/process/login/AsynchronousLogin.java
View File

@ -8,14 +8,17 @@ import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.events.AuthMeAsyncPreLoginEvent; import fr.xephi.authme.events.AuthMeAsyncPreLoginEvent;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.permission.AdminPermission; import fr.xephi.authme.permission.AdminPermission;
import fr.xephi.authme.permission.PlayerPermission; import fr.xephi.authme.permission.PlayerPermission;
import fr.xephi.authme.permission.PlayerStatePermission; import fr.xephi.authme.permission.PlayerStatePermission;
import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.security.RandomString; import fr.xephi.authme.security.RandomString;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.DatabaseSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings; import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.task.MessageTask; import fr.xephi.authme.task.MessageTask;
import fr.xephi.authme.util.StringUtils; import fr.xephi.authme.util.StringUtils;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
@ -27,7 +30,7 @@ import java.util.List;
/** /**
*/ */
public class AsynchronousLogin { public class AsynchronousLogin implements Process {
private final Player player; private final Player player;
private final String name; private final String name;
@ -36,23 +39,11 @@ public class AsynchronousLogin {
private final boolean forceLogin; private final boolean forceLogin;
private final AuthMe plugin; private final AuthMe plugin;
private final DataSource database; private final DataSource database;
private final Messages m;
private final String ip; private final String ip;
private final NewSetting settings; private final ProcessService service;
/**
* Constructor for AsynchronousLogin.
*
* @param player Player
* @param password String
* @param forceLogin boolean
* @param plugin AuthMe
* @param data DataSource
* @param settings The settings
*/
public AsynchronousLogin(Player player, String password, boolean forceLogin, AuthMe plugin, DataSource data, public AsynchronousLogin(Player player, String password, boolean forceLogin, AuthMe plugin, DataSource data,
NewSetting settings) { ProcessService service) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.password = password; this.password = password;
@ -60,12 +51,12 @@ public class AsynchronousLogin {
this.forceLogin = forceLogin; this.forceLogin = forceLogin;
this.plugin = plugin; this.plugin = plugin;
this.database = data; this.database = data;
this.ip = plugin.getIP(player); this.ip = service.getIpAddressManager().getPlayerIp(player);
this.settings = settings; this.service = service;
} }
private boolean needsCaptcha() { private boolean needsCaptcha() {
if (Settings.useCaptcha) { if (service.getProperty(SecuritySettings.USE_CAPTCHA)) {
if (!plugin.captcha.containsKey(name)) { if (!plugin.captcha.containsKey(name)) {
plugin.captcha.putIfAbsent(name, 1); plugin.captcha.putIfAbsent(name, 1);
} else { } else {
@ -75,7 +66,7 @@ public class AsynchronousLogin {
} }
if (plugin.captcha.containsKey(name) && plugin.captcha.get(name) > Settings.maxLoginTry) { if (plugin.captcha.containsKey(name) && plugin.captcha.get(name) > Settings.maxLoginTry) {
plugin.cap.putIfAbsent(name, RandomString.generate(Settings.captchaLength)); plugin.cap.putIfAbsent(name, RandomString.generate(Settings.captchaLength));
m.send(player, MessageKey.USAGE_CAPTCHA, plugin.cap.get(name)); service.send(player, MessageKey.USAGE_CAPTCHA, plugin.cap.get(name));
return true; return true;
} }
} }
@ -90,30 +81,27 @@ public class AsynchronousLogin {
*/ */
private PlayerAuth preAuth() { private PlayerAuth preAuth() {
if (PlayerCache.getInstance().isAuthenticated(name)) { if (PlayerCache.getInstance().isAuthenticated(name)) {
m.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR); service.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
return null; return null;
} }
PlayerAuth pAuth = database.getAuth(name); PlayerAuth pAuth = database.getAuth(name);
if (pAuth == null) { if (pAuth == null) {
m.send(player, MessageKey.USER_NOT_REGISTERED); service.send(player, MessageKey.USER_NOT_REGISTERED);
if (LimboCache.getInstance().hasLimboPlayer(name)) { if (LimboCache.getInstance().hasLimboPlayer(name)) {
LimboCache.getInstance().getLimboPlayer(name).getMessageTaskId().cancel(); LimboCache.getInstance().getLimboPlayer(name).getMessageTask().cancel();
String[] msg; String[] msg = service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)
if (Settings.emailRegistration) { ? service.retrieveMessage(MessageKey.REGISTER_EMAIL_MESSAGE)
msg = m.retrieve(MessageKey.REGISTER_EMAIL_MESSAGE); : service.retrieveMessage(MessageKey.REGISTER_MESSAGE);
} else { BukkitTask messageTask = service.runTask(
msg = m.retrieve(MessageKey.REGISTER_MESSAGE); new MessageTask(plugin, name, msg, service.getProperty(RegistrationSettings.MESSAGE_INTERVAL)));
} LimboCache.getInstance().getLimboPlayer(name).setMessageTask(messageTask);
BukkitTask msgT = Bukkit.getScheduler().runTask(plugin,
new MessageTask(plugin, name, msg, settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)));
LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgT);
} }
return null; return null;
} }
if (!Settings.getMySQLColumnGroup.isEmpty() && pAuth.getGroupId() == Settings.getNonActivatedGroup) { if (!service.getProperty(DatabaseSettings.MYSQL_COL_GROUP).isEmpty() && pAuth.getGroupId() == Settings.getNonActivatedGroup) {
m.send(player, MessageKey.ACCOUNT_NOT_ACTIVATED); service.send(player, MessageKey.ACCOUNT_NOT_ACTIVATED);
return null; return null;
} }
@ -121,7 +109,7 @@ public class AsynchronousLogin {
&& !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS) && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)
&& !ip.equalsIgnoreCase("127.0.0.1") && !ip.equalsIgnoreCase("localhost")) { && !ip.equalsIgnoreCase("127.0.0.1") && !ip.equalsIgnoreCase("localhost")) {
if (plugin.isLoggedIp(name, ip)) { if (plugin.isLoggedIp(name, ip)) {
m.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR); service.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
return null; return null;
} }
} }
@ -134,13 +122,14 @@ public class AsynchronousLogin {
return pAuth; return pAuth;
} }
public void process() { @Override
public void run() {
PlayerAuth pAuth = preAuth(); PlayerAuth pAuth = preAuth();
if (pAuth == null || needsCaptcha()) { if (pAuth == null || needsCaptcha()) {
return; return;
} }
if (pAuth.getIp().equals("127.0.0.1") && !pAuth.getIp().equals(ip)) { if ("127.0.0.1".equals(pAuth.getIp()) && !pAuth.getIp().equals(ip)) {
pAuth.setIp(ip); pAuth.setIp(ip);
database.updateIp(pAuth.getNickname(), ip); database.updateIp(pAuth.getNickname(), ip);
} }
@ -159,7 +148,7 @@ public class AsynchronousLogin {
.build(); .build();
database.updateSession(auth); database.updateSession(auth);
if (Settings.useCaptcha) { if (service.getProperty(SecuritySettings.USE_CAPTCHA)) {
if (plugin.captcha.containsKey(name)) { if (plugin.captcha.containsKey(name)) {
plugin.captcha.remove(name); plugin.captcha.remove(name);
} }
@ -170,12 +159,12 @@ public class AsynchronousLogin {
player.setNoDamageTicks(0); player.setNoDamageTicks(0);
if (!forceLogin) if (!forceLogin)
m.send(player, MessageKey.LOGIN_SUCCESS); service.send(player, MessageKey.LOGIN_SUCCESS);
displayOtherAccounts(auth); displayOtherAccounts(auth);
if (Settings.recallEmail && (StringUtils.isEmpty(email) || "your@email.com".equalsIgnoreCase(email))) { if (Settings.recallEmail && (StringUtils.isEmpty(email) || "your@email.com".equalsIgnoreCase(email))) {
m.send(player, MessageKey.ADD_EMAIL_MESSAGE); service.send(player, MessageKey.ADD_EMAIL_MESSAGE);
} }
if (!Settings.noConsoleSpam) { if (!Settings.noConsoleSpam) {
@ -190,29 +179,30 @@ public class AsynchronousLogin {
// task, we schedule it in the end // task, we schedule it in the end
// so that we can be sure, and have not to care if it might be // so that we can be sure, and have not to care if it might be
// processed in other order. // processed in other order.
ProcessSyncPlayerLogin syncPlayerLogin = new ProcessSyncPlayerLogin(player, plugin, database, settings); ProcessSyncPlayerLogin syncPlayerLogin = new ProcessSyncPlayerLogin(
player, plugin, database, service.getSettings());
if (syncPlayerLogin.getLimbo() != null) { if (syncPlayerLogin.getLimbo() != null) {
if (syncPlayerLogin.getLimbo().getTimeoutTaskId() != null) { if (syncPlayerLogin.getLimbo().getTimeoutTask() != null) {
syncPlayerLogin.getLimbo().getTimeoutTaskId().cancel(); syncPlayerLogin.getLimbo().getTimeoutTask().cancel();
} }
if (syncPlayerLogin.getLimbo().getMessageTaskId() != null) { if (syncPlayerLogin.getLimbo().getMessageTask() != null) {
syncPlayerLogin.getLimbo().getMessageTaskId().cancel(); syncPlayerLogin.getLimbo().getMessageTask().cancel();
} }
} }
Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, syncPlayerLogin); Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, syncPlayerLogin);
} else if (player.isOnline()) { } else if (player.isOnline()) {
if (!Settings.noConsoleSpam) if (!service.getProperty(SecuritySettings.REMOVE_SPAM_FROM_CONSOLE)) {
ConsoleLogger.info(realName + " used the wrong password"); ConsoleLogger.info(realName + " used the wrong password");
if (Settings.isKickOnWrongPasswordEnabled) { }
Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() { if (service.getProperty(RestrictionSettings.KICK_ON_WRONG_PASSWORD)) {
service.scheduleSyncDelayedTask(new Runnable() {
@Override @Override
public void run() { public void run() {
player.kickPlayer(m.retrieveSingle(MessageKey.WRONG_PASSWORD)); player.kickPlayer(service.retrieveSingleMessage(MessageKey.WRONG_PASSWORD));
} }
}); });
} else { } else {
m.send(player, MessageKey.WRONG_PASSWORD); service.send(player, MessageKey.WRONG_PASSWORD);
} }
} else { } else {
ConsoleLogger.showError("Player " + name + " wasn't online during login process, aborted... "); ConsoleLogger.showError("Player " + name + " wasn't online during login process, aborted... ");

2
src/main/java/fr/xephi/authme/process/login/ProcessSyncPlayerLogin.java
View File

@ -67,7 +67,7 @@ public class ProcessSyncPlayerLogin implements Runnable {
} }
private void restoreOpState() { private void restoreOpState() {
player.setOp(limbo.getOperator()); player.setOp(limbo.isOperator());
} }
private void packQuitLocation() { private void packQuitLocation() {

33
src/main/java/fr/xephi/authme/process/logout/AsynchronousLogout.java
View File

@ -6,22 +6,22 @@ import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.cache.limbo.LimboCache; import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import fr.xephi.authme.util.Utils.GroupType; import fr.xephi.authme.util.Utils.GroupType;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitScheduler;
/** /**
*/ */
public class AsynchronousLogout { public class AsynchronousLogout implements Process {
protected final Player player; private final Player player;
protected final String name; private final String name;
protected final AuthMe plugin; private final AuthMe plugin;
protected final DataSource database; private final DataSource database;
protected boolean canLogout = true; private boolean canLogout = true;
private final Messages m; private final ProcessService service;
/** /**
* Constructor for AsynchronousLogout. * Constructor for AsynchronousLogout.
@ -29,29 +29,30 @@ public class AsynchronousLogout {
* @param player Player * @param player Player
* @param plugin AuthMe * @param plugin AuthMe
* @param database DataSource * @param database DataSource
* @param service The process service
*/ */
public AsynchronousLogout(Player player, AuthMe plugin, DataSource database) { public AsynchronousLogout(Player player, AuthMe plugin, DataSource database, ProcessService service) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.plugin = plugin; this.plugin = plugin;
this.database = database; this.database = database;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.service = service;
} }
private void preLogout() { private void preLogout() {
if (!PlayerCache.getInstance().isAuthenticated(name)) { if (!PlayerCache.getInstance().isAuthenticated(name)) {
m.send(player, MessageKey.NOT_LOGGED_IN); service.send(player, MessageKey.NOT_LOGGED_IN);
canLogout = false; canLogout = false;
} }
} }
public void process() { @Override
public void run() {
preLogout(); preLogout();
if (!canLogout) { if (!canLogout) {
return; return;
} }
final Player p = player; final Player p = player;
BukkitScheduler scheduler = p.getServer().getScheduler();
PlayerAuth auth = PlayerCache.getInstance().getAuth(name); PlayerAuth auth = PlayerCache.getInstance().getAuth(name);
database.updateSession(auth); database.updateSession(auth);
auth.setQuitLocX(p.getLocation().getX()); auth.setQuitLocX(p.getLocation().getX());
@ -62,7 +63,7 @@ public class AsynchronousLogout {
PlayerCache.getInstance().removePlayer(name); PlayerCache.getInstance().removePlayer(name);
database.setUnlogged(name); database.setUnlogged(name);
scheduler.scheduleSyncDelayedTask(plugin, new Runnable() { service.scheduleSyncDelayedTask(new Runnable() {
@Override @Override
public void run() { public void run() {
Utils.teleportToSpawn(p); Utils.teleportToSpawn(p);
@ -73,6 +74,6 @@ public class AsynchronousLogout {
} }
LimboCache.getInstance().addLimboPlayer(player); LimboCache.getInstance().addLimboPlayer(player);
Utils.setGroup(player, GroupType.NOTLOGGEDIN); Utils.setGroup(player, GroupType.NOTLOGGEDIN);
scheduler.scheduleSyncDelayedTask(plugin, new ProcessSyncronousPlayerLogout(p, plugin)); service.scheduleSyncDelayedTask(new ProcessSynchronousPlayerLogout(p, plugin, service));
} }
} }

45
src/main/java/fr/xephi/authme/process/logout/ProcessSyncronousPlayerLogout.java → src/main/java/fr/xephi/authme/process/logout/ProcessSynchronousPlayerLogout.java
View File

@ -7,37 +7,40 @@ import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.limbo.LimboCache; import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.events.LogoutEvent; import fr.xephi.authme.events.LogoutEvent;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.task.MessageTask; import fr.xephi.authme.task.MessageTask;
import fr.xephi.authme.task.TimeoutTask; import fr.xephi.authme.task.TimeoutTask;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType; import org.bukkit.potion.PotionEffectType;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
/** /**
*/ */
public class ProcessSyncronousPlayerLogout implements Runnable { public class ProcessSynchronousPlayerLogout implements Process {
protected final Player player; private final Player player;
protected final AuthMe plugin; private final AuthMe plugin;
protected final String name; private final String name;
private final Messages m; private final ProcessService service;
/** /**
* Constructor for ProcessSyncronousPlayerLogout. * Constructor for ProcessSynchronousPlayerLogout.
* *
* @param player Player * @param player Player
* @param plugin AuthMe * @param plugin AuthMe
* @param service The process service
*/ */
public ProcessSyncronousPlayerLogout(Player player, AuthMe plugin) { public ProcessSynchronousPlayerLogout(Player player, AuthMe plugin, ProcessService service) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.plugin = plugin; this.plugin = plugin;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.service = service;
} }
protected void sendBungeeMessage() { protected void sendBungeeMessage() {
@ -56,11 +59,6 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
} }
} }
/**
* Method run.
*
* @see java.lang.Runnable#run()
*/
@Override @Override
public void run() { public void run() {
if (plugin.sessions.containsKey(name)) { if (plugin.sessions.containsKey(name)) {
@ -70,19 +68,18 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
if (Settings.protectInventoryBeforeLogInEnabled) { if (Settings.protectInventoryBeforeLogInEnabled) {
plugin.inventoryProtector.sendBlankInventoryPacket(player); plugin.inventoryProtector.sendBlankInventoryPacket(player);
} }
int timeOut = Settings.getRegistrationTimeout * 20; int timeOut = service.getProperty(RestrictionSettings.TIMEOUT) * 20;
int interval = Settings.getWarnMessageInterval; int interval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
BukkitScheduler sched = player.getServer().getScheduler();
if (timeOut != 0) { if (timeOut != 0) {
BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut); BukkitTask id = service.runTaskLater(new TimeoutTask(plugin, name, player), timeOut);
LimboCache.getInstance().getLimboPlayer(name).setTimeoutTaskId(id); LimboCache.getInstance().getLimboPlayer(name).setTimeoutTask(id);
} }
BukkitTask msgT = sched.runTask(plugin, new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval)); BukkitTask msgT = service.runTask(new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval));
LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(msgT); LimboCache.getInstance().getLimboPlayer(name).setMessageTask(msgT);
if (player.isInsideVehicle() && player.getVehicle() != null) { if (player.isInsideVehicle() && player.getVehicle() != null) {
player.getVehicle().eject(); player.getVehicle().eject();
} }
if (Settings.applyBlindEffect) { if (service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2)); player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
} }
player.setOp(false); player.setOp(false);
@ -92,7 +89,7 @@ public class ProcessSyncronousPlayerLogout implements Runnable {
if (Settings.bungee) { if (Settings.bungee) {
sendBungeeMessage(); sendBungeeMessage();
} }
m.send(player, MessageKey.LOGOUT_SUCCESS); service.send(player, MessageKey.LOGOUT_SUCCESS);
ConsoleLogger.info(player.getName() + " logged out"); ConsoleLogger.info(player.getName() + " logged out");
} }

35
src/main/java/fr/xephi/authme/process/quit/AsynchronousQuit.java
View File

@ -7,15 +7,17 @@ import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.cache.limbo.LimboPlayer; import fr.xephi.authme.cache.limbo.LimboPlayer;
import fr.xephi.authme.datasource.CacheDataSource; import fr.xephi.authme.datasource.CacheDataSource;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.util.StringUtils; import fr.xephi.authme.util.StringUtils;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import org.bukkit.Bukkit;
import org.bukkit.Location; import org.bukkit.Location;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
public class AsynchronousQuit { public class AsynchronousQuit implements Process {
private final AuthMe plugin; private final AuthMe plugin;
private final DataSource database; private final DataSource database;
@ -23,33 +25,40 @@ public class AsynchronousQuit {
private final String name; private final String name;
private boolean isOp = false; private boolean isOp = false;
private boolean needToChange = false; private boolean needToChange = false;
private boolean isKick = false; private final boolean isKick;
private final ProcessService service;
public AsynchronousQuit(Player p, AuthMe plugin, DataSource database, public AsynchronousQuit(Player p, AuthMe plugin, DataSource database, boolean isKick, ProcessService service) {
boolean isKick) {
this.player = p; this.player = p;
this.plugin = plugin; this.plugin = plugin;
this.database = database; this.database = database;
this.name = p.getName().toLowerCase(); this.name = p.getName().toLowerCase();
this.isKick = isKick; this.isKick = isKick;
this.service = service;
} }
public void process() { @Override
public void run() {
if (player == null || Utils.isUnrestricted(player)) { if (player == null || Utils.isUnrestricted(player)) {
return; return;
} }
String ip = plugin.getIP(player); String ip = service.getIpAddressManager().getPlayerIp(player);
if (PlayerCache.getInstance().isAuthenticated(name)) { if (PlayerCache.getInstance().isAuthenticated(name)) {
if (Settings.isSaveQuitLocationEnabled) { if (service.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)) {
Location loc = player.getLocation(); Location loc = player.getLocation();
PlayerAuth auth = PlayerAuth.builder() PlayerAuth auth = PlayerAuth.builder()
.name(name).location(loc) .name(name).location(loc)
.realName(player.getName()).build(); .realName(player.getName()).build();
database.updateQuitLoc(auth); database.updateQuitLoc(auth);
} }
PlayerAuth auth = new PlayerAuth(name, ip, System.currentTimeMillis(), player.getName()); PlayerAuth auth = PlayerAuth.builder()
.name(name)
.realName(player.getName())
.ip(ip)
.lastLogin(System.currentTimeMillis())
.build();
database.updateSession(auth); database.updateSession(auth);
} }
@ -59,7 +68,7 @@ public class AsynchronousQuit {
Utils.addNormal(player, limbo.getGroup()); Utils.addNormal(player, limbo.getGroup());
} }
needToChange = true; needToChange = true;
isOp = limbo.getOperator(); isOp = limbo.isOperator();
LimboCache.getInstance().deleteLimboPlayer(name); LimboCache.getInstance().deleteLimboPlayer(name);
} }
if (Settings.isSessionsEnabled && !isKick) { if (Settings.isSessionsEnabled && !isKick) {
@ -76,7 +85,7 @@ public class AsynchronousQuit {
plugin.sessions.put(name, task); plugin.sessions.put(name, task);
} else { } else {
//plugin is disable we canno schedule more tasks so run it directly here //plugin is disabled; we cannot schedule more tasks so run it directly here
postLogout(); postLogout();
} }
} }
@ -85,9 +94,9 @@ public class AsynchronousQuit {
database.setUnlogged(name); database.setUnlogged(name);
} }
plugin.realIp.remove(name); service.getIpAddressManager().removeCache(player.getName());
if (plugin.isEnabled()) { if (plugin.isEnabled()) {
Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new ProcessSyncronousPlayerQuit(plugin, player, isOp, needToChange)); service.scheduleSyncDelayedTask(new ProcessSyncronousPlayerQuit(plugin, player, isOp, needToChange));
} }
// remove player from cache // remove player from cache
if (database instanceof CacheDataSource) { if (database instanceof CacheDataSource) {

79
src/main/java/fr/xephi/authme/process/register/AsyncRegister.java
View File

@ -1,27 +1,27 @@
package fr.xephi.authme.process.register; package fr.xephi.authme.process.register;
import java.util.List;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth; import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache; import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages;
import fr.xephi.authme.permission.PlayerStatePermission; import fr.xephi.authme.permission.PlayerStatePermission;
import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.security.HashAlgorithm; import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.security.crypts.HashedPassword; import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.security.crypts.TwoFactor; import fr.xephi.authme.security.crypts.TwoFactor;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.util.StringUtils; import fr.xephi.authme.util.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import java.util.List;
/** /**
*/ */
public class AsyncRegister { public class AsyncRegister implements Process {
private final Player player; private final Player player;
private final String name; private final String name;
@ -30,68 +30,68 @@ public class AsyncRegister {
private final String email; private final String email;
private final AuthMe plugin; private final AuthMe plugin;
private final DataSource database; private final DataSource database;
private final Messages m; private final ProcessService service;
private final NewSetting settings;
public AsyncRegister(Player player, String password, String email, AuthMe plugin, DataSource data, public AsyncRegister(Player player, String password, String email, AuthMe plugin, DataSource data,
NewSetting settings) { ProcessService service) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.password = password; this.password = password;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.email = email; this.email = email;
this.plugin = plugin; this.plugin = plugin;
this.database = data; this.database = data;
this.ip = plugin.getIP(player); this.ip = service.getIpAddressManager().getPlayerIp(player);
this.settings = settings; this.service = service;
} }
private boolean preRegisterCheck() { private boolean preRegisterCheck() {
String passLow = password.toLowerCase(); String passLow = password.toLowerCase();
if (PlayerCache.getInstance().isAuthenticated(name)) { if (PlayerCache.getInstance().isAuthenticated(name)) {
m.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR); service.send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
return false; return false;
} else if (!Settings.isRegistrationEnabled) { } else if (!Settings.isRegistrationEnabled) {
m.send(player, MessageKey.REGISTRATION_DISABLED); service.send(player, MessageKey.REGISTRATION_DISABLED);
return false; return false;
} }
//check the password safety only if it's not a automatically generated password //check the password safety only if it's not a automatically generated password
if (Settings.getPasswordHash != HashAlgorithm.TWO_FACTOR) { if (service.getProperty(SecuritySettings.PASSWORD_HASH) != HashAlgorithm.TWO_FACTOR) {
if (!passLow.matches(Settings.getPassRegex)) { if (!passLow.matches(Settings.getPassRegex)) {
m.send(player, MessageKey.PASSWORD_MATCH_ERROR); service.send(player, MessageKey.PASSWORD_MATCH_ERROR);
return false; return false;
} else if (passLow.equalsIgnoreCase(player.getName())) { } else if (passLow.equalsIgnoreCase(player.getName())) {
m.send(player, MessageKey.PASSWORD_IS_USERNAME_ERROR); service.send(player, MessageKey.PASSWORD_IS_USERNAME_ERROR);
return false; return false;
} else if (password.length() < Settings.getPasswordMinLen || password.length() > Settings.passwordMaxLength) { } else if (password.length() < Settings.getPasswordMinLen || password.length() > Settings.passwordMaxLength) {
m.send(player, MessageKey.INVALID_PASSWORD_LENGTH); service.send(player, MessageKey.INVALID_PASSWORD_LENGTH);
return false; return false;
} else if (!Settings.unsafePasswords.isEmpty() && Settings.unsafePasswords.contains(password.toLowerCase())) { } else if (!Settings.unsafePasswords.isEmpty() && Settings.unsafePasswords.contains(password.toLowerCase())) {
m.send(player, MessageKey.PASSWORD_UNSAFE_ERROR); service.send(player, MessageKey.PASSWORD_UNSAFE_ERROR);
return false; return false;
} }
} }
//check this in both possiblities so don't use 'else if' //check this in both possibilities so don't use 'else if'
if (database.isAuthAvailable(name)) { if (database.isAuthAvailable(name)) {
m.send(player, MessageKey.NAME_ALREADY_REGISTERED); service.send(player, MessageKey.NAME_ALREADY_REGISTERED);
return false; return false;
} else if(Settings.getmaxRegPerIp > 0 } else if(Settings.getmaxRegPerIp > 0
&& !ip.equalsIgnoreCase("127.0.0.1") && !ip.equalsIgnoreCase("127.0.0.1")
&& !ip.equalsIgnoreCase("localhost") && !ip.equalsIgnoreCase("localhost")
&& !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)) { && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)) {
Integer maxReg = Settings.getmaxRegPerIp; int maxReg = Settings.getmaxRegPerIp;
List<String> otherAccounts = database.getAllAuthsByIp(ip); List<String> otherAccounts = database.getAllAuthsByIp(ip);
if (otherAccounts.size() >= maxReg) { if (otherAccounts.size() >= maxReg) {
m.send(player, MessageKey.MAX_REGISTER_EXCEEDED, maxReg.toString(), Integer.toString(otherAccounts.size()), otherAccounts.toString()); service.send(player, MessageKey.MAX_REGISTER_EXCEEDED, Integer.toString(maxReg),
Integer.toString(otherAccounts.size()), StringUtils.join(", ", otherAccounts.toString()));
return false; return false;
} }
} }
return true; return true;
} }
public void process() { @Override
public void run() {
if (preRegisterCheck()) { if (preRegisterCheck()) {
if (!StringUtils.isEmpty(email)) { if (!StringUtils.isEmpty(email)) {
emailRegister(); emailRegister();
@ -102,18 +102,19 @@ public class AsyncRegister {
} }
private void emailRegister() { private void emailRegister() {
if(Settings.getmaxRegPerEmail > 0 if (Settings.getmaxRegPerEmail > 0
&& !ip.equalsIgnoreCase("127.0.0.1") && !ip.equalsIgnoreCase("127.0.0.1")
&& !ip.equalsIgnoreCase("localhost") && !ip.equalsIgnoreCase("localhost")
&& !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)) { && !plugin.getPermissionsManager().hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)) {
Integer maxReg = Settings.getmaxRegPerIp; int maxReg = Settings.getmaxRegPerIp;
List<String> otherAccounts = database.getAllAuthsByIp(ip); List<String> otherAccounts = database.getAllAuthsByIp(ip);
if (otherAccounts.size() >= maxReg) { if (otherAccounts.size() >= maxReg) {
m.send(player, MessageKey.MAX_REGISTER_EXCEEDED, maxReg.toString(), Integer.toString(otherAccounts.size()), otherAccounts.toString()); service.send(player, MessageKey.MAX_REGISTER_EXCEEDED, Integer.toString(maxReg),
Integer.toString(otherAccounts.size()), StringUtils.join(", ", otherAccounts.toString()));
return; return;
} }
} }
final HashedPassword hashedPassword = plugin.getPasswordSecurity().computeHash(password, name); final HashedPassword hashedPassword = service.computeHash(password, name);
PlayerAuth auth = PlayerAuth.builder() PlayerAuth auth = PlayerAuth.builder()
.name(name) .name(name)
.realName(player.getName()) .realName(player.getName())
@ -124,19 +125,19 @@ public class AsyncRegister {
.build(); .build();
if (!database.saveAuth(auth)) { if (!database.saveAuth(auth)) {
m.send(player, MessageKey.ERROR); service.send(player, MessageKey.ERROR);
return; return;
} }
database.updateEmail(auth); database.updateEmail(auth);
database.updateSession(auth); database.updateSession(auth);
plugin.mail.main(auth, password); plugin.mail.main(auth, password);
ProcessSyncEmailRegister sync = new ProcessSyncEmailRegister(player, plugin); ProcessSyncEmailRegister sync = new ProcessSyncEmailRegister(player, service);
plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, sync); service.scheduleSyncDelayedTask(sync);
} }
private void passwordRegister() { private void passwordRegister() {
final HashedPassword hashedPassword = plugin.getPasswordSecurity().computeHash(password, name); final HashedPassword hashedPassword = service.computeHash(password, name);
PlayerAuth auth = PlayerAuth.builder() PlayerAuth auth = PlayerAuth.builder()
.name(name) .name(name)
.realName(player.getName()) .realName(player.getName())
@ -146,7 +147,7 @@ public class AsyncRegister {
.build(); .build();
if (!database.saveAuth(auth)) { if (!database.saveAuth(auth)) {
m.send(player, MessageKey.ERROR); service.send(player, MessageKey.ERROR);
return; return;
} }
@ -157,13 +158,13 @@ public class AsyncRegister {
plugin.getManagement().performLogin(player, "dontneed", true); plugin.getManagement().performLogin(player, "dontneed", true);
} }
ProcessSyncPasswordRegister sync = new ProcessSyncPasswordRegister(player, plugin, settings); ProcessSyncPasswordRegister sync = new ProcessSyncPasswordRegister(player, plugin, service);
plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, sync); service.scheduleSyncDelayedTask(sync);
//give the user the secret code to setup their app code generation //give the user the secret code to setup their app code generation
if (Settings.getPasswordHash == HashAlgorithm.TWO_FACTOR) { if (service.getProperty(SecuritySettings.PASSWORD_HASH) == HashAlgorithm.TWO_FACTOR) {
String qrCodeUrl = TwoFactor.getQRBarcodeURL(player.getName(), Bukkit.getIp(), hashedPassword.getHash()); String qrCodeUrl = TwoFactor.getQRBarcodeURL(player.getName(), Bukkit.getIp(), hashedPassword.getHash());
m.send(player, MessageKey.TWO_FACTOR_CREATE, hashedPassword.getHash(), qrCodeUrl); service.send(player, MessageKey.TWO_FACTOR_CREATE, hashedPassword.getHash(), qrCodeUrl);
} }
} }
} }

52
src/main/java/fr/xephi/authme/process/register/ProcessSyncEmailRegister.java
View File

@ -1,70 +1,64 @@
package fr.xephi.authme.process.register; package fr.xephi.authme.process.register;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.ConsoleLogger; import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.cache.limbo.LimboCache; import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.cache.limbo.LimboPlayer; import fr.xephi.authme.cache.limbo.LimboPlayer;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.task.MessageTask; import fr.xephi.authme.task.MessageTask;
import fr.xephi.authme.task.TimeoutTask; import fr.xephi.authme.task.TimeoutTask;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
/** /**
*/ */
public class ProcessSyncEmailRegister implements Runnable { public class ProcessSyncEmailRegister implements Process {
protected final Player player; private final Player player;
protected final String name; private final String name;
private final AuthMe plugin; private final ProcessService service;
private final Messages m;
/** /**
* Constructor for ProcessSyncEmailRegister. * Constructor for ProcessSyncEmailRegister.
* *
* @param player Player * @param player The player to process an email registration for
* @param plugin AuthMe * @param service The process service
*/ */
public ProcessSyncEmailRegister(Player player, AuthMe plugin) { public ProcessSyncEmailRegister(Player player, ProcessService service) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.plugin = plugin; this.service = service;
} }
/**
* Method run.
*
* @see java.lang.Runnable#run()
*/
@Override @Override
public void run() { public void run() {
LimboPlayer limbo = LimboCache.getInstance().getLimboPlayer(name); LimboPlayer limbo = LimboCache.getInstance().getLimboPlayer(name);
if (!Settings.getRegisteredGroup.isEmpty()) { if (!Settings.getRegisteredGroup.isEmpty()) {
Utils.setGroup(player, Utils.GroupType.REGISTERED); Utils.setGroup(player, Utils.GroupType.REGISTERED);
} }
m.send(player, MessageKey.ACCOUNT_NOT_ACTIVATED); service.send(player, MessageKey.ACCOUNT_NOT_ACTIVATED);
int time = Settings.getRegistrationTimeout * 20; int time = service.getProperty(RestrictionSettings.TIMEOUT) * 20;
int msgInterval = Settings.getWarnMessageInterval; int msgInterval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
BukkitScheduler sched = plugin.getServer().getScheduler();
if (limbo != null) { if (limbo != null) {
if (time != 0) { if (time != 0) {
BukkitTask id = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), time); BukkitTask id = service.runTaskLater(new TimeoutTask(service.getAuthMe(), name, player), time);
limbo.setTimeoutTaskId(id); limbo.setTimeoutTask(id);
} }
BukkitTask nwMsg = sched.runTask(plugin, new MessageTask(plugin, name, m.retrieve(MessageKey.LOGIN_MESSAGE), msgInterval)); BukkitTask messageTask = service.runTask(new MessageTask(
limbo.setMessageTaskId(nwMsg); service.getAuthMe(), name, service.retrieveMessage(MessageKey.LOGIN_MESSAGE), msgInterval));
limbo.setMessageTask(messageTask);
} }
player.saveData(); player.saveData();
if (!Settings.noConsoleSpam) { if (!service.getProperty(SecuritySettings.REMOVE_SPAM_FROM_CONSOLE)) {
ConsoleLogger.info(player.getName() + " registered " + plugin.getIP(player)); ConsoleLogger.info(player.getName() + " registered " + service.getIpAddressManager().getPlayerIp(player));
} }
} }

59
src/main/java/fr/xephi/authme/process/register/ProcessSyncPasswordRegister.java
View File

@ -9,42 +9,34 @@ import fr.xephi.authme.cache.limbo.LimboPlayer;
import fr.xephi.authme.events.LoginEvent; import fr.xephi.authme.events.LoginEvent;
import fr.xephi.authme.events.RestoreInventoryEvent; import fr.xephi.authme.events.RestoreInventoryEvent;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.Process;
import fr.xephi.authme.settings.NewSetting; import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.HooksSettings; import fr.xephi.authme.settings.properties.HooksSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.task.MessageTask; import fr.xephi.authme.task.MessageTask;
import fr.xephi.authme.task.TimeoutTask; import fr.xephi.authme.task.TimeoutTask;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
import org.bukkit.Bukkit; import org.bukkit.Bukkit;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffectType; import org.bukkit.potion.PotionEffectType;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
/** /**
*/ */
public class ProcessSyncPasswordRegister implements Runnable { public class ProcessSyncPasswordRegister implements Process {
protected final Player player; protected final Player player;
protected final String name; protected final String name;
private final AuthMe plugin; private final AuthMe plugin;
private final Messages m; private final ProcessService service;
private final NewSetting settings;
/** public ProcessSyncPasswordRegister(Player player, AuthMe plugin, ProcessService service) {
* Constructor for ProcessSyncPasswordRegister.
*
* @param player Player
* @param plugin AuthMe
* @param settings The plugin settings
*/
public ProcessSyncPasswordRegister(Player player, AuthMe plugin, NewSetting settings) {
this.m = plugin.getMessages();
this.player = player; this.player = player;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.plugin = plugin; this.plugin = plugin;
this.settings = settings; this.service = service;
} }
private void sendBungeeMessage() { private void sendBungeeMessage() {
@ -70,16 +62,15 @@ public class ProcessSyncPasswordRegister implements Runnable {
Utils.teleportToSpawn(player); Utils.teleportToSpawn(player);
LimboCache cache = LimboCache.getInstance(); LimboCache cache = LimboCache.getInstance();
cache.updateLimboPlayer(player); cache.updateLimboPlayer(player);
int delay = Settings.getRegistrationTimeout * 20; int delay = service.getProperty(RestrictionSettings.TIMEOUT) * 20;
int interval = Settings.getWarnMessageInterval; int interval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
BukkitScheduler sched = plugin.getServer().getScheduler();
BukkitTask task; BukkitTask task;
if (delay != 0) { if (delay != 0) {
task = sched.runTaskLater(plugin, new TimeoutTask(plugin, name, player), delay); task = service.runTaskLater(new TimeoutTask(service.getAuthMe(), name, player), delay);
cache.getLimboPlayer(name).setTimeoutTaskId(task); cache.getLimboPlayer(name).setTimeoutTask(task);
} }
task = sched.runTask(plugin, new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval)); task = service.runTask(new MessageTask(plugin, name, MessageKey.LOGIN_MESSAGE, interval));
cache.getLimboPlayer(name).setMessageTaskId(task); cache.getLimboPlayer(name).setMessageTask(task);
if (player.isInsideVehicle() && player.getVehicle() != null) { if (player.isInsideVehicle() && player.getVehicle() != null) {
player.getVehicle().eject(); player.getVehicle().eject();
} }
@ -106,13 +97,13 @@ public class ProcessSyncPasswordRegister implements Runnable {
Utils.setGroup(player, Utils.GroupType.REGISTERED); Utils.setGroup(player, Utils.GroupType.REGISTERED);
} }
m.send(player, MessageKey.REGISTER_SUCCESS); service.send(player, MessageKey.REGISTER_SUCCESS);
if (!Settings.getmailAccount.isEmpty()) { if (!Settings.getmailAccount.isEmpty()) {
m.send(player, MessageKey.ADD_EMAIL_MESSAGE); service.send(player, MessageKey.ADD_EMAIL_MESSAGE);
} }
if (Settings.applyBlindEffect) { if (service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
player.removePotionEffect(PotionEffectType.BLINDNESS); player.removePotionEffect(PotionEffectType.BLINDNESS);
} }
@ -121,23 +112,23 @@ public class ProcessSyncPasswordRegister implements Runnable {
player.saveData(); player.saveData();
if (!Settings.noConsoleSpam) { if (!Settings.noConsoleSpam) {
ConsoleLogger.info(player.getName() + " registered " + plugin.getIP(player)); ConsoleLogger.info(player.getName() + " registered " + service.getIpAddressManager().getPlayerIp(player));
} }
// Kick Player after Registration is enabled, kick the player // Kick Player after Registration is enabled, kick the player
if (Settings.forceRegKick) { if (Settings.forceRegKick) {
player.kickPlayer(m.retrieveSingle(MessageKey.REGISTER_SUCCESS)); player.kickPlayer(service.retrieveSingleMessage(MessageKey.REGISTER_SUCCESS));
return; return;
} }
// Register is finish and player is logged, display welcome message // Register is finish and player is logged, display welcome message
if (Settings.useWelcomeMessage) { if (service.getProperty(RegistrationSettings.USE_WELCOME_MESSAGE)) {
if (Settings.broadcastWelcomeMessage) { if (service.getProperty(RegistrationSettings.BROADCAST_WELCOME_MESSAGE)) {
for (String s : settings.getWelcomeMessage()) { for (String s : service.getSettings().getWelcomeMessage()) {
plugin.getServer().broadcastMessage(plugin.replaceAllInfo(s, player)); plugin.getServer().broadcastMessage(plugin.replaceAllInfo(s, player));
} }
} else { } else {
for (String s : settings.getWelcomeMessage()) { for (String s : service.getSettings().getWelcomeMessage()) {
player.sendMessage(plugin.replaceAllInfo(s, player)); player.sendMessage(plugin.replaceAllInfo(s, player));
} }
} }
@ -160,10 +151,10 @@ public class ProcessSyncPasswordRegister implements Runnable {
} }
private void sendTo() { private void sendTo() {
if (!settings.getProperty(HooksSettings.BUNGEECORD_SERVER).isEmpty()) { if (!service.getProperty(HooksSettings.BUNGEECORD_SERVER).isEmpty()) {
ByteArrayDataOutput out = ByteStreams.newDataOutput(); ByteArrayDataOutput out = ByteStreams.newDataOutput();
out.writeUTF("Connect"); out.writeUTF("Connect");
out.writeUTF(settings.getProperty(HooksSettings.BUNGEECORD_SERVER)); out.writeUTF(service.getProperty(HooksSettings.BUNGEECORD_SERVER));
player.sendPluginMessage(plugin, "BungeeCord", out.toByteArray()); player.sendPluginMessage(plugin, "BungeeCord", out.toByteArray());
} }
} }

39
src/main/java/fr/xephi/authme/process/unregister/AsynchronousUnregister.java
View File

@ -8,8 +8,11 @@ import fr.xephi.authme.cache.backup.JsonCache;
import fr.xephi.authme.cache.limbo.LimboCache; import fr.xephi.authme.cache.limbo.LimboCache;
import fr.xephi.authme.cache.limbo.LimboPlayer; import fr.xephi.authme.cache.limbo.LimboPlayer;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.Process;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.task.MessageTask; import fr.xephi.authme.task.MessageTask;
import fr.xephi.authme.task.TimeoutTask; import fr.xephi.authme.task.TimeoutTask;
import fr.xephi.authme.util.Utils; import fr.xephi.authme.util.Utils;
@ -20,15 +23,15 @@ import org.bukkit.potion.PotionEffectType;
import org.bukkit.scheduler.BukkitScheduler; import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitTask; import org.bukkit.scheduler.BukkitTask;
public class AsynchronousUnregister { public class AsynchronousUnregister implements Process {
private final Player player; private final Player player;
private final String name; private final String name;
private final String password; private final String password;
private final boolean force; private final boolean force;
private final AuthMe plugin; private final AuthMe plugin;
private final Messages m;
private final JsonCache playerCache; private final JsonCache playerCache;
private final ProcessService service;
/** /**
* Constructor for AsynchronousUnregister. * Constructor for AsynchronousUnregister.
@ -38,29 +41,27 @@ public class AsynchronousUnregister {
* @param force boolean * @param force boolean
* @param plugin AuthMe * @param plugin AuthMe
*/ */
public AsynchronousUnregister(Player player, String password, boolean force, AuthMe plugin) { public AsynchronousUnregister(Player player, String password, boolean force, AuthMe plugin,
this.m = plugin.getMessages(); ProcessService service) {
this.player = player; this.player = player;
this.name = player.getName().toLowerCase(); this.name = player.getName().toLowerCase();
this.password = password; this.password = password;
this.force = force; this.force = force;
this.plugin = plugin; this.plugin = plugin;
this.playerCache = new JsonCache(); this.playerCache = new JsonCache();
this.service = service;
} }
protected String getIp() { @Override
return plugin.getIP(player); public void run() {
}
public void process() {
PlayerAuth cachedAuth = PlayerCache.getInstance().getAuth(name); PlayerAuth cachedAuth = PlayerCache.getInstance().getAuth(name);
if (force || plugin.getPasswordSecurity().comparePassword( if (force || plugin.getPasswordSecurity().comparePassword(
password, cachedAuth.getPassword(), player.getName())) { password, cachedAuth.getPassword(), player.getName())) {
if (!plugin.getDataSource().removeAuth(name)) { if (!plugin.getDataSource().removeAuth(name)) {
m.send(player, MessageKey.ERROR); service.send(player, MessageKey.ERROR);
return; return;
} }
int timeOut = Settings.getRegistrationTimeout * 20; int timeOut = service.getProperty(RestrictionSettings.TIMEOUT) * 20;
if (Settings.isForcedRegistrationEnabled) { if (Settings.isForcedRegistrationEnabled) {
Utils.teleportToSpawn(player); Utils.teleportToSpawn(player);
player.saveData(); player.saveData();
@ -70,15 +71,15 @@ public class AsynchronousUnregister {
} }
LimboCache.getInstance().addLimboPlayer(player); LimboCache.getInstance().addLimboPlayer(player);
LimboPlayer limboPlayer = LimboCache.getInstance().getLimboPlayer(name); LimboPlayer limboPlayer = LimboCache.getInstance().getLimboPlayer(name);
int interval = Settings.getWarnMessageInterval; int interval = service.getProperty(RegistrationSettings.MESSAGE_INTERVAL);
BukkitScheduler scheduler = plugin.getServer().getScheduler(); BukkitScheduler scheduler = plugin.getServer().getScheduler();
if (timeOut != 0) { if (timeOut != 0) {
BukkitTask id = scheduler.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut); BukkitTask id = scheduler.runTaskLater(plugin, new TimeoutTask(plugin, name, player), timeOut);
limboPlayer.setTimeoutTaskId(id); limboPlayer.setTimeoutTask(id);
} }
limboPlayer.setMessageTaskId(scheduler.runTask(plugin, limboPlayer.setMessageTask(scheduler.runTask(plugin,
new MessageTask(plugin, name, MessageKey.REGISTER_MESSAGE, interval))); new MessageTask(plugin, name, MessageKey.REGISTER_MESSAGE, interval)));
m.send(player, MessageKey.UNREGISTERED_SUCCESS); service.send(player, MessageKey.UNREGISTERED_SUCCESS);
ConsoleLogger.info(player.getDisplayName() + " unregistered himself"); ConsoleLogger.info(player.getDisplayName() + " unregistered himself");
return; return;
} }
@ -92,14 +93,14 @@ public class AsynchronousUnregister {
playerCache.removeCache(player); playerCache.removeCache(player);
} }
// Apply blind effect // Apply blind effect
if (Settings.applyBlindEffect) { if (service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)) {
player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2)); player.addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, timeOut, 2));
} }
m.send(player, MessageKey.UNREGISTERED_SUCCESS); service.send(player, MessageKey.UNREGISTERED_SUCCESS);
ConsoleLogger.info(player.getDisplayName() + " unregistered himself"); ConsoleLogger.info(player.getDisplayName() + " unregistered himself");
Utils.teleportToSpawn(player); Utils.teleportToSpawn(player);
} else { } else {
m.send(player, MessageKey.WRONG_PASSWORD); service.send(player, MessageKey.WRONG_PASSWORD);
} }
} }
} }

41
src/main/java/fr/xephi/authme/settings/Settings.java
View File

@ -1,10 +1,8 @@
package fr.xephi.authme.settings; package fr.xephi.authme.settings;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.datasource.DataSourceType;
import fr.xephi.authme.security.HashAlgorithm; import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.settings.domain.Property; import fr.xephi.authme.settings.domain.Property;
import fr.xephi.authme.settings.properties.DatabaseSettings;
import fr.xephi.authme.settings.properties.HooksSettings; import fr.xephi.authme.settings.properties.HooksSettings;
import fr.xephi.authme.settings.properties.PluginSettings; import fr.xephi.authme.settings.properties.PluginSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings; import fr.xephi.authme.settings.properties.RegistrationSettings;
@ -41,13 +39,9 @@ public final class Settings {
public static List<String> forceRegisterCommands; public static List<String> forceRegisterCommands;
public static List<String> forceRegisterCommandsAsConsole; public static List<String> forceRegisterCommandsAsConsole;
public static List<String> unsafePasswords; public static List<String> unsafePasswords;
public static List<String> emailBlacklist;
public static List<String> emailWhitelist;
public static DataSourceType getDataSource;
public static HashAlgorithm getPasswordHash; public static HashAlgorithm getPasswordHash;
public static Pattern nickPattern; public static Pattern nickPattern;
public static boolean useLogging = false; public static boolean useLogging = false;
public static int purgeDelay = 60;
public static boolean isChatAllowed, isPermissionCheckEnabled, isRegistrationEnabled, public static boolean isChatAllowed, isPermissionCheckEnabled, isRegistrationEnabled,
isForcedRegistrationEnabled, isTeleportToSpawnEnabled, isForcedRegistrationEnabled, isTeleportToSpawnEnabled,
isSessionsEnabled, isAllowRestrictedIp, isSessionsEnabled, isAllowRestrictedIp,
@ -57,19 +51,17 @@ public final class Settings {
isKickOnWrongPasswordEnabled, enablePasswordConfirmation, isKickOnWrongPasswordEnabled, enablePasswordConfirmation,
protectInventoryBeforeLogInEnabled, isStopEnabled, reloadSupport, protectInventoryBeforeLogInEnabled, isStopEnabled, reloadSupport,
rakamakUseIp, noConsoleSpam, removePassword, displayOtherAccounts, rakamakUseIp, noConsoleSpam, removePassword, displayOtherAccounts,
useCaptcha, emailRegistration, multiverse, bungee, emailRegistration, multiverse, bungee,
banUnsafeIp, doubleEmailCheck, sessionExpireOnIpChange, banUnsafeIp, doubleEmailCheck, sessionExpireOnIpChange,
disableSocialSpy, useEssentialsMotd, usePurge, disableSocialSpy, useEssentialsMotd,
purgePlayerDat, purgeEssentialsFile,
purgeLimitedCreative, purgeAntiXray, purgePermissions,
enableProtection, enableAntiBot, recallEmail, useWelcomeMessage, enableProtection, enableAntiBot, recallEmail, useWelcomeMessage,
broadcastWelcomeMessage, forceRegKick, forceRegLogin, broadcastWelcomeMessage, forceRegKick, forceRegLogin,
checkVeryGames, removeJoinMessage, removeLeaveMessage, delayJoinMessage, checkVeryGames, removeJoinMessage, removeLeaveMessage, delayJoinMessage,
noTeleport, applyBlindEffect, hideTablistBeforeLogin, denyTabcompleteBeforeLogin, noTeleport, hideTablistBeforeLogin, denyTabcompleteBeforeLogin,
kickPlayersBeforeStopping, allowAllCommandsIfRegIsOptional, kickPlayersBeforeStopping, allowAllCommandsIfRegIsOptional,
customAttributes, generateImage, isRemoveSpeedEnabled, preventOtherCase; customAttributes, isRemoveSpeedEnabled, preventOtherCase;
public static String getNickRegex, getUnloggedinGroup, public static String getNickRegex, getUnloggedinGroup,
getMySQLColumnGroup, unRegisteredGroup, unRegisteredGroup,
backupWindowsPath, getRegisteredGroup, backupWindowsPath, getRegisteredGroup,
rakamakUsers, rakamakUsersIp, getmailAccount, defaultWorld, rakamakUsers, rakamakUsersIp, getmailAccount, defaultWorld,
spawnPriority, crazyloginFileName, getPassRegex, sendPlayerTo; spawnPriority, crazyloginFileName, getPassRegex, sendPlayerTo;
@ -79,7 +71,7 @@ public final class Settings {
getNonActivatedGroup, passwordMaxLength, getRecoveryPassLength, getNonActivatedGroup, passwordMaxLength, getRecoveryPassLength,
getMailPort, maxLoginTry, captchaLength, saltLength, getMailPort, maxLoginTry, captchaLength, saltLength,
getmaxRegPerEmail, bCryptLog2Rounds, getmaxRegPerEmail, bCryptLog2Rounds,
antiBotSensibility, antiBotDuration, delayRecall, getMaxLoginPerIp, antiBotSensibility, antiBotDuration, getMaxLoginPerIp,
getMaxJoinPerIp; getMaxJoinPerIp;
protected static FileConfiguration configFile; protected static FileConfiguration configFile;
@ -123,8 +115,6 @@ public final class Settings {
getmaxRegPerIp = configFile.getInt("settings.restrictions.maxRegPerIp", 1); getmaxRegPerIp = configFile.getInt("settings.restrictions.maxRegPerIp", 1);
getPasswordHash = load(SecuritySettings.PASSWORD_HASH); getPasswordHash = load(SecuritySettings.PASSWORD_HASH);
getUnloggedinGroup = load(SecuritySettings.UNLOGGEDIN_GROUP); getUnloggedinGroup = load(SecuritySettings.UNLOGGEDIN_GROUP);
getDataSource = load(DatabaseSettings.BACKEND);
getMySQLColumnGroup = configFile.getString("ExternalBoardOptions.mySQLColumnGroup", "");
getNonActivatedGroup = configFile.getInt("ExternalBoardOptions.nonActivedUserGroup", -1); getNonActivatedGroup = configFile.getInt("ExternalBoardOptions.nonActivedUserGroup", -1);
unRegisteredGroup = configFile.getString("GroupOptions.UnregisteredPlayerGroup", ""); unRegisteredGroup = configFile.getString("GroupOptions.UnregisteredPlayerGroup", "");
@ -158,13 +148,12 @@ public final class Settings {
rakamakUsers = configFile.getString("Converter.Rakamak.fileName", "users.rak"); rakamakUsers = configFile.getString("Converter.Rakamak.fileName", "users.rak");
rakamakUsersIp = configFile.getString("Converter.Rakamak.ipFileName", "UsersIp.rak"); rakamakUsersIp = configFile.getString("Converter.Rakamak.ipFileName", "UsersIp.rak");
rakamakUseIp = configFile.getBoolean("Converter.Rakamak.useIp", false); rakamakUseIp = configFile.getBoolean("Converter.Rakamak.useIp", false);
noConsoleSpam = configFile.getBoolean("Security.console.noConsoleSpam", false); noConsoleSpam = load(SecuritySettings.REMOVE_SPAM_FROM_CONSOLE);
removePassword = configFile.getBoolean("Security.console.removePassword", true); removePassword = configFile.getBoolean("Security.console.removePassword", true);
getmailAccount = configFile.getString("Email.mailAccount", ""); getmailAccount = configFile.getString("Email.mailAccount", "");
getMailPort = configFile.getInt("Email.mailPort", 465); getMailPort = configFile.getInt("Email.mailPort", 465);
getRecoveryPassLength = configFile.getInt("Email.RecoveryPasswordLength", 8); getRecoveryPassLength = configFile.getInt("Email.RecoveryPasswordLength", 8);
displayOtherAccounts = configFile.getBoolean("settings.restrictions.displayOtherAccounts", true); displayOtherAccounts = configFile.getBoolean("settings.restrictions.displayOtherAccounts", true);
useCaptcha = configFile.getBoolean("Security.captcha.useCaptcha", false);
maxLoginTry = configFile.getInt("Security.captcha.maxLoginTry", 5); maxLoginTry = configFile.getInt("Security.captcha.maxLoginTry", 5);
captchaLength = configFile.getInt("Security.captcha.captchaLength", 5); captchaLength = configFile.getInt("Security.captcha.captchaLength", 5);
emailRegistration = load(RegistrationSettings.USE_EMAIL_REGISTRATION); emailRegistration = load(RegistrationSettings.USE_EMAIL_REGISTRATION);
@ -180,14 +169,7 @@ public final class Settings {
disableSocialSpy = configFile.getBoolean("Hooks.disableSocialSpy", true); disableSocialSpy = configFile.getBoolean("Hooks.disableSocialSpy", true);
bCryptLog2Rounds = configFile.getInt("ExternalBoardOptions.bCryptLog2Round", 10); bCryptLog2Rounds = configFile.getInt("ExternalBoardOptions.bCryptLog2Round", 10);
useEssentialsMotd = configFile.getBoolean("Hooks.useEssentialsMotd", false); useEssentialsMotd = configFile.getBoolean("Hooks.useEssentialsMotd", false);
usePurge = configFile.getBoolean("Purge.useAutoPurge", false);
purgeDelay = configFile.getInt("Purge.daysBeforeRemovePlayer", 60);
purgePlayerDat = configFile.getBoolean("Purge.removePlayerDat", false);
purgeEssentialsFile = configFile.getBoolean("Purge.removeEssentialsFile", false);
defaultWorld = configFile.getString("Purge.defaultWorld", "world"); defaultWorld = configFile.getString("Purge.defaultWorld", "world");
purgeLimitedCreative = configFile.getBoolean("Purge.removeLimitedCreativesInventories", false);
purgeAntiXray = configFile.getBoolean("Purge.removeAntiXRayFile", false);
purgePermissions = configFile.getBoolean("Purge.removePermissions", false);
enableProtection = configFile.getBoolean("Protection.enableProtection", false); enableProtection = configFile.getBoolean("Protection.enableProtection", false);
countries = configFile.getStringList("Protection.countries"); countries = configFile.getStringList("Protection.countries");
enableAntiBot = configFile.getBoolean("Protection.enableAntiBot", false); enableAntiBot = configFile.getBoolean("Protection.enableAntiBot", false);
@ -196,11 +178,10 @@ public final class Settings {
forceCommands = configFile.getStringList("settings.forceCommands"); forceCommands = configFile.getStringList("settings.forceCommands");
forceCommandsAsConsole = configFile.getStringList("settings.forceCommandsAsConsole"); forceCommandsAsConsole = configFile.getStringList("settings.forceCommandsAsConsole");
recallEmail = configFile.getBoolean("Email.recallPlayers", false); recallEmail = configFile.getBoolean("Email.recallPlayers", false);
delayRecall = configFile.getInt("Email.delayRecall", 5); useWelcomeMessage = load(RegistrationSettings.USE_WELCOME_MESSAGE);
useWelcomeMessage = configFile.getBoolean("settings.useWelcomeMessage", true);
unsafePasswords = configFile.getStringList("settings.security.unsafePasswords"); unsafePasswords = configFile.getStringList("settings.security.unsafePasswords");
countriesBlacklist = configFile.getStringList("Protection.countriesBlacklist"); countriesBlacklist = configFile.getStringList("Protection.countriesBlacklist");
broadcastWelcomeMessage = configFile.getBoolean("settings.broadcastWelcomeMessage", false); broadcastWelcomeMessage = load(RegistrationSettings.BROADCAST_WELCOME_MESSAGE);
forceRegKick = configFile.getBoolean("settings.registration.forceKickAfterRegister", false); forceRegKick = configFile.getBoolean("settings.registration.forceKickAfterRegister", false);
forceRegLogin = load(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER); forceRegLogin = load(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER);
spawnPriority = load(RestrictionSettings.SPAWN_PRIORITY); spawnPriority = load(RestrictionSettings.SPAWN_PRIORITY);
@ -213,13 +194,9 @@ public final class Settings {
noTeleport = load(RestrictionSettings.NO_TELEPORT); noTeleport = load(RestrictionSettings.NO_TELEPORT);
crazyloginFileName = configFile.getString("Converter.CrazyLogin.fileName", "accounts.db"); crazyloginFileName = configFile.getString("Converter.CrazyLogin.fileName", "accounts.db");
getPassRegex = configFile.getString("settings.restrictions.allowedPasswordCharacters", "[\\x21-\\x7E]*"); getPassRegex = configFile.getString("settings.restrictions.allowedPasswordCharacters", "[\\x21-\\x7E]*");
applyBlindEffect = configFile.getBoolean("settings.applyBlindEffect", false);
emailBlacklist = configFile.getStringList("Email.emailBlacklisted");
emailWhitelist = configFile.getStringList("Email.emailWhitelisted");
forceRegisterCommands = configFile.getStringList("settings.forceRegisterCommands"); forceRegisterCommands = configFile.getStringList("settings.forceRegisterCommands");
forceRegisterCommandsAsConsole = configFile.getStringList("settings.forceRegisterCommandsAsConsole"); forceRegisterCommandsAsConsole = configFile.getStringList("settings.forceRegisterCommandsAsConsole");
customAttributes = configFile.getBoolean("Hooks.customAttributes"); customAttributes = configFile.getBoolean("Hooks.customAttributes");
generateImage = configFile.getBoolean("Email.generateImage", false);
preventOtherCase = configFile.getBoolean("settings.preventOtherCase", false); preventOtherCase = configFile.getBoolean("settings.preventOtherCase", false);
kickPlayersBeforeStopping = configFile.getBoolean("Security.stop.kickPlayersBeforeStopping", true); kickPlayersBeforeStopping = configFile.getBoolean("Security.stop.kickPlayersBeforeStopping", true);
sendPlayerTo = configFile.getString("Hooks.sendPlayerTo", ""); sendPlayerTo = configFile.getString("Hooks.sendPlayerTo", "");

19
src/main/java/fr/xephi/authme/settings/properties/PurgeSettings.java
View File

@ -5,43 +5,40 @@ import fr.xephi.authme.settings.domain.Property;
import fr.xephi.authme.settings.domain.SettingsClass; import fr.xephi.authme.settings.domain.SettingsClass;
import static fr.xephi.authme.settings.domain.Property.newProperty; import static fr.xephi.authme.settings.domain.Property.newProperty;
import static fr.xephi.authme.settings.domain.PropertyType.BOOLEAN;
import static fr.xephi.authme.settings.domain.PropertyType.INTEGER;
import static fr.xephi.authme.settings.domain.PropertyType.STRING;
public class PurgeSettings implements SettingsClass { public class PurgeSettings implements SettingsClass {
@Comment("If enabled, AuthMe automatically purges old, unused accounts") @Comment("If enabled, AuthMe automatically purges old, unused accounts")
public static final Property<Boolean> USE_AUTO_PURGE = public static final Property<Boolean> USE_AUTO_PURGE =
newProperty(BOOLEAN, "Purge.useAutoPurge", false); newProperty("Purge.useAutoPurge", false);
@Comment("Number of Days an account become Unused") @Comment("Number of Days an account become Unused")
public static final Property<Integer> DAYS_BEFORE_REMOVE_PLAYER = public static final Property<Integer> DAYS_BEFORE_REMOVE_PLAYER =
newProperty(INTEGER, "Purge.daysBeforeRemovePlayer", 60); newProperty("Purge.daysBeforeRemovePlayer", 60);
@Comment("Do we need to remove the player.dat file during purge process?") @Comment("Do we need to remove the player.dat file during purge process?")
public static final Property<Boolean> REMOVE_PLAYER_DAT = public static final Property<Boolean> REMOVE_PLAYER_DAT =
newProperty(BOOLEAN, "Purge.removePlayerDat", false); newProperty("Purge.removePlayerDat", false);
@Comment("Do we need to remove the Essentials/users/player.yml file during purge process?") @Comment("Do we need to remove the Essentials/users/player.yml file during purge process?")
public static final Property<Boolean> REMOVE_ESSENTIALS_FILES = public static final Property<Boolean> REMOVE_ESSENTIALS_FILES =
newProperty(BOOLEAN, "Purge.removeEssentialsFile", false); newProperty("Purge.removeEssentialsFile", false);
@Comment("World where are players.dat stores") @Comment("World where are players.dat stores")
public static final Property<String> DEFAULT_WORLD = public static final Property<String> DEFAULT_WORLD =
newProperty(STRING, "Purge.defaultWorld", "world"); newProperty("Purge.defaultWorld", "world");
@Comment("Do we need to remove LimitedCreative/inventories/player.yml, player_creative.yml files during purge process ?") @Comment("Do we need to remove LimitedCreative/inventories/player.yml, player_creative.yml files during purge process ?")
public static final Property<Boolean> REMOVE_LIMITED_CREATIVE_INVENTORIES = public static final Property<Boolean> REMOVE_LIMITED_CREATIVE_INVENTORIES =
newProperty(BOOLEAN, "Purge.removeLimitedCreativesInventories", false); newProperty("Purge.removeLimitedCreativesInventories", false);
@Comment("Do we need to remove the AntiXRayData/PlayerData/player file during purge process?") @Comment("Do we need to remove the AntiXRayData/PlayerData/player file during purge process?")
public static final Property<Boolean> REMOVE_ANTI_XRAY_FILE = public static final Property<Boolean> REMOVE_ANTI_XRAY_FILE =
newProperty(BOOLEAN, "Purge.removeAntiXRayFile", false); newProperty("Purge.removeAntiXRayFile", false);
@Comment("Do we need to remove permissions?") @Comment("Do we need to remove permissions?")
public static final Property<Boolean> REMOVE_PERMISSIONS = public static final Property<Boolean> REMOVE_PERMISSIONS =
newProperty(BOOLEAN, "Purge.removePermissions", false); newProperty("Purge.removePermissions", false);
private PurgeSettings() { private PurgeSettings() {
} }

8
src/main/java/fr/xephi/authme/task/MessageTask.java
View File

@ -22,13 +22,13 @@ public class MessageTask implements Runnable {
* *
* @param plugin AuthMe * @param plugin AuthMe
* @param name String * @param name String
* @param strings String[] * @param lines String[]
* @param interval int * @param interval int
*/ */
public MessageTask(AuthMe plugin, String name, String[] strings, int interval) { public MessageTask(AuthMe plugin, String name, String[] lines, int interval) {
this.plugin = plugin; this.plugin = plugin;
this.name = name; this.name = name;
this.msg = strings; this.msg = lines;
this.interval = interval; this.interval = interval;
} }
@ -49,7 +49,7 @@ public class MessageTask implements Runnable {
} }
BukkitTask nextTask = plugin.getServer().getScheduler().runTaskLater(plugin, this, interval * 20); BukkitTask nextTask = plugin.getServer().getScheduler().runTaskLater(plugin, this, interval * 20);
if (LimboCache.getInstance().hasLimboPlayer(name)) { if (LimboCache.getInstance().hasLimboPlayer(name)) {
LimboCache.getInstance().getLimboPlayer(name).setMessageTaskId(nextTask); LimboCache.getInstance().getLimboPlayer(name).setMessageTask(nextTask);
} }
return; return;
} }

3
src/main/java/fr/xephi/authme/util/GeoLiteAPI.java
View File

@ -22,6 +22,9 @@ public class GeoLiteAPI {
private static LookupService lookupService; private static LookupService lookupService;
private static Thread downloadTask; private static Thread downloadTask;
private GeoLiteAPI() {
}
/** /**
* Download (if absent or old) the GeoIpLite data file and then try to load it. * Download (if absent or old) the GeoIpLite data file and then try to load it.
* *

5
src/main/java/fr/xephi/authme/util/Wrapper.java
View File

@ -8,7 +8,6 @@ import org.bukkit.Server;
import org.bukkit.scheduler.BukkitScheduler; import org.bukkit.scheduler.BukkitScheduler;
import java.io.File; import java.io.File;
import java.util.logging.Logger;
/** /**
* Wrapper for the retrieval of common singletons used throughout the application. * Wrapper for the retrieval of common singletons used throughout the application.
@ -48,10 +47,6 @@ public class Wrapper {
return getAuthMe().getServer(); return getAuthMe().getServer();
} }
public Logger getLogger() {
return getAuthMe().getLogger();
}
public Messages getMessages() { public Messages getMessages() {
return getAuthMe().getMessages(); return getAuthMe().getMessages();
} }

63
src/test/java/fr/xephi/authme/cache/CaptchaManagerTest.java vendored Normal file
View File

@ -0,0 +1,63 @@
package fr.xephi.authme.cache;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.SecuritySettings;
import org.junit.Test;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
/**
* Test for {@link CaptchaManager}.
*/
public class CaptchaManagerTest {
@Test
public void shouldAddCounts() {
// given
NewSetting settings = mockSettings(3, 4);
CaptchaManager manager = new CaptchaManager(settings);
String player = "tester";
// when
for (int i = 0; i < 2; ++i) {
manager.increaseCount(player);
}
// then
assertThat(manager.isCaptchaRequired(player), equalTo(false));
manager.increaseCount(player);
assertThat(manager.isCaptchaRequired(player.toUpperCase()), equalTo(true));
assertThat(manager.isCaptchaRequired("otherPlayer"), equalTo(false));
}
@Test
public void shouldCreateAndCheckCaptcha() {
// given
String player = "Miner";
NewSetting settings = mockSettings(1, 4);
CaptchaManager manager = new CaptchaManager(settings);
String captchaCode = manager.getCaptchaCode(player);
// when
boolean badResult = manager.checkCode(player, "wrong_code");
boolean goodResult = manager.checkCode(player, captchaCode);
// then
assertThat(captchaCode.length(), equalTo(4));
assertThat(badResult, equalTo(false));
assertThat(goodResult, equalTo(true));
// Supplying correct code should clear the entry, and any code should be valid if no entry is present
assertThat(manager.checkCode(player, "bogus"), equalTo(true));
}
private static NewSetting mockSettings(int maxTries, int captchaLength) {
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(SecuritySettings.MAX_LOGIN_TRIES_BEFORE_CAPTCHA)).willReturn(maxTries);
given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(captchaLength);
return settings;
}
}

64
src/test/java/fr/xephi/authme/cache/IpAddressManagerTest.java vendored Normal file
View File

@ -0,0 +1,64 @@
package fr.xephi.authme.cache;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.HooksSettings;
import org.bukkit.entity.Player;
import org.junit.Test;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
/**
* Test for {@link IpAddressManager}.
*/
public class IpAddressManagerTest {
@Test
public void shouldRetrieveFromCache() {
// given
IpAddressManager ipAddressManager = new IpAddressManager(mockSettings(true));
ipAddressManager.addCache("Test", "my test IP");
// when
String result = ipAddressManager.getPlayerIp(mockPlayer("test", "123.123.123.123"));
// then
assertThat(result, equalTo("my test IP"));
}
@Test
public void shouldReturnPlainIp() {
// given
IpAddressManager ipAddressManager = new IpAddressManager(mockSettings(false));
// when
String result = ipAddressManager.getPlayerIp(mockPlayer("bobby", "8.8.8.8"));
// then
assertThat(result, equalTo("8.8.8.8"));
}
private static NewSetting mockSettings(boolean useVeryGames) {
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(HooksSettings.ENABLE_VERYGAMES_IP_CHECK)).willReturn(useVeryGames);
return settings;
}
private static Player mockPlayer(String name, String ip) {
Player player = mock(Player.class);
given(player.getName()).willReturn(name);
InetAddress inetAddress = mock(InetAddress.class);
given(inetAddress.getHostAddress()).willReturn(ip);
InetSocketAddress inetSocketAddress = new InetSocketAddress(inetAddress, 8093);
given(player.getAddress()).willReturn(inetSocketAddress);
return player;
}
}

16
src/test/java/fr/xephi/authme/command/CommandServiceTest.java
View File

@ -3,6 +3,7 @@ package fr.xephi.authme.command;
import fr.xephi.authme.AuthMe; import fr.xephi.authme.AuthMe;
import fr.xephi.authme.command.help.HelpProvider; import fr.xephi.authme.command.help.HelpProvider;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.cache.IpAddressManager;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.output.Messages;
import fr.xephi.authme.permission.PermissionsManager; import fr.xephi.authme.permission.PermissionsManager;
@ -40,6 +41,7 @@ public class CommandServiceTest {
private CommandService commandService; private CommandService commandService;
private PermissionsManager permissionsManager; private PermissionsManager permissionsManager;
private NewSetting settings; private NewSetting settings;
private IpAddressManager ipAddressManager;
@Before @Before
public void setUpService() { public void setUpService() {
@ -50,8 +52,9 @@ public class CommandServiceTest {
passwordSecurity = mock(PasswordSecurity.class); passwordSecurity = mock(PasswordSecurity.class);
permissionsManager = mock(PermissionsManager.class); permissionsManager = mock(PermissionsManager.class);
settings = mock(NewSetting.class); settings = mock(NewSetting.class);
commandService = new CommandService( ipAddressManager = mock(IpAddressManager.class);
authMe, commandMapper, helpProvider, messages, passwordSecurity, permissionsManager, settings); commandService = new CommandService(authMe, commandMapper, helpProvider, messages, passwordSecurity,
permissionsManager, settings, ipAddressManager);
} }
@Test @Test
@ -203,4 +206,13 @@ public class CommandServiceTest {
// then // then
assertThat(result, equalTo(authMe)); assertThat(result, equalTo(authMe));
} }
@Test
public void shouldReturnIpAddressManager() {
// given/when
IpAddressManager ipManager = commandService.getIpAddressManager();
// then
assertThat(ipManager, equalTo(ipAddressManager));
}
} }

21
src/test/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommandTest.java
View File

@ -7,8 +7,6 @@ import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.settings.properties.RestrictionSettings; import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings; import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.task.ChangePasswordTask; import fr.xephi.authme.task.ChangePasswordTask;
import fr.xephi.authme.util.WrapperMock;
import org.bukkit.Server;
import org.bukkit.command.BlockCommandSender; import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender; import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
@ -21,6 +19,7 @@ import java.util.Arrays;
import java.util.Collections; import java.util.Collections;
import static org.hamcrest.MatcherAssert.assertThat; import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo; import static org.hamcrest.Matchers.equalTo;
import static org.mockito.BDDMockito.given; import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.any; import static org.mockito.Mockito.any;
@ -35,14 +34,10 @@ import static org.mockito.Mockito.when;
*/ */
public class ChangePasswordCommandTest { public class ChangePasswordCommandTest {
private WrapperMock wrapperMock;
private PlayerCache cacheMock;
private CommandService commandService; private CommandService commandService;
@Before @Before
public void setUpMocks() { public void setUpMocks() {
wrapperMock = WrapperMock.createInstance();
cacheMock = wrapperMock.getPlayerCache();
commandService = mock(CommandService.class); commandService = mock(CommandService.class);
when(commandService.getProperty(SecuritySettings.MIN_PASSWORD_LENGTH)).thenReturn(2); when(commandService.getProperty(SecuritySettings.MIN_PASSWORD_LENGTH)).thenReturn(2);
@ -62,7 +57,9 @@ public class ChangePasswordCommandTest {
command.executeCommand(sender, new ArrayList<String>(), commandService); command.executeCommand(sender, new ArrayList<String>(), commandService);
// then // then
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false)); ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
verify(sender).sendMessage(captor.capture());
assertThat(captor.getValue(), containsString("only for players"));
} }
@Test @Test
@ -76,7 +73,6 @@ public class ChangePasswordCommandTest {
// then // then
verify(commandService).send(sender, MessageKey.NOT_LOGGED_IN); verify(commandService).send(sender, MessageKey.NOT_LOGGED_IN);
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false));
} }
@Test @Test
@ -90,7 +86,6 @@ public class ChangePasswordCommandTest {
// then // then
verify(commandService).send(sender, MessageKey.PASSWORD_MATCH_ERROR); verify(commandService).send(sender, MessageKey.PASSWORD_MATCH_ERROR);
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false));
} }
@ -105,7 +100,6 @@ public class ChangePasswordCommandTest {
// then // then
verify(commandService).send(sender, MessageKey.PASSWORD_IS_USERNAME_ERROR); verify(commandService).send(sender, MessageKey.PASSWORD_IS_USERNAME_ERROR);
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false));
} }
@Test @Test
@ -120,7 +114,6 @@ public class ChangePasswordCommandTest {
// then // then
verify(commandService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH); verify(commandService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH);
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false));
} }
@Test @Test
@ -135,7 +128,6 @@ public class ChangePasswordCommandTest {
// then // then
verify(commandService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH); verify(commandService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH);
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false));
} }
@Test @Test
@ -151,7 +143,6 @@ public class ChangePasswordCommandTest {
// then // then
verify(commandService).send(sender, MessageKey.PASSWORD_UNSAFE_ERROR); verify(commandService).send(sender, MessageKey.PASSWORD_UNSAFE_ERROR);
assertThat(wrapperMock.wasMockCalled(Server.class), equalTo(false));
} }
@Test @Test
@ -175,7 +166,9 @@ public class ChangePasswordCommandTest {
private Player initPlayerWithName(String name, boolean loggedIn) { private Player initPlayerWithName(String name, boolean loggedIn) {
Player player = mock(Player.class); Player player = mock(Player.class);
when(player.getName()).thenReturn(name); when(player.getName()).thenReturn(name);
when(cacheMock.isAuthenticated(name)).thenReturn(loggedIn); PlayerCache playerCache = mock(PlayerCache.class);
when(playerCache.isAuthenticated(name)).thenReturn(loggedIn);
when(commandService.getPlayerCache()).thenReturn(playerCache);
return player; return player;
} }

2
src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java
View File

@ -58,7 +58,7 @@ import static org.mockito.Mockito.verify;
public abstract class AbstractResourceClosingTest { public abstract class AbstractResourceClosingTest {
/** List of DataSource method names not to test. */ /** List of DataSource method names not to test. */
private static final Set<String> IGNORED_METHODS = ImmutableSet.of("reload", "close", "getType"); private static final Set<String> IGNORED_METHODS = ImmutableSet.of("close", "getType");
/** Collection of values to use to call methods with the parameters they expect. */ /** Collection of values to use to call methods with the parameters they expect. */
private static final Map<Class<?>, Object> PARAM_VALUES = getDefaultParameters(); private static final Map<Class<?>, Object> PARAM_VALUES = getDefaultParameters();

57
src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java
View File

@ -1,13 +1,12 @@
package fr.xephi.authme.process.email; package fr.xephi.authme.process.email;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.cache.auth.PlayerAuth; import fr.xephi.authme.cache.auth.PlayerAuth;
import fr.xephi.authme.cache.auth.PlayerCache; import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey; import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.output.Messages; import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.NewSetting; import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings; import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.util.WrapperMock; import fr.xephi.authme.util.WrapperMock;
import org.bukkit.entity.Player; import org.bukkit.entity.Player;
import org.junit.After; import org.junit.After;
@ -27,9 +26,9 @@ import static org.mockito.Mockito.when;
public class AsyncChangeEmailTest { public class AsyncChangeEmailTest {
private Player player; private Player player;
private Messages messages;
private PlayerCache playerCache; private PlayerCache playerCache;
private DataSource dataSource; private DataSource dataSource;
private ProcessService service;
private NewSetting settings; private NewSetting settings;
@BeforeClass @BeforeClass
@ -41,9 +40,10 @@ public class AsyncChangeEmailTest {
@After @After
public void cleanFields() { public void cleanFields() {
player = null; player = null;
messages = null;
playerCache = null; playerCache = null;
dataSource = null; dataSource = null;
service = null;
settings = null;
} }
@Test @Test
@ -57,12 +57,12 @@ public class AsyncChangeEmailTest {
given(dataSource.updateEmail(auth)).willReturn(true); given(dataSource.updateEmail(auth)).willReturn(true);
// when // when
process.process(); process.run();
// then // then
verify(dataSource).updateEmail(auth); verify(dataSource).updateEmail(auth);
verify(playerCache).updatePlayer(auth); verify(playerCache).updatePlayer(auth);
verify(messages).send(player, MessageKey.EMAIL_CHANGED_SUCCESS); verify(service).send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
} }
@Test @Test
@ -76,12 +76,12 @@ public class AsyncChangeEmailTest {
given(dataSource.updateEmail(auth)).willReturn(false); given(dataSource.updateEmail(auth)).willReturn(false);
// when // when
process.process(); process.run();
// then // then
verify(dataSource).updateEmail(auth); verify(dataSource).updateEmail(auth);
verify(playerCache, never()).updatePlayer(auth); verify(playerCache, never()).updatePlayer(auth);
verify(messages).send(player, MessageKey.ERROR); verify(service).send(player, MessageKey.ERROR);
} }
@Test @Test
@ -94,12 +94,12 @@ public class AsyncChangeEmailTest {
given(playerCache.getAuth("bobby")).willReturn(auth); given(playerCache.getAuth("bobby")).willReturn(auth);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.USAGE_ADD_EMAIL); verify(service).send(player, MessageKey.USAGE_ADD_EMAIL);
} }
@Test @Test
@ -112,12 +112,12 @@ public class AsyncChangeEmailTest {
given(playerCache.getAuth("bobby")).willReturn(auth); given(playerCache.getAuth("bobby")).willReturn(auth);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.INVALID_NEW_EMAIL); verify(service).send(player, MessageKey.INVALID_NEW_EMAIL);
} }
@Test @Test
@ -130,12 +130,12 @@ public class AsyncChangeEmailTest {
given(playerCache.getAuth("bobby")).willReturn(auth); given(playerCache.getAuth("bobby")).willReturn(auth);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.INVALID_OLD_EMAIL); verify(service).send(player, MessageKey.INVALID_OLD_EMAIL);
} }
@Test @Test
@ -149,12 +149,12 @@ public class AsyncChangeEmailTest {
given(dataSource.isEmailStored("new@example.com")).willReturn(true); given(dataSource.isEmailStored("new@example.com")).willReturn(true);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR); verify(service).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
} }
@Test @Test
@ -166,12 +166,12 @@ public class AsyncChangeEmailTest {
given(dataSource.isAuthAvailable("Bobby")).willReturn(true); given(dataSource.isAuthAvailable("Bobby")).willReturn(true);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.LOGIN_MESSAGE); verify(service).send(player, MessageKey.LOGIN_MESSAGE);
} }
@Test @Test
@ -181,15 +181,15 @@ public class AsyncChangeEmailTest {
given(player.getName()).willReturn("Bobby"); given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(false); given(playerCache.isAuthenticated("bobby")).willReturn(false);
given(dataSource.isAuthAvailable("Bobby")).willReturn(false); given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
Settings.emailRegistration = true; given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.REGISTER_EMAIL_MESSAGE); verify(service).send(player, MessageKey.REGISTER_EMAIL_MESSAGE);
} }
@Test @Test
@ -199,15 +199,15 @@ public class AsyncChangeEmailTest {
given(player.getName()).willReturn("Bobby"); given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(false); given(playerCache.isAuthenticated("bobby")).willReturn(false);
given(dataSource.isAuthAvailable("Bobby")).willReturn(false); given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
Settings.emailRegistration = false; given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(false);
// when // when
process.process(); process.run();
// then // then
verify(dataSource, never()).updateEmail(any(PlayerAuth.class)); verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
verify(playerCache, never()).updatePlayer(any(PlayerAuth.class)); verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
verify(messages).send(player, MessageKey.REGISTER_MESSAGE); verify(service).send(player, MessageKey.REGISTER_MESSAGE);
} }
private static PlayerAuth authWithMail(String email) { private static PlayerAuth authWithMail(String email) {
@ -218,12 +218,11 @@ public class AsyncChangeEmailTest {
private AsyncChangeEmail createProcess(String oldEmail, String newEmail) { private AsyncChangeEmail createProcess(String oldEmail, String newEmail) {
player = mock(Player.class); player = mock(Player.class);
messages = mock(Messages.class);
AuthMe authMe = mock(AuthMe.class);
when(authMe.getMessages()).thenReturn(messages);
playerCache = mock(PlayerCache.class); playerCache = mock(PlayerCache.class);
dataSource = mock(DataSource.class); dataSource = mock(DataSource.class);
service = mock(ProcessService.class);
settings = mock(NewSetting.class); settings = mock(NewSetting.class);
return new AsyncChangeEmail(player, authMe, oldEmail, newEmail, dataSource, playerCache, settings); given(service.getSettings()).willReturn(settings);
return new AsyncChangeEmail(player, oldEmail, newEmail, dataSource, playerCache, service);
} }
} }

6
src/test/java/fr/xephi/authme/util/WrapperMock.java
View File

@ -10,7 +10,6 @@ import org.mockito.Mockito;
import java.io.File; import java.io.File;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import java.util.logging.Logger;
/** /**
* Class returning mocks for all calls in {@link Wrapper}. * Class returning mocks for all calls in {@link Wrapper}.
@ -36,11 +35,6 @@ public class WrapperMock extends Wrapper {
return instance; return instance;
} }
@Override
public Logger getLogger() {
return getMock(Logger.class);
}
@Override @Override
public Server getServer() { public Server getServer() {
return getMock(Server.class); return getMock(Server.class);