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

Merge branch 'master' of https://github.com/AuthMe/AuthMeReloaded into limbo

Browse Source 
# Conflicts:
#	.checkstyle.xml
This commit is contained in:
ljacqu
2017-03-20 08:23:52 +01:00
parent 42f46b51d3 9a9d0974f8
commit 6eaa91278e
93 changed files with 1016 additions and 580 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/main/java/fr/xephi/authme/AuthMe.java
+10 -3
View File
@@ -15,6 +15,7 @@ import fr.xephi.authme.initialization.OnStartupTasks;
import fr.xephi.authme.initialization.SettingsProvider;
import fr.xephi.authme.initialization.TaskCloser;
import fr.xephi.authme.initialization.factory.FactoryDependencyHandler;
import fr.xephi.authme.initialization.factory.SingletonStoreDependencyHandler;
import fr.xephi.authme.listener.BlockListener;
import fr.xephi.authme.listener.EntityListener;
import fr.xephi.authme.listener.PlayerListener;
@@ -25,7 +26,7 @@ import fr.xephi.authme.listener.PlayerListener19;
import fr.xephi.authme.listener.ServerListener;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PermissionsSystemType;
import fr.xephi.authme.security.crypts.SHA256;
import fr.xephi.authme.security.crypts.Sha256;
import fr.xephi.authme.service.BackupService;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.service.MigrationService;
@@ -36,6 +37,7 @@ import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.task.CleanupTask;
import fr.xephi.authme.task.purge.PurgeService;
import org.apache.commons.lang.SystemUtils;
import org.bukkit.Server;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
@@ -195,12 +197,17 @@ public class AuthMe extends JavaPlugin {
ConsoleLogger.setLogger(getLogger());
ConsoleLogger.setLogFile(new File(getDataFolder(), LOG_FILENAME));
// Check java version
if(!SystemUtils.isJavaVersionAtLeast(1.8f)) {
throw new IllegalStateException("You need Java 1.8 or above to run this plugin!");
}
// Create plugin folder
getDataFolder().mkdir();
// Create injector, provide elements from the Bukkit environment and register providers
injector = new InjectorBuilder()
.addHandlers(new FactoryDependencyHandler())
.addHandlers(new FactoryDependencyHandler(), new SingletonStoreDependencyHandler())
.addDefaultHandlers("fr.xephi.authme")
.create();
injector.register(AuthMe.class, this);
@@ -220,7 +227,7 @@ public class AuthMe extends JavaPlugin {
instantiateServices(injector);
// Convert deprecated PLAINTEXT hash entries
MigrationService.changePlainTextToSha256(settings, database, new SHA256());
MigrationService.changePlainTextToSha256(settings, database, new Sha256());
// TODO: does this still make sense? -sgdc3
// If the server is empty (fresh start) just set all the players as unlogged
src/main/java/fr/xephi/authme/api/NewAPI.java
+5 -7
View File
@@ -5,7 +5,8 @@ import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.data.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.process.register.executors.RegistrationExecutorProvider;
import fr.xephi.authme.process.register.executors.ApiPasswordRegisterParams;
import fr.xephi.authme.process.register.executors.RegistrationMethod;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.service.PluginHookService;
@@ -35,15 +36,13 @@ public class NewAPI {
private final Management management;
private final ValidationService validationService;
private final PlayerCache playerCache;
private final RegistrationExecutorProvider registrationExecutorProvider;
/*
* Constructor for NewAPI.
*/
@Inject
NewAPI(AuthMe plugin, PluginHookService pluginHookService, DataSource dataSource, PasswordSecurity passwordSecurity,
Management management, ValidationService validationService, PlayerCache playerCache,
RegistrationExecutorProvider registrationExecutorProvider) {
Management management, ValidationService validationService, PlayerCache playerCache) {
this.plugin = plugin;
this.pluginHookService = pluginHookService;
this.dataSource = dataSource;
@@ -51,7 +50,6 @@ public class NewAPI {
this.management = management;
this.validationService = validationService;
this.playerCache = playerCache;
this.registrationExecutorProvider = registrationExecutorProvider;
NewAPI.singleton = this;
}
@@ -204,8 +202,8 @@ public class NewAPI {
* @param autoLogin Should the player be authenticated automatically after the registration?
*/
public void forceRegister(Player player, String password, boolean autoLogin) {
management.performRegister(player,
registrationExecutorProvider.getPasswordRegisterExecutor(player, password, autoLogin));
management.performRegister(RegistrationMethod.API_REGISTRATION,
ApiPasswordRegisterParams.of(player, password, autoLogin));
}
/**
src/main/java/fr/xephi/authme/command/executable/authme/ConverterCommand.java
+4 -4
View File
@@ -10,8 +10,8 @@ import fr.xephi.authme.datasource.converter.MySqlToSqlite;
import fr.xephi.authme.datasource.converter.RakamakConverter;
import fr.xephi.authme.datasource.converter.RoyalAuthConverter;
import fr.xephi.authme.datasource.converter.SqliteToSql;
import fr.xephi.authme.datasource.converter.vAuthConverter;
import fr.xephi.authme.datasource.converter.xAuthConverter;
import fr.xephi.authme.datasource.converter.VAuthConverter;
import fr.xephi.authme.datasource.converter.XAuthConverter;
import fr.xephi.authme.initialization.factory.Factory;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.service.BukkitService;
@@ -78,11 +78,11 @@ public class ConverterCommand implements ExecutableCommand {
*/
private static Map<String, Class<? extends Converter>> getConverters() {
return ImmutableMap.<String, Class<? extends Converter>>builder()
.put("xauth", xAuthConverter.class)
.put("xauth", XAuthConverter.class)
.put("crazylogin", CrazyLoginConverter.class)
.put("rakamak", RakamakConverter.class)
.put("royalauth", RoyalAuthConverter.class)
.put("vauth", vAuthConverter.class)
.put("vauth", VAuthConverter.class)
.put("sqlitetosql", SqliteToSql.class)
.put("mysqltosqlite", MySqlToSqlite.class)
.build();
src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java
+10 -9
View File
@@ -7,7 +7,10 @@ import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.process.register.RegisterSecondaryArgument;
import fr.xephi.authme.process.register.RegistrationType;
import fr.xephi.authme.process.register.executors.RegistrationExecutorProvider;
import fr.xephi.authme.process.register.executors.EmailRegisterParams;
import fr.xephi.authme.process.register.executors.PasswordRegisterParams;
import fr.xephi.authme.process.register.executors.RegistrationMethod;
import fr.xephi.authme.process.register.executors.TwoFactorRegisterParams;
import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.service.ValidationService;
@@ -42,15 +45,12 @@ public class RegisterCommand extends PlayerCommand {
@Inject
private ValidationService validationService;
@Inject
private RegistrationExecutorProvider registrationExecutorProvider;
@Override
public void runCommand(Player player, List<String> arguments) {
if (commonService.getProperty(SecuritySettings.PASSWORD_HASH) == HashAlgorithm.TWO_FACTOR) {
//for two factor auth we don't need to check the usage
management.performRegister(player,
registrationExecutorProvider.getTwoFactorRegisterExecutor(player));
management.performRegister(RegistrationMethod.TWO_FACTOR_REGISTRATION,
TwoFactorRegisterParams.of(player));
return;
} else if (arguments.size() < 1) {
commonService.send(player, MessageKey.USAGE_REGISTER);
@@ -82,8 +82,8 @@ public class RegisterCommand extends PlayerCommand {
final String password = arguments.get(0);
final String email = getEmailIfAvailable(arguments);
management.performRegister(
player, registrationExecutorProvider.getPasswordRegisterExecutor(player, password, email));
management.performRegister(RegistrationMethod.PASSWORD_REGISTRATION,
PasswordRegisterParams.of(player, password, email));
}
}
@@ -138,7 +138,8 @@ public class RegisterCommand extends PlayerCommand {
if (!validationService.validateEmail(email)) {
commonService.send(player, MessageKey.INVALID_EMAIL);
} else if (isSecondArgValidForEmailRegistration(player, arguments)) {
management.performRegister(player, registrationExecutorProvider.getEmailRegisterExecutor(player, email));
management.performRegister(RegistrationMethod.EMAIL_REGISTRATION,
EmailRegisterParams.of(player, email));
}
}
src/main/java/fr/xephi/authme/datasource/MySQL.java
+8 -8
View File
@@ -7,7 +7,7 @@ import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.security.crypts.XFBCRYPT;
import fr.xephi.authme.security.crypts.XfBCrypt;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.DatabaseSettings;
import fr.xephi.authme.settings.properties.HooksSettings;
@@ -292,7 +292,7 @@ public class MySQL implements DataSource {
if (rs.next()) {
Blob blob = rs.getBlob("data");
byte[] bytes = blob.getBytes(1, (int) blob.length());
auth.setPassword(new HashedPassword(XFBCRYPT.getHashFromBlob(bytes)));
auth.setPassword(new HashedPassword(XfBCrypt.getHashFromBlob(bytes)));
}
}
}
@@ -520,8 +520,8 @@ public class MySQL implements DataSource {
sql = "INSERT INTO xf_user_authenticate (user_id, scheme_class, data) VALUES (?,?,?)";
pst2 = con.prepareStatement(sql);
pst2.setInt(1, id);
pst2.setString(2, XFBCRYPT.SCHEME_CLASS);
String serializedHash = XFBCRYPT.serializeHash(auth.getPassword().getHash());
pst2.setString(2, XfBCrypt.SCHEME_CLASS);
String serializedHash = XfBCrypt.serializeHash(auth.getPassword().getHash());
byte[] bytes = serializedHash.getBytes();
Blob blob = con.createBlob();
blob.setBytes(1, bytes);
@@ -609,7 +609,7 @@ public class MySQL implements DataSource {
// Insert password in the correct table
sql = "UPDATE xf_user_authenticate SET data=? WHERE " + col.ID + "=?;";
PreparedStatement pst2 = con.prepareStatement(sql);
String serializedHash = XFBCRYPT.serializeHash(password.getHash());
String serializedHash = XfBCrypt.serializeHash(password.getHash());
byte[] bytes = serializedHash.getBytes();
Blob blob = con.createBlob();
blob.setBytes(1, bytes);
@@ -620,7 +620,7 @@ public class MySQL implements DataSource {
// ...
sql = "UPDATE xf_user_authenticate SET scheme_class=? WHERE " + col.ID + "=?;";
pst2 = con.prepareStatement(sql);
pst2.setString(1, XFBCRYPT.SCHEME_CLASS);
pst2.setString(1, XfBCrypt.SCHEME_CLASS);
pst2.setInt(2, id);
pst2.executeUpdate();
pst2.close();
@@ -895,7 +895,7 @@ public class MySQL implements DataSource {
if (rs2.next()) {
Blob blob = rs2.getBlob("data");
byte[] bytes = blob.getBytes(1, (int) blob.length());
pAuth.setPassword(new HashedPassword(XFBCRYPT.getHashFromBlob(bytes)));
pAuth.setPassword(new HashedPassword(XfBCrypt.getHashFromBlob(bytes)));
}
rs2.close();
}
@@ -927,7 +927,7 @@ public class MySQL implements DataSource {
if (rs2.next()) {
Blob blob = rs2.getBlob("data");
byte[] bytes = blob.getBytes(1, (int) blob.length());
pAuth.setPassword(new HashedPassword(XFBCRYPT.getHashFromBlob(bytes)));
pAuth.setPassword(new HashedPassword(XfBCrypt.getHashFromBlob(bytes)));
}
rs2.close();
}
src/main/java/fr/xephi/authme/datasource/converter/vAuthConverter.java → src/main/java/fr/xephi/authme/datasource/converter/VAuthConverter.java
+2 -2
View File
@@ -16,13 +16,13 @@ import java.util.UUID;
import static fr.xephi.authme.util.FileUtils.makePath;
public class vAuthConverter implements Converter {
public class VAuthConverter implements Converter {
private final DataSource dataSource;
private final File vAuthPasswordsFile;
@Inject
vAuthConverter(@DataFolder File dataFolder, DataSource dataSource) {
VAuthConverter(@DataFolder File dataFolder, DataSource dataSource) {
vAuthPasswordsFile = new File(dataFolder.getParent(), makePath("vAuth", "passwords.yml"));
this.dataSource = dataSource;
}
src/main/java/fr/xephi/authme/datasource/converter/xAuthConverter.java → src/main/java/fr/xephi/authme/datasource/converter/XAuthConverter.java
+2 -2
View File
@@ -21,7 +21,7 @@ import java.util.List;
import static fr.xephi.authme.util.FileUtils.makePath;
public class xAuthConverter implements Converter {
public class XAuthConverter implements Converter {
@Inject
@DataFolder
@@ -31,7 +31,7 @@ public class xAuthConverter implements Converter {
@Inject
private PluginManager pluginManager;
xAuthConverter() {
XAuthConverter() {
}
@Override
src/main/java/fr/xephi/authme/initialization/factory/FactoryDependencyHandler.java
+2 -2
View File
@@ -16,8 +16,8 @@ public class FactoryDependencyHandler implements DependencyHandler {
if (dependencyDescription.getType() == Factory.class) {
Class<?> genericType = ReflectionUtils.getGenericType(dependencyDescription.getGenericType());
if (genericType == null) {
throw new IllegalStateException("Factory fields must have concrete generic type. " +
"Cannot get generic type for field in '" + context.getMappedClass() + "'");
throw new IllegalStateException("Factory fields must have concrete generic type. "
+ "Cannot get generic type for field in '" + context.getMappedClass() + "'");
}
return new FactoryImpl<>(genericType, context.getInjector());
src/main/java/fr/xephi/authme/initialization/factory/SingletonStore.java
+37
View File
@@ -0,0 +1,37 @@
package fr.xephi.authme.initialization.factory;
import java.util.Collection;
/**
* Injectable object to retrieve and create singletons of a common parent.
*
* @param <P> the parent class to which this store is limited to
*/
public interface SingletonStore<P> {
/**
* Returns the singleton of the given type, creating it if it hasn't been yet created.
*
* @param clazz the class to get the singleton for
* @param <C> type of the singleton
* @return the singleton of type {@code C}
*/
<C extends P> C getSingleton(Class<C> clazz);
/**
* Returns all existing singletons of this store's type.
*
* @return all registered singletons of type {@code P}
*/
Collection<P> retrieveAllOfType();
/**
* Returns all existing singletons of the given type.
*
* @param clazz the type to get singletons for
* @param <C> class type
* @return all registered singletons of type {@code C}
*/
<C extends P> Collection<C> retrieveAllOfType(Class<C> clazz);
}
src/main/java/fr/xephi/authme/initialization/factory/SingletonStoreDependencyHandler.java
+61
View File
@@ -0,0 +1,61 @@
package fr.xephi.authme.initialization.factory;
import ch.jalu.injector.Injector;
import ch.jalu.injector.context.ResolvedInstantiationContext;
import ch.jalu.injector.handlers.dependency.DependencyHandler;
import ch.jalu.injector.handlers.instantiation.DependencyDescription;
import ch.jalu.injector.utils.ReflectionUtils;
import java.util.Collection;
/**
* Dependency handler that builds {@link SingletonStore} objects.
*/
public class SingletonStoreDependencyHandler implements DependencyHandler {
@Override
public Object resolveValue(ResolvedInstantiationContext<?> context, DependencyDescription dependencyDescription) {
if (dependencyDescription.getType() == SingletonStore.class) {
Class<?> genericType = ReflectionUtils.getGenericType(dependencyDescription.getGenericType());
if (genericType == null) {
throw new IllegalStateException("Singleton store fields must have concrete generic type. "
+ "Cannot get generic type for field in '" + context.getMappedClass() + "'");
}
return new SingletonStoreImpl<>(genericType, context.getInjector());
}
return null;
}
private static final class SingletonStoreImpl<P> implements SingletonStore<P> {
private final Injector injector;
private final Class<P> parentClass;
SingletonStoreImpl(Class<P> parentClass, Injector injector) {
this.parentClass = parentClass;
this.injector = injector;
}
@Override
public <C extends P> C getSingleton(Class<C> clazz) {
if (parentClass.isAssignableFrom(clazz)) {
return injector.getSingleton(clazz);
}
throw new IllegalArgumentException(clazz + " not child of " + parentClass);
}
@Override
public Collection<P> retrieveAllOfType() {
return retrieveAllOfType(parentClass);
}
@Override
public <C extends P> Collection<C> retrieveAllOfType(Class<C> clazz) {
if (parentClass.isAssignableFrom(clazz)) {
return injector.retrieveAllOfType(clazz);
}
throw new IllegalArgumentException(clazz + " not child of " + parentClass);
}
}
}
src/main/java/fr/xephi/authme/process/Management.java
+4 -3
View File
@@ -8,7 +8,8 @@ import fr.xephi.authme.process.login.AsynchronousLogin;
import fr.xephi.authme.process.logout.AsynchronousLogout;
import fr.xephi.authme.process.quit.AsynchronousQuit;
import fr.xephi.authme.process.register.AsyncRegister;
import fr.xephi.authme.process.register.executors.RegistrationExecutor;
import fr.xephi.authme.process.register.executors.RegistrationMethod;
import fr.xephi.authme.process.register.executors.RegistrationParameters;
import fr.xephi.authme.process.unregister.AsynchronousUnregister;
import fr.xephi.authme.service.BukkitService;
import org.bukkit.command.CommandSender;
@@ -60,8 +61,8 @@ public class Management {
runTask(() -> asynchronousLogout.logout(player));
}
public void performRegister(Player player, RegistrationExecutor registrationExecutor) {
runTask(() -> asyncRegister.register(player, registrationExecutor));
public <P extends RegistrationParameters> void performRegister(RegistrationMethod<P> variant, P parameters) {
runTask(() -> asyncRegister.register(variant, parameters));
}
public void performUnregister(Player player, String password) {
src/main/java/fr/xephi/authme/process/register/AsyncRegister.java
+21 -10
View File
@@ -3,10 +3,13 @@ package fr.xephi.authme.process.register;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.data.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.initialization.factory.SingletonStore;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.process.AsynchronousProcess;
import fr.xephi.authme.process.register.executors.RegistrationExecutor;
import fr.xephi.authme.process.register.executors.RegistrationParameters;
import fr.xephi.authme.process.register.executors.RegistrationMethod;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
@@ -31,6 +34,8 @@ public class AsyncRegister implements AsynchronousProcess {
private CommonService service;
@Inject
private PermissionsManager permissionsManager;
@Inject
private SingletonStore<RegistrationExecutor> registrationExecutorFactory;
AsyncRegister() {
}
@@ -38,12 +43,16 @@ public class AsyncRegister implements AsynchronousProcess {
/**
* Performs the registration process for the given player.
*
* @param player the player to register
* @param executor the registration executor to perform the registration with
* @param variant the registration method
* @param parameters the parameters
* @param <P> parameters type
*/
public void register(Player player, RegistrationExecutor executor) {
if (preRegisterCheck(player) && executor.isRegistrationAdmitted()) {
executeRegistration(player, executor);
public <P extends RegistrationParameters> void register(RegistrationMethod<P> variant, P parameters) {
if (preRegisterCheck(parameters.getPlayer())) {
RegistrationExecutor<P> executor = registrationExecutorFactory.getSingleton(variant.getExecutorClass());
if (executor.isRegistrationAdmitted(parameters)) {
executeRegistration(parameters, executor);
}
}
}
@@ -66,15 +75,17 @@ public class AsyncRegister implements AsynchronousProcess {
/**
* Executes the registration.
*
* @param player the player to register
* @param parameters the registration parameters
* @param executor the executor to perform the registration process with
* @param <P> registration params type
*/
private void executeRegistration(Player player, RegistrationExecutor executor) {
PlayerAuth auth = executor.buildPlayerAuth();
private <P extends RegistrationParameters>
void executeRegistration(P parameters, RegistrationExecutor<P> executor) {
PlayerAuth auth = executor.buildPlayerAuth(parameters);
if (database.saveAuth(auth)) {
executor.executePostPersistAction();
executor.executePostPersistAction(parameters);
} else {
service.send(player, MessageKey.ERROR);
service.send(parameters.getPlayer(), MessageKey.ERROR);
}
}
src/main/java/fr/xephi/authme/process/register/executors/AbstractPasswordRegisterExecutor.java
+97
View File
@@ -0,0 +1,97 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.process.SyncProcessManager;
import fr.xephi.authme.process.login.AsynchronousLogin;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.service.ValidationService;
import fr.xephi.authme.settings.properties.PluginSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import org.bukkit.entity.Player;
import javax.inject.Inject;
/**
* Registration executor for registration methods where the password
* is supplied by the user.
*/
abstract class AbstractPasswordRegisterExecutor<P extends AbstractPasswordRegisterParams>
implements RegistrationExecutor<P> {
/**
* Number of ticks to wait before running the login action when it is run synchronously.
* A small delay is necessary or the database won't return the newly saved PlayerAuth object
* and the login process thinks the user is not registered.
*/
private static final int SYNC_LOGIN_DELAY = 5;
@Inject
private ValidationService validationService;
@Inject
private CommonService commonService;
@Inject
private PasswordSecurity passwordSecurity;
@Inject
private BukkitService bukkitService;
@Inject
private SyncProcessManager syncProcessManager;
@Inject
private AsynchronousLogin asynchronousLogin;
@Override
public boolean isRegistrationAdmitted(P params) {
ValidationService.ValidationResult passwordValidation = validationService.validatePassword(
params.getPassword(), params.getPlayer().getName());
if (passwordValidation.hasError()) {
commonService.send(params.getPlayer(), passwordValidation.getMessageKey(), passwordValidation.getArgs());
return false;
}
return true;
}
@Override
public PlayerAuth buildPlayerAuth(P params) {
HashedPassword hashedPassword = passwordSecurity.computeHash(params.getPassword(), params.getPlayerName());
params.setHashedPassword(hashedPassword);
return createPlayerAuthObject(params);
}
/**
* Creates the PlayerAuth object to store into the database, based on the registration parameters.
*
* @param params the parameters
* @return the PlayerAuth representing the new account to register
*/
protected abstract PlayerAuth createPlayerAuthObject(P params);
/**
* Returns whether the player should be automatically logged in after registration.
*
* @param params the registration parameters
* @return true if the player should be logged in, false otherwise
*/
protected boolean performLoginAfterRegister(P params) {
return !commonService.getProperty(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER);
}
@Override
public void executePostPersistAction(P params) {
final Player player = params.getPlayer();
if (performLoginAfterRegister(params)) {
if (commonService.getProperty(PluginSettings.USE_ASYNC_TASKS)) {
bukkitService.runTaskAsynchronously(() -> asynchronousLogin.forceLogin(player));
} else {
bukkitService.scheduleSyncDelayedTask(() -> asynchronousLogin.forceLogin(player), SYNC_LOGIN_DELAY);
}
}
syncProcessManager.processSyncPasswordRegister(player);
}
}
src/main/java/fr/xephi/authme/process/register/executors/AbstractPasswordRegisterParams.java
+48
View File
@@ -0,0 +1,48 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.security.crypts.HashedPassword;
import org.bukkit.entity.Player;
/**
* Common params type for implementors of {@link AbstractPasswordRegisterExecutor}.
* Password must be supplied on creation and cannot be changed later on. The {@link HashedPassword}
* is stored on the params object for later use.
*/
public abstract class AbstractPasswordRegisterParams extends RegistrationParameters {
private final String password;
private HashedPassword hashedPassword;
/**
* Constructor.
*
* @param player the player to register
* @param password the password to use
*/
public AbstractPasswordRegisterParams(Player player, String password) {
super(player);
this.password = password;
}
/**
* Constructor with no defined password. Use for registration methods which
* have no implicit password (like two factor authentication).
*
* @param player the player to register
*/
public AbstractPasswordRegisterParams(Player player) {
this(player, null);
}
public String getPassword() {
return password;
}
void setHashedPassword(HashedPassword hashedPassword) {
this.hashedPassword = hashedPassword;
}
HashedPassword getHashedPassword() {
return hashedPassword;
}
}
src/main/java/fr/xephi/authme/process/register/executors/ApiPasswordRegisterExecutor.java
+20
View File
@@ -0,0 +1,20 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
/**
* Executor for password registration via API call.
*/
class ApiPasswordRegisterExecutor extends AbstractPasswordRegisterExecutor<ApiPasswordRegisterParams> {
@Override
protected PlayerAuth createPlayerAuthObject(ApiPasswordRegisterParams params) {
return PlayerAuthBuilderHelper
.createPlayerAuth(params.getPlayer(), params.getHashedPassword(), null);
}
@Override
protected boolean performLoginAfterRegister(ApiPasswordRegisterParams params) {
return params.getLoginAfterRegister();
}
}
src/main/java/fr/xephi/authme/process/register/executors/ApiPasswordRegisterParams.java
+35
View File
@@ -0,0 +1,35 @@
package fr.xephi.authme.process.register.executors;
import org.bukkit.entity.Player;
/**
* Parameters for {@link ApiPasswordRegisterExecutor}.
*/
public class ApiPasswordRegisterParams extends PasswordRegisterParams {
private final boolean loginAfterRegister;
protected ApiPasswordRegisterParams(Player player, String password, boolean loginAfterRegister) {
super(player, password, null);
this.loginAfterRegister = loginAfterRegister;
}
/**
* Creates a parameters object.
*
* @param player the player to register
* @param password the password to register with
* @param loginAfterRegister whether the player should be logged in after registration
* @return params object with the given data
*/
public static ApiPasswordRegisterParams of(Player player, String password, boolean loginAfterRegister) {
return new ApiPasswordRegisterParams(player, password, loginAfterRegister);
}
/**
* @return true if the player should be logged in after being registered, false otherwise
*/
public boolean getLoginAfterRegister() {
return loginAfterRegister;
}
}
src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutor.java
+80
View File
@@ -0,0 +1,80 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.mail.EmailService;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.process.SyncProcessManager;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.util.RandomStringUtils;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import static fr.xephi.authme.permission.PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS;
import static fr.xephi.authme.process.register.executors.PlayerAuthBuilderHelper.createPlayerAuth;
import static fr.xephi.authme.settings.properties.EmailSettings.RECOVERY_PASSWORD_LENGTH;
/**
* Executor for email registration: the player only provides his email address,
* to which a generated password is sent.
*/
class EmailRegisterExecutor implements RegistrationExecutor<EmailRegisterParams> {
@Inject
private PermissionsManager permissionsManager;
@Inject
private DataSource dataSource;
@Inject
private CommonService commonService;
@Inject
private EmailService emailService;
@Inject
private SyncProcessManager syncProcessManager;
@Inject
private PasswordSecurity passwordSecurity;
@Override
public boolean isRegistrationAdmitted(EmailRegisterParams params) {
final int maxRegPerEmail = commonService.getProperty(EmailSettings.MAX_REG_PER_EMAIL);
if (maxRegPerEmail > 0 && !permissionsManager.hasPermission(params.getPlayer(), ALLOW_MULTIPLE_ACCOUNTS)) {
int otherAccounts = dataSource.countAuthsByEmail(params.getEmail());
if (otherAccounts >= maxRegPerEmail) {
commonService.send(params.getPlayer(), MessageKey.MAX_REGISTER_EXCEEDED,
Integer.toString(maxRegPerEmail), Integer.toString(otherAccounts), "@");
return false;
}
}
return true;
}
@Override
public PlayerAuth buildPlayerAuth(EmailRegisterParams params) {
String password = RandomStringUtils.generate(commonService.getProperty(RECOVERY_PASSWORD_LENGTH));
HashedPassword hashedPassword = passwordSecurity.computeHash(password, params.getPlayer().getName());
params.setPassword(password);
return createPlayerAuth(params.getPlayer(), hashedPassword, params.getEmail());
}
@Override
public void executePostPersistAction(EmailRegisterParams params) {
Player player = params.getPlayer();
boolean couldSendMail = emailService.sendPasswordMail(
player.getName(), params.getEmail(), params.getPassword());
if (couldSendMail) {
syncProcessManager.processSyncEmailRegister(player);
} else {
commonService.send(player, MessageKey.EMAIL_SEND_FAILURE);
}
}
}
src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorProvider.java
-91
View File
@@ -1,91 +0,0 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.mail.EmailService;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.process.SyncProcessManager;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.util.RandomStringUtils;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import static fr.xephi.authme.permission.PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS;
import static fr.xephi.authme.process.register.executors.PlayerAuthBuilderHelper.createPlayerAuth;
import static fr.xephi.authme.settings.properties.EmailSettings.RECOVERY_PASSWORD_LENGTH;
/**
* Provides a registration executor for email registration.
*/
class EmailRegisterExecutorProvider {
@Inject
private PermissionsManager permissionsManager;
@Inject
private DataSource dataSource;
@Inject
private CommonService commonService;
@Inject
private EmailService emailService;
@Inject
private SyncProcessManager syncProcessManager;
@Inject
private PasswordSecurity passwordSecurity;
EmailRegisterExecutorProvider() {
}
/** Registration executor implementation for email registration. */
class EmailRegisterExecutor implements RegistrationExecutor {
private final Player player;
private final String email;
private String password;
EmailRegisterExecutor(Player player, String email) {
this.player = player;
this.email = email;
}
@Override
public boolean isRegistrationAdmitted() {
final int maxRegPerEmail = commonService.getProperty(EmailSettings.MAX_REG_PER_EMAIL);
if (maxRegPerEmail > 0 && !permissionsManager.hasPermission(player, ALLOW_MULTIPLE_ACCOUNTS)) {
int otherAccounts = dataSource.countAuthsByEmail(email);
if (otherAccounts >= maxRegPerEmail) {
commonService.send(player, MessageKey.MAX_REGISTER_EXCEEDED, Integer.toString(maxRegPerEmail),
Integer.toString(otherAccounts), "@");
return false;
}
}
return true;
}
@Override
public PlayerAuth buildPlayerAuth() {
password = RandomStringUtils.generate(commonService.getProperty(RECOVERY_PASSWORD_LENGTH));
HashedPassword hashedPassword = passwordSecurity.computeHash(password, player.getName());
return createPlayerAuth(player, hashedPassword, email);
}
@Override
public void executePostPersistAction() {
boolean couldSendMail = emailService.sendPasswordMail(player.getName(), email, password);
if (couldSendMail) {
syncProcessManager.processSyncEmailRegister(player);
} else {
commonService.send(player, MessageKey.EMAIL_SEND_FAILURE);
}
}
}
}
src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterParams.java
+43
View File
@@ -0,0 +1,43 @@
package fr.xephi.authme.process.register.executors;
import org.bukkit.entity.Player;
/**
* Parameters for email registration.
*/
public class EmailRegisterParams extends RegistrationParameters {
private final String email;
private String password;
protected EmailRegisterParams(Player player, String email) {
super(player);
this.email = email;
}
/**
* Creates a params object for email registration.
*
* @param player the player to register
* @param email the player's email
* @return params object with the given data
*/
public static EmailRegisterParams of(Player player, String email) {
return new EmailRegisterParams(player, email);
}
public String getEmail() {
return email;
}
void setPassword(String password) {
this.password = password;
}
/**
* @return the password generated for the player
*/
String getPassword() {
return password;
}
}
src/main/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutor.java
+17
View File
@@ -0,0 +1,17 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
import static fr.xephi.authme.process.register.executors.PlayerAuthBuilderHelper.createPlayerAuth;
/**
* Registration executor for password registration.
*/
class PasswordRegisterExecutor extends AbstractPasswordRegisterExecutor<PasswordRegisterParams> {
@Override
public PlayerAuth createPlayerAuthObject(PasswordRegisterParams params) {
return createPlayerAuth(params.getPlayer(), params.getHashedPassword(), params.getEmail());
}
}
src/main/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorProvider.java
-164
View File
@@ -1,164 +0,0 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.process.SyncProcessManager;
import fr.xephi.authme.process.login.AsynchronousLogin;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.security.crypts.TwoFactor;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.service.ValidationService;
import fr.xephi.authme.service.ValidationService.ValidationResult;
import fr.xephi.authme.settings.properties.PluginSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import javax.inject.Inject;
import static fr.xephi.authme.process.register.executors.PlayerAuthBuilderHelper.createPlayerAuth;
/**
* Provides registration executors for password-based registration variants.
*/
class PasswordRegisterExecutorProvider {
/**
* Number of ticks to wait before running the login action when it is run synchronously.
* A small delay is necessary or the database won't return the newly saved PlayerAuth object
* and the login process thinks the user is not registered.
*/
private static final int SYNC_LOGIN_DELAY = 5;
@Inject
private ValidationService validationService;
@Inject
private CommonService commonService;
@Inject
private PasswordSecurity passwordSecurity;
@Inject
private BukkitService bukkitService;
@Inject
private SyncProcessManager syncProcessManager;
@Inject
private AsynchronousLogin asynchronousLogin;
PasswordRegisterExecutorProvider() {
}
/** Registration executor for password registration. */
class PasswordRegisterExecutor implements RegistrationExecutor {
private final Player player;
private final String password;
private final String email;
private HashedPassword hashedPassword;
/**
* Constructor.
*
* @param player the player to register
* @param password the password to register with
* @param email the email of the player (may be null)
*/
PasswordRegisterExecutor(Player player, String password, String email) {
this.player = player;
this.password = password;
this.email = email;
}
@Override
public boolean isRegistrationAdmitted() {
ValidationResult passwordValidation = validationService.validatePassword(password, player.getName());
if (passwordValidation.hasError()) {
commonService.send(player, passwordValidation.getMessageKey(), passwordValidation.getArgs());
return false;
}
return true;
}
@Override
public PlayerAuth buildPlayerAuth() {
hashedPassword = passwordSecurity.computeHash(password, player.getName().toLowerCase());
return createPlayerAuth(player, hashedPassword, email);
}
protected boolean performLoginAfterRegister() {
return !commonService.getProperty(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER);
}
@Override
public void executePostPersistAction() {
if (performLoginAfterRegister()) {
if (commonService.getProperty(PluginSettings.USE_ASYNC_TASKS)) {
bukkitService.runTaskAsynchronously(() -> asynchronousLogin.forceLogin(player));
} else {
bukkitService.scheduleSyncDelayedTask(() -> asynchronousLogin.forceLogin(player), SYNC_LOGIN_DELAY);
}
}
syncProcessManager.processSyncPasswordRegister(player);
}
protected Player getPlayer() {
return player;
}
protected HashedPassword getHashedPassword() {
return hashedPassword;
}
}
/** Executor for password registration via API call. */
class ApiPasswordRegisterExecutor extends PasswordRegisterExecutor {
private final boolean loginAfterRegister;
/**
* Constructor.
*
* @param player the player to register
* @param password the password to register with
* @param loginAfterRegister whether the user should be automatically logged in after registration
*/
ApiPasswordRegisterExecutor(Player player, String password, boolean loginAfterRegister) {
super(player, password, null);
this.loginAfterRegister = loginAfterRegister;
}
@Override
protected boolean performLoginAfterRegister() {
return loginAfterRegister;
}
}
/** Executor for two factor registration. */
class TwoFactorRegisterExecutor extends PasswordRegisterExecutor {
TwoFactorRegisterExecutor(Player player) {
super(player, "", null);
}
@Override
public boolean isRegistrationAdmitted() {
// nothing to check
return true;
}
@Override
public void executePostPersistAction() {
super.executePostPersistAction();
String hash = getHashedPassword().getHash();
String qrCodeUrl = TwoFactor.getQRBarcodeURL(getPlayer().getName(), Bukkit.getIp(), hash);
commonService.send(getPlayer(), MessageKey.TWO_FACTOR_CREATE, hash, qrCodeUrl);
}
}
}
src/main/java/fr/xephi/authme/process/register/executors/PasswordRegisterParams.java
+32
View File
@@ -0,0 +1,32 @@
package fr.xephi.authme.process.register.executors;
import org.bukkit.entity.Player;
/**
* Parameters for registration with a given password, and optionally an email address.
*/
public class PasswordRegisterParams extends AbstractPasswordRegisterParams {
private final String email;
protected PasswordRegisterParams(Player player, String password, String email) {
super(player, password);
this.email = email;
}
/**
* Creates a params object.
*
* @param player the player to register
* @param password the password to register with
* @param email the email of the player (may be null)
* @return params object with the given data
*/
public static PasswordRegisterParams of(Player player, String password, String email) {
return new PasswordRegisterParams(player, password, email);
}
public String getEmail() {
return email;
}
}
src/main/java/fr/xephi/authme/process/register/executors/PlayerAuthBuilderHelper.java
+8
View File
@@ -13,6 +13,14 @@ final class PlayerAuthBuilderHelper {
private PlayerAuthBuilderHelper() {
}
/**
* Creates a {@link PlayerAuth} object with the given data.
*
* @param player the player to create a PlayerAuth for
* @param hashedPassword the hashed password
* @param email the email address (nullable)
* @return the generated PlayerAuth object
*/
static PlayerAuth createPlayerAuth(Player player, HashedPassword hashedPassword, String email) {
return PlayerAuth.builder()
.name(player.getName().toLowerCase())
src/main/java/fr/xephi/authme/process/register/executors/RegistrationExecutor.java
+8 -4
View File
@@ -5,7 +5,7 @@ import fr.xephi.authme.data.auth.PlayerAuth;
/**
* Performs the registration action.
*/
public interface RegistrationExecutor {
public interface RegistrationExecutor<P extends RegistrationParameters> {
/**
* Returns whether the registration may take place. Use this method to execute
@@ -14,20 +14,24 @@ public interface RegistrationExecutor {
* If this method returns {@code false}, it is expected that the executor inform
* the player about the error within this method call.
*
* @param params the parameters for the registration
* @return true if registration may be performed, false otherwise
*/
boolean isRegistrationAdmitted();
boolean isRegistrationAdmitted(P params);
/**
* Constructs the PlayerAuth object to persist into the database.
*
* @param params the parameters for the registration
* @return the player auth to register in the data source
*/
PlayerAuth buildPlayerAuth();
PlayerAuth buildPlayerAuth(P params);
/**
* Follow-up method called after the player auth could be added into the database.
*
* @param params the parameters for the registration
*/
void executePostPersistAction();
void executePostPersistAction(P params);
}
src/main/java/fr/xephi/authme/process/register/executors/RegistrationExecutorProvider.java
-36
View File
@@ -1,36 +0,0 @@
package fr.xephi.authme.process.register.executors;
import org.bukkit.entity.Player;
import javax.inject.Inject;
/**
* Provides a {@link RegistrationExecutor} for various registration methods.
*/
public class RegistrationExecutorProvider {
@Inject
private PasswordRegisterExecutorProvider passwordRegisterExecutorProvider;
@Inject
private EmailRegisterExecutorProvider emailRegisterExecutorProvider;
RegistrationExecutorProvider() {
}
public RegistrationExecutor getPasswordRegisterExecutor(Player player, String password, String email) {
return passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, password, email);
}
public RegistrationExecutor getPasswordRegisterExecutor(Player player, String password, boolean loginAfterRegister) {
return passwordRegisterExecutorProvider.new ApiPasswordRegisterExecutor(player, password, loginAfterRegister);
}
public RegistrationExecutor getTwoFactorRegisterExecutor(Player player) {
return passwordRegisterExecutorProvider.new TwoFactorRegisterExecutor(player);
}
public RegistrationExecutor getEmailRegisterExecutor(Player player, String email) {
return emailRegisterExecutorProvider.new EmailRegisterExecutor(player, email);
}
}
src/main/java/fr/xephi/authme/process/register/executors/RegistrationMethod.java
+51
View File
@@ -0,0 +1,51 @@
package fr.xephi.authme.process.register.executors;
/**
* Methods with which a player can be registered.
* <p>
* These constants each define a different way of registering a player and define the
* {@link RegistrationParameters parameters} and {@link RegistrationExecutor executor}
* classes which perform this registration method. This is essentially a <i>typed enum</i>
* as passing a constant of this class along with a parameters object to a method can
* be restricted to the correct parameters type.
*/
public final class RegistrationMethod<P extends RegistrationParameters> {
/**
* Password registration.
*/
public static final RegistrationMethod<PasswordRegisterParams> PASSWORD_REGISTRATION =
new RegistrationMethod<>(PasswordRegisterExecutor.class);
/**
* Registration with two-factor authentication as login means.
*/
public static final RegistrationMethod<TwoFactorRegisterParams> TWO_FACTOR_REGISTRATION =
new RegistrationMethod<>(TwoFactorRegisterExecutor.class);
/**
* Email registration: an email address is provided, to which a generated password is sent.
*/
public static final RegistrationMethod<EmailRegisterParams> EMAIL_REGISTRATION =
new RegistrationMethod<>(EmailRegisterExecutor.class);
/**
* API registration: player and password are provided via an API method.
*/
public static final RegistrationMethod<ApiPasswordRegisterParams> API_REGISTRATION =
new RegistrationMethod<>(ApiPasswordRegisterExecutor.class);
private final Class<? extends RegistrationExecutor<P>> executorClass;
private RegistrationMethod(Class<? extends RegistrationExecutor<P>> executorClass) {
this.executorClass = executorClass;
}
/**
* @return the executor class to perform the registration method
*/
public Class<? extends RegistrationExecutor<P>> getExecutorClass() {
return executorClass;
}
}
src/main/java/fr/xephi/authme/process/register/executors/RegistrationParameters.java
+28
View File
@@ -0,0 +1,28 @@
package fr.xephi.authme.process.register.executors;
import org.bukkit.entity.Player;
/**
* Parent of all registration parameters.
*/
public abstract class RegistrationParameters {
private final Player player;
/**
* Constructor.
*
* @param player the player to perform the registration for
*/
public RegistrationParameters(Player player) {
this.player = player;
}
public Player getPlayer() {
return player;
}
public String getPlayerName() {
return player.getName();
}
}
src/main/java/fr/xephi/authme/process/register/executors/TwoFactorRegisterExecutor.java
+43
View File
@@ -0,0 +1,43 @@
package fr.xephi.authme.process.register.executors;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.security.crypts.TwoFactor;
import fr.xephi.authme.service.CommonService;
import org.bukkit.Bukkit;
import javax.inject.Inject;
import static fr.xephi.authme.process.register.executors.PlayerAuthBuilderHelper.createPlayerAuth;
/**
* Executor for two-factor registration.
*/
class TwoFactorRegisterExecutor extends AbstractPasswordRegisterExecutor<TwoFactorRegisterParams> {
@Inject
private CommonService commonService;
@Override
public boolean isRegistrationAdmitted(TwoFactorRegisterParams params) {
// nothing to check
return true;
}
@Override
protected PlayerAuth createPlayerAuthObject(TwoFactorRegisterParams params) {
return createPlayerAuth(params.getPlayer(), params.getHashedPassword(), null);
}
@Override
public void executePostPersistAction(TwoFactorRegisterParams params) {
super.executePostPersistAction(params);
// Note ljacqu 20170317: This two-factor registration type is only invoked when the password hash is configured
// to two-factor authentication. Therefore, the hashed password is the result of the TwoFactor EncryptionMethod
// implementation (contains the TOTP secret).
String hash = params.getHashedPassword().getHash();
String qrCodeUrl = TwoFactor.getQRBarcodeURL(params.getPlayerName(), Bukkit.getIp(), hash);
commonService.send(params.getPlayer(), MessageKey.TWO_FACTOR_CREATE, hash, qrCodeUrl);
}
}
src/main/java/fr/xephi/authme/process/register/executors/TwoFactorRegisterParams.java
+23
View File
@@ -0,0 +1,23 @@
package fr.xephi.authme.process.register.executors;
import org.bukkit.entity.Player;
/**
* Parameters for registration with two-factor authentication.
*/
public class TwoFactorRegisterParams extends AbstractPasswordRegisterParams {
protected TwoFactorRegisterParams(Player player) {
super(player);
}
/**
* Creates a parameters object.
*
* @param player the player to register
* @return params object with the given player
*/
public static TwoFactorRegisterParams of(Player player) {
return new TwoFactorRegisterParams(player);
}
}
src/main/java/fr/xephi/authme/security/HashAlgorithm.java
+26 -26
View File
@@ -7,36 +7,36 @@ import fr.xephi.authme.security.crypts.EncryptionMethod;
*/
public enum HashAlgorithm {
BCRYPT(fr.xephi.authme.security.crypts.BCRYPT.class),
BCRYPT2Y(fr.xephi.authme.security.crypts.BCRYPT2Y.class),
CRAZYCRYPT1(fr.xephi.authme.security.crypts.CRAZYCRYPT1.class),
DOUBLEMD5(fr.xephi.authme.security.crypts.DOUBLEMD5.class),
IPB3(fr.xephi.authme.security.crypts.IPB3.class),
IPB4(fr.xephi.authme.security.crypts.IPB4.class),
JOOMLA(fr.xephi.authme.security.crypts.JOOMLA.class),
MD5(fr.xephi.authme.security.crypts.MD5.class),
MD5VB(fr.xephi.authme.security.crypts.MD5VB.class),
MYBB(fr.xephi.authme.security.crypts.MYBB.class),
BCRYPT(fr.xephi.authme.security.crypts.BCrypt.class),
BCRYPT2Y(fr.xephi.authme.security.crypts.BCrypt2y.class),
CRAZYCRYPT1(fr.xephi.authme.security.crypts.CrazyCrypt1.class),
DOUBLEMD5(fr.xephi.authme.security.crypts.DoubleMd5.class),
IPB3(fr.xephi.authme.security.crypts.Ipb3.class),
IPB4(fr.xephi.authme.security.crypts.Ipb4.class),
JOOMLA(fr.xephi.authme.security.crypts.Joomla.class),
MD5(fr.xephi.authme.security.crypts.Md5.class),
MD5VB(fr.xephi.authme.security.crypts.Md5vB.class),
MYBB(fr.xephi.authme.security.crypts.MyBB.class),
PBKDF2(fr.xephi.authme.security.crypts.Pbkdf2.class),
PBKDF2DJANGO(fr.xephi.authme.security.crypts.Pbkdf2Django.class),
PHPBB(fr.xephi.authme.security.crypts.PHPBB.class),
PHPFUSION(fr.xephi.authme.security.crypts.PHPFUSION.class),
PHPBB(fr.xephi.authme.security.crypts.PhpBB.class),
PHPFUSION(fr.xephi.authme.security.crypts.PhpFusion.class),
@Deprecated
PLAINTEXT(fr.xephi.authme.security.crypts.PLAINTEXT.class),
ROYALAUTH(fr.xephi.authme.security.crypts.ROYALAUTH.class),
SALTED2MD5(fr.xephi.authme.security.crypts.SALTED2MD5.class),
SALTEDSHA512(fr.xephi.authme.security.crypts.SALTEDSHA512.class),
SHA1(fr.xephi.authme.security.crypts.SHA1.class),
SHA256(fr.xephi.authme.security.crypts.SHA256.class),
SHA512(fr.xephi.authme.security.crypts.SHA512.class),
SMF(fr.xephi.authme.security.crypts.SMF.class),
PLAINTEXT(fr.xephi.authme.security.crypts.PlainText.class),
ROYALAUTH(fr.xephi.authme.security.crypts.RoyalAuth.class),
SALTED2MD5(fr.xephi.authme.security.crypts.Salted2Md5.class),
SALTEDSHA512(fr.xephi.authme.security.crypts.SaltedSha512.class),
SHA1(fr.xephi.authme.security.crypts.Sha1.class),
SHA256(fr.xephi.authme.security.crypts.Sha256.class),
SHA512(fr.xephi.authme.security.crypts.Sha512.class),
SMF(fr.xephi.authme.security.crypts.Smf.class),
TWO_FACTOR(fr.xephi.authme.security.crypts.TwoFactor.class),
WBB3(fr.xephi.authme.security.crypts.WBB3.class),
WBB4(fr.xephi.authme.security.crypts.WBB4.class),
WHIRLPOOL(fr.xephi.authme.security.crypts.WHIRLPOOL.class),
WORDPRESS(fr.xephi.authme.security.crypts.WORDPRESS.class),
XAUTH(fr.xephi.authme.security.crypts.XAUTH.class),
XFBCRYPT(fr.xephi.authme.security.crypts.XFBCRYPT.class),
WBB3(fr.xephi.authme.security.crypts.Wbb3.class),
WBB4(fr.xephi.authme.security.crypts.Wbb4.class),
WHIRLPOOL(fr.xephi.authme.security.crypts.Whirlpool.class),
WORDPRESS(fr.xephi.authme.security.crypts.Wordpress.class),
XAUTH(fr.xephi.authme.security.crypts.XAuth.class),
XFBCRYPT(fr.xephi.authme.security.crypts.XfBCrypt.class),
CUSTOM(null);
private final Class<? extends EncryptionMethod> clazz;
src/main/java/fr/xephi/authme/security/crypts/BCRYPT.java → src/main/java/fr/xephi/authme/security/crypts/BCrypt.java
+2 -2
View File
@@ -14,12 +14,12 @@ import javax.inject.Inject;
@Recommendation(Usage.RECOMMENDED) // provided the salt length is >= 8
@HasSalt(value = SaltType.TEXT) // length depends on the bcryptLog2Rounds setting
public class BCRYPT implements EncryptionMethod {
public class BCrypt implements EncryptionMethod {
private final int bCryptLog2Rounds;
@Inject
public BCRYPT(Settings settings) {
public BCrypt(Settings settings) {
bCryptLog2Rounds = settings.getProperty(HooksSettings.BCRYPT_LOG2_ROUND);
}
src/main/java/fr/xephi/authme/security/crypts/BCRYPT2Y.java → src/main/java/fr/xephi/authme/security/crypts/BCrypt2y.java
+1 -1
View File
@@ -4,7 +4,7 @@ import fr.xephi.authme.security.crypts.description.Recommendation;
import fr.xephi.authme.security.crypts.description.Usage;
@Recommendation(Usage.RECOMMENDED)
public class BCRYPT2Y extends HexSaltedMethod {
public class BCrypt2y extends HexSaltedMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/CRAZYCRYPT1.java → src/main/java/fr/xephi/authme/security/crypts/CrazyCrypt1.java
+1 -1
View File
@@ -6,7 +6,7 @@ import fr.xephi.authme.security.MessageDigestAlgorithm;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
public class CRAZYCRYPT1 extends UsernameSaltMethod {
public class CrazyCrypt1 extends UsernameSaltMethod {
private static final char[] CRYPTCHARS =
{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
src/main/java/fr/xephi/authme/security/crypts/DOUBLEMD5.java → src/main/java/fr/xephi/authme/security/crypts/DoubleMd5.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import static fr.xephi.authme.security.HashUtils.md5;
public class DOUBLEMD5 extends UnsaltedMethod {
public class DoubleMd5 extends UnsaltedMethod {
@Override
public String computeHash(String password) {
src/main/java/fr/xephi/authme/security/crypts/IPB3.java → src/main/java/fr/xephi/authme/security/crypts/Ipb3.java
+1 -1
View File
@@ -10,7 +10,7 @@ import static fr.xephi.authme.security.HashUtils.md5;
@Recommendation(Usage.ACCEPTABLE)
@HasSalt(value = SaltType.TEXT, length = 5)
public class IPB3 extends SeparateSaltMethod {
public class Ipb3 extends SeparateSaltMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/IPB4.java → src/main/java/fr/xephi/authme/security/crypts/Ipb4.java
+3 -3
View File
@@ -11,15 +11,15 @@ import fr.xephi.authme.util.StringUtils;
/**
* Implementation for IPB4 (Invision Power Board 4).
* Implementation for Ipb4 (Invision Power Board 4).
* <p>
* The hash uses standard BCrypt with 13 as log<sub>2</sub> number of rounds. Additionally,
* IPB4 requires that the salt be stored additionally in the column "members_pass_hash"
* Ipb4 requires that the salt be stored additionally in the column "members_pass_hash"
* (even though BCrypt hashes already have the salt in the result).
*/
@Recommendation(Usage.DOES_NOT_WORK)
@HasSalt(value = SaltType.TEXT, length = 22)
public class IPB4 implements EncryptionMethod {
public class Ipb4 implements EncryptionMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/JOOMLA.java → src/main/java/fr/xephi/authme/security/crypts/Joomla.java
+1 -1
View File
@@ -5,7 +5,7 @@ import fr.xephi.authme.security.crypts.description.Recommendation;
import fr.xephi.authme.security.crypts.description.Usage;
@Recommendation(Usage.ACCEPTABLE)
public class JOOMLA extends HexSaltedMethod {
public class Joomla extends HexSaltedMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/MD5.java → src/main/java/fr/xephi/authme/security/crypts/Md5.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import fr.xephi.authme.security.HashUtils;
public class MD5 extends UnsaltedMethod {
public class Md5 extends UnsaltedMethod {
@Override
public String computeHash(String password) {
src/main/java/fr/xephi/authme/security/crypts/MD5VB.java → src/main/java/fr/xephi/authme/security/crypts/Md5vB.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import static fr.xephi.authme.security.HashUtils.md5;
public class MD5VB extends HexSaltedMethod {
public class Md5vB extends HexSaltedMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/MYBB.java → src/main/java/fr/xephi/authme/security/crypts/MyBB.java
+1 -1
View File
@@ -10,7 +10,7 @@ import static fr.xephi.authme.security.HashUtils.md5;
@Recommendation(Usage.ACCEPTABLE)
@HasSalt(value = SaltType.TEXT, length = 8)
public class MYBB extends SeparateSaltMethod {
public class MyBB extends SeparateSaltMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/PHPBB.java → src/main/java/fr/xephi/authme/security/crypts/PhpBB.java
+1 -1
View File
@@ -9,7 +9,7 @@ import java.security.MessageDigest;
/**
* @author stefano
*/
public class PHPBB extends HexSaltedMethod {
public class PhpBB extends HexSaltedMethod {
private static final String itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
src/main/java/fr/xephi/authme/security/crypts/PHPFUSION.java → src/main/java/fr/xephi/authme/security/crypts/PhpFusion.java
+1 -1
View File
@@ -14,7 +14,7 @@ import java.security.NoSuchAlgorithmException;
@Recommendation(Usage.DO_NOT_USE)
@AsciiRestricted
public class PHPFUSION extends SeparateSaltMethod {
public class PhpFusion extends SeparateSaltMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/PLAINTEXT.java → src/main/java/fr/xephi/authme/security/crypts/PlainText.java
+1 -1
View File
@@ -6,7 +6,7 @@ package fr.xephi.authme.security.crypts;
* @deprecated Using this is no longer supported. AuthMe will migrate to SHA256 on startup.
*/
@Deprecated
public class PLAINTEXT extends UnsaltedMethod {
public class PlainText extends UnsaltedMethod {
@Override
public String computeHash(String password) {
src/main/java/fr/xephi/authme/security/crypts/ROYALAUTH.java → src/main/java/fr/xephi/authme/security/crypts/RoyalAuth.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import fr.xephi.authme.security.HashUtils;
public class ROYALAUTH extends UnsaltedMethod {
public class RoyalAuth extends UnsaltedMethod {
@Override
public String computeHash(String password) {
src/main/java/fr/xephi/authme/security/crypts/SALTED2MD5.java → src/main/java/fr/xephi/authme/security/crypts/Salted2Md5.java
+2 -2
View File
@@ -14,12 +14,12 @@ import static fr.xephi.authme.security.HashUtils.md5;
@Recommendation(Usage.ACCEPTABLE) // presuming that length is something sensible (>= 8)
@HasSalt(value = SaltType.TEXT) // length defined by the doubleMd5SaltLength setting
public class SALTED2MD5 extends SeparateSaltMethod {
public class Salted2Md5 extends SeparateSaltMethod {
private final int saltLength;
@Inject
public SALTED2MD5(Settings settings) {
public Salted2Md5(Settings settings) {
saltLength = settings.getProperty(SecuritySettings.DOUBLE_MD5_SALT_LENGTH);
}
src/main/java/fr/xephi/authme/security/crypts/SALTEDSHA512.java → src/main/java/fr/xephi/authme/security/crypts/SaltedSha512.java
+1 -1
View File
@@ -6,7 +6,7 @@ import fr.xephi.authme.security.crypts.description.Recommendation;
import fr.xephi.authme.security.crypts.description.Usage;
@Recommendation(Usage.RECOMMENDED)
public class SALTEDSHA512 extends SeparateSaltMethod {
public class SaltedSha512 extends SeparateSaltMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/SHA1.java → src/main/java/fr/xephi/authme/security/crypts/Sha1.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import fr.xephi.authme.security.HashUtils;
public class SHA1 extends UnsaltedMethod {
public class Sha1 extends UnsaltedMethod {
@Override
public String computeHash(String password) {
src/main/java/fr/xephi/authme/security/crypts/SHA256.java → src/main/java/fr/xephi/authme/security/crypts/Sha256.java
+1 -1
View File
@@ -6,7 +6,7 @@ import fr.xephi.authme.security.crypts.description.Usage;
import static fr.xephi.authme.security.HashUtils.sha256;
@Recommendation(Usage.RECOMMENDED)
public class SHA256 extends HexSaltedMethod {
public class Sha256 extends HexSaltedMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/SHA512.java → src/main/java/fr/xephi/authme/security/crypts/Sha512.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import fr.xephi.authme.security.HashUtils;
public class SHA512 extends UnsaltedMethod {
public class Sha512 extends UnsaltedMethod {
@Override
public String computeHash(String password) {
src/main/java/fr/xephi/authme/security/crypts/SMF.java → src/main/java/fr/xephi/authme/security/crypts/Smf.java
+1 -1
View File
@@ -2,7 +2,7 @@ package fr.xephi.authme.security.crypts;
import fr.xephi.authme.security.HashUtils;
public class SMF extends UsernameSaltMethod {
public class Smf extends UsernameSaltMethod {
@Override
public HashedPassword computeHash(String password, String name) {
src/main/java/fr/xephi/authme/security/crypts/WBB3.java → src/main/java/fr/xephi/authme/security/crypts/Wbb3.java
+1 -1
View File
@@ -10,7 +10,7 @@ import static fr.xephi.authme.security.HashUtils.sha1;
@Recommendation(Usage.ACCEPTABLE)
@HasSalt(value = SaltType.TEXT, length = 40)
public class WBB3 extends SeparateSaltMethod {
public class Wbb3 extends SeparateSaltMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/WBB4.java → src/main/java/fr/xephi/authme/security/crypts/Wbb4.java
+1 -1
View File
@@ -6,7 +6,7 @@ import fr.xephi.authme.security.crypts.description.Usage;
import static fr.xephi.authme.security.crypts.BCryptService.hashpw;
@Recommendation(Usage.RECOMMENDED)
public class WBB4 extends HexSaltedMethod {
public class Wbb4 extends HexSaltedMethod {
@Override
public String computeHash(String password, String salt, String name) {
src/main/java/fr/xephi/authme/security/crypts/WHIRLPOOL.java → src/main/java/fr/xephi/authme/security/crypts/Whirlpool.java
+2 -2
View File
@@ -61,7 +61,7 @@ package fr.xephi.authme.security.crypts;
import java.util.Arrays;
public class WHIRLPOOL extends UnsaltedMethod {
public class Whirlpool extends UnsaltedMethod {
/**
* The message digest size (in bits)
@@ -158,7 +158,7 @@ public class WHIRLPOOL extends UnsaltedMethod {
protected final long[] block = new long[8];
protected final long[] state = new long[8];
public WHIRLPOOL() {
public Whirlpool() {
}
protected static String display(byte[] array) {
src/main/java/fr/xephi/authme/security/crypts/WORDPRESS.java → src/main/java/fr/xephi/authme/security/crypts/Wordpress.java
+1 -1
View File
@@ -16,7 +16,7 @@ import java.util.Arrays;
@HasSalt(value = SaltType.TEXT, length = 9)
// Note ljacqu 20151228: Wordpress is actually a salted algorithm but salt generation is handled internally
// and isn't exposed to the outside, so we treat it as an unsalted implementation
public class WORDPRESS extends UnsaltedMethod {
public class Wordpress extends UnsaltedMethod {
private static final String itoa64 = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
private final SecureRandom randomGen = new SecureRandom();
src/main/java/fr/xephi/authme/security/crypts/XAUTH.java → src/main/java/fr/xephi/authme/security/crypts/XAuth.java
+4 -4
View File
@@ -4,15 +4,15 @@ import fr.xephi.authme.security.crypts.description.Recommendation;
import fr.xephi.authme.security.crypts.description.Usage;
@Recommendation(Usage.RECOMMENDED)
public class XAUTH extends HexSaltedMethod {
public class XAuth extends HexSaltedMethod {
private static String getWhirlpool(String message) {
WHIRLPOOL w = new WHIRLPOOL();
byte[] digest = new byte[WHIRLPOOL.DIGESTBYTES];
Whirlpool w = new Whirlpool();
byte[] digest = new byte[Whirlpool.DIGESTBYTES];
w.NESSIEinit();
w.NESSIEadd(message);
w.NESSIEfinalize(digest);
return WHIRLPOOL.display(digest);
return Whirlpool.display(digest);
}
@Override
src/main/java/fr/xephi/authme/security/crypts/XFBCRYPT.java → src/main/java/fr/xephi/authme/security/crypts/XfBCrypt.java
+1 -1
View File
@@ -7,7 +7,7 @@ import fr.xephi.authme.util.StringUtils;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class XFBCRYPT implements EncryptionMethod {
public class XfBCrypt implements EncryptionMethod {
public static final String SCHEME_CLASS = "XenForo_Authentication_Core12";
private static final Pattern HASH_PATTERN = Pattern.compile("\"hash\";s.*\"(.*)?\"");
src/main/java/fr/xephi/authme/service/MigrationService.java
+4 -4
View File
@@ -5,7 +5,7 @@ import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.security.HashAlgorithm;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.security.crypts.SHA256;
import fr.xephi.authme.security.crypts.Sha256;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.SecuritySettings;
@@ -20,14 +20,14 @@ public final class MigrationService {
}
/**
* Hash all passwords to SHA256 and updated the setting if the password hash is set to the deprecated PLAINTEXT.
* Hash all passwords to Sha256 and updated the setting if the password hash is set to the deprecated PLAINTEXT.
*
* @param settings The settings instance
* @param dataSource The data source
* @param authmeSha256 Instance to the AuthMe SHA256 encryption method implementation
* @param authmeSha256 Instance to the AuthMe Sha256 encryption method implementation
*/
public static void changePlainTextToSha256(Settings settings, DataSource dataSource,
SHA256 authmeSha256) {
Sha256 authmeSha256) {
if (HashAlgorithm.PLAINTEXT == settings.getProperty(SecuritySettings.PASSWORD_HASH)) {
ConsoleLogger.warning("Your HashAlgorithm has been detected as plaintext and is now deprecated;"
+ " it will be changed and hashed now to the AuthMe default hashing method");
src/main/resources/messages/messages_zhcn.yml
+9 -9
View File
@@ -87,7 +87,7 @@ email_send_failure: '邮件发送失败，请联系管理员'
show_no_email: '&2您当前并没有任何邮箱与该账号绑定'
add_email: '&8[&6玩家系统&8] &c请输入“/email add <你的邮箱> <再输入一次以确认>”以把你的邮箱添加到此帐号'
recovery_email: '&8[&6玩家系统&8] &c忘了你的密码？请输入：“/email recovery <你的邮箱>”'
# TODO email_cooldown_error: '&cAn email was already sent recently. You must wait %time before you can send a new one.'
email_cooldown_error: '&c邮件已在几分钟前发送，您需要等待 %time 后才能再次请求发送'
# Captcha
usage_captcha: '&8[&6玩家系统&8] &c正确用法：/captcha <theCaptcha>'
@@ -95,11 +95,11 @@ wrong_captcha: '&8[&6玩家系统&8] &c错误的验证码，请输入：“/capt
valid_captcha: '&8[&6玩家系统&8] &c你的验证码是有效的！'
# Time units
# TODO second: 'second'
# TODO seconds: 'seconds'
# TODO minute: 'minute'
# TODO minutes: 'minutes'
# TODO hour: 'hour'
# TODO hours: 'hours'
# TODO day: 'day'
# TODO days: 'days'
second: '秒'
seconds: '秒'
minute: '分钟'
minutes: '分钟'
hour: '小时'
hours: '小时'
day: '天'
days: '天'