Generalize references from Bungee to proxies

They are not configuration options

Related #488

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,41 @@
+---
+name: Bug report
+about: Something isn't working
+title: ''
+labels: 'bug'
+assignees: ''
+
+---
+
+[//]: # (Lines in this format are considered as comments and will not be displayed.)
+[//]: # (Before reporting make sure you're running the **latest build** of the plugin and checked for existing issues!)
+
+### What behaviour is observed:
+[//]: # (What happened?)
+
+### What behaviour is expected:
+[//]: # (What did you expect?)
+
+### Steps/models to reproduce:
+[//]: # (The actions that cause the issue. Please explain it in detail)
+
+### Screenshots (if applicable)
+[//]: # (You can drop the files here directly)
+
+### Plugin list:
+[//]: # (This can be found by running `/pl`)
+
+### Environment description
+[//]: # (Server software with exact version number, Minecraft version, SQLite/MySQL/MariaDB, ...)
+
+### Plugin version or build number (don't write latest):
+[//]: # (This can be found by running `/version plugin-name`.)
+
+### Server Log:
+[//]: # (No images please - only the textual representation)
+[Hastebin](https://hastebin.com/) / [Gist](https://gist.github.com/) link of the error, stacktrace or the complete log (if any)
+
+### Configuration:
+[//]: # (No images please - only the textual representation)
+[//]: # (remember to delete any sensitive data)
+[Hastebin](https://hastebin.com/) / [Gist](https://gist.github.com/) link of your config.yml file 

.github/ISSUE_TEMPLATE/enhancement_request.md

@@ -0,0 +1,22 @@
+---
+name: Enhancement request
+about: New feature or change request
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+
+[//]: # (Lines in this format are considered as comments and will not be displayed.)
+
+### Is your feature request related to a problem? Please describe.
+[//]: # (A clear and concise description of what the problem is. Ex. I'm always frustrated when [...])
+
+### Describe the solution you'd like
+[//]: # (A clear and concise description of what you want to happen.)
+
+### Describe alternatives you've considered
+[//]: # (A clear and concise description of any alternative solutions or features you've considered.)
+
+### Additional context
+[//]: # (Add any other context or screenshots about the feature request here.)

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,10 @@
+---
+name: Question
+about: You want to ask something
+title: ''
+labels: 'question'
+assignees: ''
+
+---
+
+

.github/pull_request_template.md

@@ -0,0 +1,8 @@
+[//]: # (Lines in this format are considered as comments and will not be displayed.)
+[//]: # (If your work is in progress, please consider making a draft pull request.)
+
+### Summary of your change
+[//]: # (Example: motiviation, enhancement)
+
+### Related issue
+[//]: # (Reference it using '#NUMBER'. Ex: Fixes/Related #...)

.github/workflows/maven.yml

@@ -0,0 +1,49 @@
+# Automatically build, run unit and integration tests to detect errors early (CI provided by GitHub)
+# including making pull requests review easier
+
+# Human readable name in the actions tab
+name: Java CI
+
+# Build on every push and pull request regardless of the branch
+# Wiki: https://help.github.com/en/actions/reference/events-that-trigger-workflows
+on:
+    - push
+    - pull_request
+
+jobs:
+  # job id
+  build_and_test:
+
+    # Environment image - always newest OS
+    runs-on: ubuntu-latest
+
+    # Run steps
+    steps:
+    # Pull changes
+    - uses: actions/checkout@v2.3.4
+
+    # Cache artifacts - however this has the downside that we don't get notified of
+    # artifact resolution failures like invalid repository
+    # Nevertheless the repositories should be more stable and it makes no sense to pull
+    # a same version every time
+    # A dry run would make more sense
+    - uses: actions/cache@v2.1.4
+      with:
+        path: ~/.m2/repository
+        key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
+        restore-keys: |
+          ${{ runner.os }}-maven-
+
+    # Setup Java
+    - name: Set up JDK
+      uses: actions/setup-java@v1.4.3
+      with:
+        # Use Java 11, because it's minimum required version
+        java-version: 11
+
+    # Build and test (included in package)
+    - name: Build with Maven and test
+    # Run non-interactive, package (with compile+test),
+    # ignore snapshot updates, because they are likely to have breaking changes, enforce checksums to validate
+    # possible errors in dependencies
+      run: mvn package test --batch-mode --no-snapshot-updates --strict-checksums --file pom.xml

.gitignore

@@ -1,38 +1,22 @@
-# Eclipse stuff
-/.classpath
-/.project
-/.settings
+# Eclipse
+.classpath
+.project
+.settings/
 
-# netbeans
-/nbproject
+# NetBeans
+nbproject/
 nb-configuration.xml
-/bukkit/nbproject/
 
-# maven
-/target
-
-# vim
-.*.sw[a-p]
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-# various other potential build files
-/build
-/bin
-/dist
-/manifest.mf
-*.log
-
-# Mac filesystem dust
-.DS_Store
-
-# intellij
+# IntelliJ
 *.iml
 *.ipr
 *.iws
 .idea/
 
+# Maven
+target/
+pom.xml.versionsBackup
+
 # Gradle
 .gradle
 
@@ -42,8 +26,21 @@ gradle-app.setting
 # Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
 !gradle-wrapper.jar
 
-# Project module targets
-bukkit/target
-universal/target
-bungee/target
-core/target
+# various other potential build files
+build/
+bin/
+dist/
+manifest.mf
+*.log
+
+# Vim
+.*.sw[a-p]
+
+# virtual machine crash logs, see https://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+# Mac filesystem dust
+.DS_Store
+
+# Factorypath from Visual Studio Code
+.factorypath

.travis.yml

@@ -1,12 +0,0 @@
-# Use https://travis-ci.org/ for automatic tests
-
-# speed up testing https://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
-sudo: false
-
-# This is a java project
-language: java
-
-script: mvn compile test
-
-# We run on 8
-jdk: [oraclejdk8]

CHANGELOG.md

@@ -1,17 +1,41 @@
+### 1.11
+
+* TODO: Replace reflection with methodhandles
+
+* Use direct proxies instead of ssl factories for multiple IP-addresses
+* Remove local address check for multiple IP-addresses
+* Fix parsing of local IP-addresses
+* Fix address rotating for contacting the Mojang API
+* Optimize issue template
+* Use Instant for timestamps
+* Migrate SLF4J logging (Fixes #177)
+* Use Gson's TypeAdapter for more type safety
+* Add support for IPv6 proxies
+* Shared configuration implementation for easier maintained code
+* Use Gson for json parsing, because it's supported on all platforms and removes code duplicates
+* Clean up project code
+* Drop support for deprecated AuthMe API
+* Remove legacy database migration code
+* Drop support for RoyalAuth, because it doesn't seem to be supported anymore
+* Clean up client-server encryption -> use only one cipher per connection, simplify code
+
 ### 1.10
 
+* Prevent authentication proxies
+* Drop database importer
+* More logging by default
 * Add support for HTTP proxies
 * Set the fake offline UUID on lowest priority (-> as soon as possible)
 * Remove bungee chatcolor for Bukkit to support KCauldron
 * Minor cleanup using inspections + Https
 * Increase hook delay to let ProtocolLib inject the listener
 * Drop support for old AuthMe API + Add support for new AuthMe API
-* Remove ebean util usage to make it compatible with 1.12
+* Remove eBean util usage to make it compatible with 1.12
 * Do not try to hook into a plugin if auth plugin hook is already set using the FastLogin API
 * Automatically register accounts if they are not in the auth plugin database but in the FastLogin database
 * Update BungeeAuth dependency and use the new API. Please update your plugin if you still use the old one.
 * Remove deprecated API methods from the last version
-* Finally set a value to the API column
+* Finally update the IP column on every login
 * No duplicate session login
 * Fix timestamp parsing in newer versions of SQLite
 * Fix Spigot console command invocation sends result to in game players
@@ -24,7 +48,7 @@
 * Added missing add-premium-other message
 * Upgrade to Java 8 -> Minimize file size
 * Refactored/Cleaned up a lot of code
-* [API] Deprecated platform specific authplugin. Please use AuthPlugin< platform specific player type >
+* [API] Deprecated platform specific auth-plugin. Please use AuthPlugin< platform specific player type >
 * [API] Deprecated bukkit's password generator. Please use PasswordGenerator< platform specific player type >
 * Fix ProtocolSupport autoRegister
 * Fix update username in FastLogin database after nameChange
@@ -47,7 +71,7 @@
 ### 1.7.1
 
 * Fix BungeeCord autoRegister (Fixes #46)
-* Fix protocollsupport autoregister
+* Fix ProtocolSupport auto-register
 
 ### 1.7
 
@@ -161,7 +185,7 @@
 * Removes the need of an Bukkit auth plugin if you use a bungeecord one
 * Optimize performance and thread-safety
 * Fixed BungeeCord support
-* Changed config option autologin to autoregister to clarify the usage
+* Changed config option auto-login to auto-register to clarify the usage
 
 ### 0.6
 
@@ -171,19 +195,19 @@
 ### 0.5
 
 * Added cracked command
-* Added autologin - See config
+* Added auto-login - See config
 * Added config
 * Added isRegistered API method
 * Added forceRegister API method
 
 * Fixed CrazyLogin player data restore -> Fixes memory leaks with this plugin
-* Fixed premium name check to protocolsupport
+* Fixed premium name check to ProtocolSupport
 * Improved permissions management
 
 ### 0.4
 
 * Added forward premium skin
-* Added plugin support for protocolsupport
+* Added plugin support for ProtocolSupport
 
 ### 0.3.2
 
@@ -209,7 +233,7 @@
 
 ### 0.2.3
 
-* Remove useless AuthMe forcelogin code
+* Remove useless AuthMe force-login code
 * Send a kick message to the client instead of just "Disconnect"
 * Reformat source code
 * Fix thread safety for fake start packets (Bukkit.getOfflinePlayer doesn't look like to be thread-safe)

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-17
+Copyright (c) 2015-2018
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -3,7 +3,7 @@
 Checks if a Minecraft player has a paid account (premium). If so, they can skip offline authentication (auth plugins).
 So they don't need to enter passwords. This is also called auto login (auto-login).
 
-### Features:
+## Features
 
 * Detect paid accounts from others
 * Automatically login paid accounts (premium)
@@ -11,172 +11,114 @@ So they don't need to enter passwords. This is also called auto login (auto-logi
 * Cauldron support
 * Forge/Sponge message support
 * Premium UUID support
-* Forwards Skins
+* Forward skins
 * Detect user name changed and will update the existing database record
 * BungeeCord support
 * Auto register new premium players
 * Plugin: ProtocolSupport is supported and can be used as an alternative to ProtocolLib
 * No client modifications needed
-* Good performance by using async non blocking operations
+* Good performance by using async operations
 * Locale messages
-* Import the database from similar plugins
-* Free
-* Open source
+* Support for Bedrock players proxied through FloodGate
+
+## Issues
+
+Please use issues for bug reports, suggestions, questions and more. Please check for existing issues. Existing issues 
+can be voted up by adding up vote to the original post. Closing issues means that they are marked as resolved. Comments
+are still allowed and it could be re-opened.
+
+## Development builds
+
+Development builds of this project can be acquired at the provided CI (continuous integration) server. It contains the
+latest changes from the Source-Code in preparation for the following release. This means they could contain new
+features, bug fixes and other changes since the last release.
+
+They **could** contain new bugs and are likely to be less stable than released versions.
+
+Specific builds can be grabbed by clicking on the build number on the left side or by clicking on status to retrieve the
+latest build.
+https://ci.codemc.org/job/Games647/job/FastLogin/changes
 
 ***
 
-### Commands:
-    * /premium [player] Label the invoker or the argument as paid account
-    * /cracked [player] Label the invoker or the argument as cracked account
-    * /importdb <autoIn/bpa/eldzi> <mysql/sqlite> [host:port] [database] [username] [password] - Imports the database from another plugin
+## Commands
 
-### Permissions:
-    * fastlogin.bukkit.command.premium
-    * fastlogin.bukkit.command.cracked
-    * fastlogin.command.premium.other
-    * fastlogin.command.cracked.other
-    * fastlogin.command.import
+    /premium [player] Label the invoker or the argument as paid account
+    /cracked [player] Label the invoker or the argument as cracked account
 
-### Requirements:
-* Plugin: [ProtocolLib](https://www.spigotmc.org/resources/protocollib.1997/) or [ProtocolSupport](https://www.spigotmc.org/resources/protocolsupport.7201/)
-* Tested Bukkit/[Spigot](https://www.spigotmc.org) 1.9 (could also work with other versions)
-* Java 7+
-* Run Spigot and/or BungeeCord/Waterfall in offline mode (see server.properties or config.yml)
-* An auth plugin. Supported plugins
+## Permissions
 
-#### Bukkit/Spigot/Paper
+    fastlogin.bukkit.command.premium
+    fastlogin.bukkit.command.cracked
+    fastlogin.command.premium.other
+    fastlogin.command.cracked.other
+
+## Placeholder
+
+This plugin supports `PlaceholderAPI` on `Spigot`. It exports the following variable 
+`%fastlogin_status%`. In BungeeCord environments, the status of a player will be delivered with a delay after the player 
+already successful joined the server. This takes about a couple of milliseconds. In this case the value
+will be `Unknown`. 
+
+Possible values: `Premium`, `Cracked`, `Unknown` 
+
+## Requirements
+
+* Plugin: 
+    * [ProtocolLib](https://www.spigotmc.org/resources/protocollib.1997/) or 
+    * [ProtocolSupport](https://www.spigotmc.org/resources/protocolsupport.7201/)
+* [Spigot](https://www.spigotmc.org) 1.8.8+
+* Java 8+
+* Run Spigot (or a fork e.g. Paper) and/or BungeeCord (or a fork e.g. Waterfall) in offline mode
+* An auth plugin.
+
+### Supported auth plugins
+
+#### Spigot/Paper
 
-* [AuthMe (both 5.X and 3.X)](https://dev.bukkit.org/bukkit-plugins/authme-reloaded/)
-* [xAuth](https://dev.bukkit.org/bukkit-plugins/xauth/)
-* [LogIt](https://github.com/XziomekX/LogIt)
 * [AdvancedLogin (Paid)](https://www.spigotmc.org/resources/advancedlogin.10510/)
+* [AuthMe (5.X)](https://dev.bukkit.org/bukkit-plugins/authme-reloaded/)
 * [CrazyLogin](https://dev.bukkit.org/bukkit-plugins/crazylogin/)
 * [LoginSecurity](https://dev.bukkit.org/bukkit-plugins/loginsecurity/)
-* [RoyalAuth](https://dev.bukkit.org/bukkit-plugins/royalauth/)
+* [LogIt](https://github.com/games647/LogIt)
+* [SodionAuth (2.0+)](https://github.com/Mohist-Community/SodionAuth)
 * [UltraAuth](https://dev.bukkit.org/bukkit-plugins/ultraauth-aa/)
+* [UserLogin](https://www.spigotmc.org/resources/userlogin.80669/)
+* [xAuth](https://dev.bukkit.org/bukkit-plugins/xauth/)
 
 #### BungeeCord/Waterfall
 
 * [BungeeAuth](https://www.spigotmc.org/resources/bungeeauth.493/)
+* [BungeeAuthenticator](https://www.spigotmc.org/resources/bungeecordauthenticator.87669/)
 
-### Downloads
+## Network requests
 
-https://www.spigotmc.org/resources/fastlogin.14153/history
+This plugin performs network requests to:
+
+* https://api.mojang.com - retrieving uuid data to decide if we should activate premium login
+* https://sessionserver.mojang.com - verify if the player is the owner of that account
 
 ***
 
-### How to install
+## How to install
 
-#### Bukkit/Spigot/Paper
+### Spigot/Paper
 
-1. Download and install ProtocolLib
-2. Download and install FastLogin
+1. Download and install ProtocolLib/ProtocolSupport
+2. Download and install FastLogin (or FastLoginBukkit for newer versions)
 3. Set your server in offline mode by setting the value onlinemode in your server.properties to false
 
-#### BungeeCord/Waterfall
+### BungeeCord/Waterfall
 
 1. Activate BungeeCord in the Spigot configuration
 2. Restart your server
-3. Now there is proxy-whitelist file in the FastLogin folder
+3. Now there is `allowed-proxies.txt` file in the FastLogin folder
 Put your stats id from the BungeeCord config into this file
 4. Activate ipForward in your BungeeCord config
-5. Download and Install FastLogin on BungeeCord AND Spigot
+5. Download and Install FastLogin (or FastLoginBungee in newer versions) on BungeeCord AND Spigot
+(on the servers where your login plugin is or where player should be able to execute the commands of FastLogin)
 6. Check your database settings in the config of FastLogin on BungeeCord
-7. Set your proxy (BungeeCord) in offline mode by setting the value onlinemode in your config.yml to false
-8. You should *always* firewall your spigot server that it's only accessible through BungeeCord https://www.spigotmc.org/wiki/bungeecord-installation/#post-installation
-9. (BungeeCord doesn't support SQLite per default, so you should change the configuration to MySQL or MariaDB)
-
-***
-
-### FAQ
-
-#### Index
-1. [How does Minecraft logins work?](#how-does-minecraft-logins-work)
-2. [How does this plugin work?](#how-does-this-plugin-work)
-3. [Why does the plugin require offline mode?](#why-does-the-plugin-require-offline-mode)
-4. [Can cracked player join with premium usernames?](#can-cracked-player-join-with-premium-usernames)
-5. [Why do players have to invoke a command?](#why-do-players-have-to-invoke-a-command)
-6. [What happens if a paid account joins with a used username?](#what-happens-if-a-paid-account-joins-with-a-used-username)
-7. [Does the plugin have BungeeCord support?](#does-the-plugin-have-bungeecord-support)
-8. [Could premium players have a premium UUID and Skin?](#could-premium-players-have-a-premium-uuid-and-skin)
-9. [Is this plugin compatible with Cauldron?](#is-this-plugin-compatible-with-cauldron)
-
-#### How does minecraft logins work?
-###### Online Mode
-1. Client -> Server: I want to login, here is my username
-2. Server -> Client: Okay. I'm in online mode so here is my public key for encryption and my server id
-3. Client -> Mojang: I'm player "xyz". I want to join a server with that server id
-4. Mojang -> Client: Session data checked. You can continue
-5. Client -> Server: I received a successful response from Mojang. Here our shared secret key
-6. Server -> Mojang: Does the player "xyz" with this shared secret key has a valid account to join me?
-7. Mojang -> Server: Yes, the player has the following additionally properties (UUID, Skin)
-8. Client and Server: encrypt all following communication packet
-9. Server -> Client: Everything checked you can play now
-
-
-###### Offline Mode
-In offline mode step 2-7 is skipped. So a login request is directly followed by 8.
-
-###### More details
-http://wiki.vg/Protocol#Login
-
-#### How does this plugin work?
-By using ProtocolLib, this plugin works as a proxy between the client and server. This plugin will fake that the server
-runs in online mode. It does everything an online mode server would do. This will be for example, generating keys or
-checking for valid sessions. Because everything is the same compared to an offline mode login after an encrypted
-connection, we will intercept only **login** packets of **premium** players.
-
-1. Player is connecting to the server.
-2. Plugin checks if the username we received activated the fast login method (i.e. using command)
-3. Run a check if the username is currently used by a paid account.
-(We don't know yet if the client connecting is premium)
-4. Request an Mojang Session Server authentication
-5. On response check if all data is correct
-6. Encrypt the connection
-7. On success intercept all related login packets and fake a new login packet as a normal offline login
-
-#### Why does the plugin require offline mode?
-1. As you can see in the question "how does minecraft login works", offline mode is equivalent to online mode except of
-the encryption and session checks on login. So we can intercept and cancel the first packets for premium players and
-enable an encrypted connection. Then we send a new fake packet in order to pretend that this a new login request from
-a offline mode player. The server will handle the rest.
-2. Some plugins check if the server is in online mode. If so, they could process the real offline (cracked) accounts
-incorrectly. For example, a plugin tries to fetch the UUID from Mojang, but the name of the player is not associated to
-a paid account.
-3. Servers, who allow cracked players and just speed up logins for premium players, are **already** in offline mode.
-
-#### Can cracked player join with premium usernames?
-Yes, indeed. Therefore the command for toggling the fast login method exists.
-
-#### Why do players have to invoke a command?
-1. It's a secure way to make sure a person with a paid account cannot steal the account
-of a cracked player that has the same username. The player have to proof first that it's his own account.
-2. We only receive the username from the player on login. We could check if that username is associated
-to a paid account but if we request a online mode login from a cracked player (who uses a username from
-a paid account), the player will disconnect with the reason "bad login" or "Invalid session". There is no way to change
-that message on the server side (without client modifications), because it's a connection between the Client and the
-session-server.
-3. If a premium player would skip registration too, a player of a cracked account could later still register the
-account and would claim and steal the account from the premium player. Because commands cannot be invoked unless the
-player has a account or is logged in, protects this method also premium players
-
-### What happens if a paid account joins with a used username?
-The player on the server have to activate the feature of this plugin by command. If a person buys the username
-of his own account, it's still secured. A normal offline mode login makes sure he's the owner of the server account
-and Mojang account. Then the command can be executed. So someone different cannot steal the account of cracked player
-by buying the username.
-
-#### Does the plugin have BungeeCord support?
-Yes it has. See the how to install above.
-
-#### Could premium players have a premium UUID and Skin?
-Since 0.7 both features are implemented. You can check the config.yml in order to activate it.
-
-#### Is this plugin compatible with Cauldron?
-It's not tested yet, but all needed methods also exists in Cauldron so it could work together.
-
-***
-
-### Useful Links:
-* [Login Protocol](http://wiki.vg/Protocol#Login)
-* [Protocol Encryption](http://wiki.vg/Protocol_Encryption)
+7. Set proxy and Spigot in offline mode by setting the value onlinemode in your config.yml to false
+8. You should *always* firewall your Spigot server that it's only accessible through BungeeCord 
+    * https://www.spigotmc.org/wiki/bungeecord-installation/#post-installation
+    * BungeeCord doesn't support SQLite per default, so you should change the configuration to MySQL or MariaDB

bukkit/pom.xml

@@ -1,11 +1,11 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
         <groupId>com.github.games647</groupId>
         <artifactId>fastlogin</artifactId>
-        <version>1.10</version>
+        <version>1.11-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -15,84 +15,137 @@
 
     <name>FastLoginBukkit</name>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.4</version>
+                <configuration>
+                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                    <shadedArtifactAttached>false</shadedArtifactAttached>
+                    <relocations>
+                        <relocation>
+                            <pattern>com.zaxxer.hikari</pattern>
+                            <shadedPattern>fastlogin.hikari</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>org.slf4j</pattern>
+                            <shadedPattern>fastlogin.slf4j</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>net.md_5.bungee.config</pattern>
+                            <shadedPattern>fastlogin.config</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>com.google.gson</pattern>
+                            <shadedPattern>fastlogin.gson</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>io.papermc.lib</pattern>
+                            <shadedPattern>fastlogin.paperlib</shadedPattern>
+                        </relocation>
+                    </relocations>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
     <repositories>
-        <!--Bukkit-Server-API -->
+        <!-- PaperSpigot API and PaperLib -->
         <repository>
-            <id>spigot-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
+            <id>papermc</id>
+            <url>https://papermc.io/repo/repository/maven-public/</url>
         </repository>
 
-        <!--LoginSecurity-->
-        <repository>
-            <id>lenis0012-repo</id>
-            <url>http://ci.lenis0012.com/plugin/repository/everything/</url>
-        </repository>
-
-        <!--ProtocolLib-->
+        <!-- ProtocolLib -->
         <repository>
             <id>dmulloy2-repo</id>
-            <url>http://repo.dmulloy2.net/content/groups/public/</url>
+            <url>https://repo.dmulloy2.net/nexus/repository/public/</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
         </repository>
 
-        <!--AuthMe Reloaded-->
+        <!-- AuthMe Reloaded, xAuth and LoginSecurity -->
         <repository>
-            <id>xephi-repo</id>
-            <url>https://ci.xephi.fr/plugin/repository/everything/</url>
+            <id>codemc-releases</id>
+            <url>https://repo.codemc.io/repository/maven-public/</url>
         </repository>
 
-        <!--xAuth-->
-        <repository>
-            <id>luricos.de-repo</id>
-            <url>http://repo.luricos.de/bukkit-plugins/</url>
-        </repository>
-
-        <!--Github automatic maven builds-->
+        <!-- GitHub automatic maven builds -->
         <repository>
             <id>jitpack.io</id>
             <url>https://jitpack.io</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
         </repository>
-        
-        <!--PlaceholderAPI -->
+
+        <!-- PlaceholderAPI -->
         <repository>
             <id>placeholderapi</id>
-            <url>http://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
         </repository>
     </repositories>
 
     <dependencies>
+        <!--Common plugin component-->
         <dependency>
             <groupId>com.github.games647</groupId>
             <artifactId>fastlogin.core</artifactId>
             <version>${project.version}</version>
+        </dependency>
+
+        <!-- PaperSpigot API for correcting usercache usage -->
+        <dependency>
+            <groupId>com.destroystokyo.paper</groupId>
+            <artifactId>paper-api</artifactId>
+            <version>1.15.2-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
 
-        <!--Server API-->
+        <!-- PaperLib for checking if server uses PaperSpigot -->
         <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.12-pre2-SNAPSHOT</version>
-            <scope>provided</scope>
+            <groupId>io.papermc</groupId>
+            <artifactId>paperlib</artifactId>
+            <version>1.0.6</version>
+            <scope>compile</scope>
         </dependency>
 
         <!--Library for listening and sending Minecraft packets-->
         <dependency>
             <groupId>com.comphenix.protocol</groupId>
             <artifactId>ProtocolLib</artifactId>
-            <version>4.3.0</version>
+            <version>4.6.0</version>
+            <scope>provided</scope>
         </dependency>
 
+        <!--Changing onlinemode on login process-->
         <dependency>
             <groupId>com.github.ProtocolSupport</groupId>
             <artifactId>ProtocolSupport</artifactId>
-            <!--4.25.dev-->
-            <version>a4f060dc46</version>
+            <!--4.29.dev after commit about API improvements-->
+            <version>3a80c661fe</version>
+            <scope>provided</scope>
         </dependency>
 
+        <!--Provide premium placeholders-->
         <dependency>
             <groupId>me.clip</groupId>
             <artifactId>placeholderapi</artifactId>
-            <version>2.8.1</version>
+            <version>2.10.8</version>
             <scope>provided</scope>
             <optional>true</optional>
             <exclusions>
@@ -107,7 +160,8 @@
         <dependency>
             <groupId>fr.xephi</groupId>
             <artifactId>authme</artifactId>
-            <version>5.3.1</version>
+            <version>5.4.0</version>
+            <scope>provided</scope>
             <optional>true</optional>
             <exclusions>
                 <exclusion>
@@ -120,7 +174,8 @@
         <dependency>
             <groupId>com.lenis0012.bukkit</groupId>
             <artifactId>loginsecurity</artifactId>
-            <version>2.1.6</version>
+            <version>3.0.2</version>
+            <scope>provided</scope>
             <optional>true</optional>
             <exclusions>
                 <exclusion>
@@ -134,20 +189,7 @@
             <groupId>com.github.games647</groupId>
             <artifactId>LogIt</artifactId>
             <version>9e3581db27</version>
-            <optional>true</optional>
             <scope>provided</scope>
-            <exclusions>
-                <exclusion>
-                    <groupId>*</groupId>
-                    <artifactId>*</artifactId>
-                </exclusion>
-            </exclusions>
-        </dependency>
-
-        <dependency>
-            <groupId>com.github.RoyalDev</groupId>
-            <artifactId>RoyalAuth</artifactId>
-            <version>-e21354a9b7-1</version>
             <optional>true</optional>
             <exclusions>
                 <exclusion>
@@ -161,6 +203,7 @@
             <groupId>de.luricos.bukkit</groupId>
             <artifactId>xAuth</artifactId>
             <version>2.6</version>
+            <scope>provided</scope>
             <optional>true</optional>
             <!--These artifacts produce conflicts on downloading-->
             <exclusions>
@@ -198,5 +241,19 @@
             <scope>system</scope>
             <systemPath>${project.basedir}/lib/UltraAuth v2.1.2.jar</systemPath>
         </dependency>
+
+        <dependency>
+            <groupId>com.github.Mohist-Community.SodionAuth</groupId>
+            <artifactId>SodionAuth-Bukkit</artifactId>
+            <version>b74392aa34</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.github.Mohist-Community.SodionAuth</groupId>
+                    <artifactId>SodionAuth-Libs</artifactId>
+                </exclusion>
+            </exclusions>
+            <optional>true</optional>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 </project>

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/BukkitLoginSession.java

@@ -1,101 +0,0 @@
-package com.github.games647.fastlogin.bukkit;
-
-import com.github.games647.fastlogin.core.PlayerProfile;
-import com.github.games647.fastlogin.core.shared.LoginSession;
-
-import org.apache.commons.lang.ArrayUtils;
-
-/**
- * Represents a client connecting to the server.
- *
- * This session is invalid if the player disconnects or the login was successful
- */
-public class BukkitLoginSession extends LoginSession {
-
-    private final String serverId;
-    private final byte[] verifyToken;
-
-    private boolean verified;
-
-    private String encodedSkinData;
-    private String skinSignature;
-
-    public BukkitLoginSession(String username, String serverId, byte[] verifyToken, boolean registered
-            , PlayerProfile profile) {
-        super(username, registered, profile);
-
-        this.serverId = serverId;
-        this.verifyToken = ArrayUtils.clone(verifyToken);
-    }
-
-    //available for BungeeCord
-    public BukkitLoginSession(String username, boolean registered) {
-        this(username, "", ArrayUtils.EMPTY_BYTE_ARRAY, registered, null);
-    }
-
-    //cracked player
-    public BukkitLoginSession(String username, PlayerProfile profile) {
-        this(username, "", ArrayUtils.EMPTY_BYTE_ARRAY, false, profile);
-    }
-
-    /**
-     * Gets the random generated server id. This makes sure the request sent from the client is just for this server.
-     *
-     * See this for details http://www.sk89q.com/2011/09/Minecraft-name-spoofing-exploit/
-     *
-     * Empty if it's a BungeeCord connection
-     *
-     * @return random generated server id
-     */
-    public String getServerId() {
-        return serverId;
-    }
-
-    /**
-     * Gets the verify token the server sent to the client.
-     *
-     * Empty if it's a BungeeCord connection
-     *
-     * @return the verify token from the server
-     */
-    public byte[] getVerifyToken() {
-        return ArrayUtils.clone(verifyToken);
-    }
-
-    public synchronized String getEncodedSkinData() {
-        return encodedSkinData;
-    }
-
-    public synchronized String getSkinSignature() {
-        return skinSignature;
-    }
-
-    /**
-     * Sets the premium skin property which was retrieved by the session server
-     *
-     * @param encodedData
-     * @param skinSignature
-     */
-    public synchronized void setSkin(String encodedData, String skinSignature) {
-        this.encodedSkinData = encodedData;
-        this.skinSignature = skinSignature;
-    }
-
-    /**
-     * Sets whether the player has a premium (paid account) account and valid session
-     *
-     * @param verified whether the player has valid session
-     */
-    public synchronized void setVerified(boolean verified) {
-        this.verified = verified;
-    }
-
-    /**
-     * Get whether the player has a premium (paid account) account and valid session
-     *
-     * @return whether the player has a valid session
-     */
-    public synchronized boolean isVerified() {
-        return verified;
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/BukkitScheduler.java

@@ -0,0 +1,27 @@
+package com.github.games647.fastlogin.bukkit;
+
+import com.github.games647.fastlogin.core.AsyncScheduler;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ThreadFactory;
+
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+import org.slf4j.Logger;
+
+public class BukkitScheduler extends AsyncScheduler {
+
+    private final Plugin plugin;
+    private final Executor syncExecutor;
+
+    public BukkitScheduler(Plugin plugin, Logger logger, ThreadFactory threadFactory) {
+        super(logger, threadFactory);
+        this.plugin = plugin;
+
+        syncExecutor = r -> Bukkit.getScheduler().runTask(plugin, r);
+    }
+
+    public Executor getSyncExecutor() {
+        return syncExecutor;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/BukkitSessionManager.java

@@ -0,0 +1,24 @@
+package com.github.games647.fastlogin.bukkit;
+
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.core.SessionManager;
+
+import java.net.InetSocketAddress;
+import java.util.UUID;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+public class BukkitSessionManager extends SessionManager<PlayerQuitEvent, InetSocketAddress, BukkitLoginSession>
+    implements Listener {
+
+    @EventHandler
+    @Override
+    public void onPlayQuit(PlayerQuitEvent quitEvent) {
+        Player player = quitEvent.getPlayer();
+        UUID playerId = player.getUniqueId();
+        endPlaySession(playerId);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/EncryptionUtil.java

@@ -1,120 +0,0 @@
-package com.github.games647.fastlogin.bukkit;
-
-import com.google.common.base.Charsets;
-
-import java.security.InvalidKeyException;
-import java.security.Key;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
-import java.security.MessageDigest;
-import java.security.NoSuchAlgorithmException;
-import java.util.stream.Stream;
-
-import javax.crypto.BadPaddingException;
-import javax.crypto.Cipher;
-import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.NoSuchPaddingException;
-import javax.crypto.SecretKey;
-import javax.crypto.spec.SecretKeySpec;
-
-/**
- * Encryption and decryption minecraft util for connection between servers
- * and paid minecraft account clients.
- *
- * Source: https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/MinecraftEncryption.java
- *
- * Remapped by: https://github.com/Techcable/MinecraftMappings/tree/master/1.8
- */
-public class EncryptionUtil {
-
-    public static KeyPair generateKeyPair() {
-        try {
-            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
-
-            keyPairGenerator.initialize(1_024);
-            return keyPairGenerator.generateKeyPair();
-        } catch (NoSuchAlgorithmException nosuchalgorithmexception) {
-            //Should be existing in every vm
-            throw new ExceptionInInitializerError(nosuchalgorithmexception);
-        }
-    }
-
-    public static byte[] getServerIdHash(String serverId, Key publicKey, Key secretKey) {
-        return digestOperation("SHA-1"
-                , serverId.getBytes(Charsets.ISO_8859_1), secretKey.getEncoded(), publicKey.getEncoded());
-    }
-
-    private static byte[] digestOperation(String algorithm, byte[]... content) {
-        try {
-            MessageDigest messagedigest = MessageDigest.getInstance(algorithm);
-            Stream.of(content).forEach(messagedigest::update);
-
-            return messagedigest.digest();
-        } catch (NoSuchAlgorithmException nosuchalgorithmexception) {
-            nosuchalgorithmexception.printStackTrace();
-            return null;
-        }
-    }
-
-//    public static PublicKey decodePublicKey(byte[] encodedKey) {
-//        try {
-//            KeyFactory keyfactory = KeyFactory.getInstance("RSA");
-//
-//            X509EncodedKeySpec x509encodedkeyspec = new X509EncodedKeySpec(encodedKey);
-//            return keyfactory.generatePublic(x509encodedkeyspec);
-//        } catch (NoSuchAlgorithmException | InvalidKeySpecException nosuchalgorithmexception) {
-//            //ignore
-//        }
-//
-//        System.err.println("Public key reconstitute failed!");
-//        return null;
-//    }
-
-    public static SecretKey decryptSharedKey(Key privateKey, byte[] encryptedSharedKey) {
-        return new SecretKeySpec(decryptData(privateKey, encryptedSharedKey), "AES");
-    }
-
-    public static byte[] decryptData(Key key, byte[] data) {
-        return cipherOperation(Cipher.DECRYPT_MODE, key, data);
-    }
-
-    private static byte[] cipherOperation(int operationMode, Key key, byte[] data) {
-        try {
-            return createCipherInstance(operationMode, key.getAlgorithm(), key).doFinal(data);
-        } catch (IllegalBlockSizeException | BadPaddingException ex) {
-            ex.printStackTrace();
-        }
-
-        System.err.println("Cipher data failed!");
-        return null;
-    }
-
-    private static Cipher createCipherInstance(int operationMode, String cipherName, Key key) {
-        try {
-            Cipher cipher = Cipher.getInstance(cipherName);
-
-            cipher.init(operationMode, key);
-            return cipher;
-        } catch (InvalidKeyException | NoSuchAlgorithmException | NoSuchPaddingException ex) {
-            ex.printStackTrace();
-        }
-
-        System.err.println("Cipher creation failed!");
-        return null;
-    }
-//
-//    public static Cipher createBufferedBlockCipher(int operationMode, Key key) {
-//        try {
-//            Cipher cipher = Cipher.getInstance("AES/CFB8/NoPadding");
-//
-//            cipher.init(operationMode, key, new IvParameterSpec(key.getEncoded()));
-//            return cipher;
-//        } catch (GeneralSecurityException generalsecurityexception) {
-//            throw new RuntimeException(generalsecurityexception);
-//        }
-//    }
-
-    private EncryptionUtil() {
-        //utility
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/FastLoginBukkit.java

@@ -1,141 +1,135 @@
 package com.github.games647.fastlogin.bukkit;
 
-import com.github.games647.fastlogin.bukkit.commands.CrackedCommand;
-import com.github.games647.fastlogin.bukkit.commands.PremiumCommand;
-import com.github.games647.fastlogin.bukkit.listener.BukkitJoinListener;
-import com.github.games647.fastlogin.bukkit.listener.BungeeCordListener;
-import com.github.games647.fastlogin.bukkit.listener.protocollib.LoginSkinApplyListener;
-import com.github.games647.fastlogin.bukkit.listener.protocollib.ProtocolLibListener;
-import com.github.games647.fastlogin.bukkit.listener.protocolsupport.ProtocolSupportListener;
-import com.github.games647.fastlogin.bukkit.tasks.DelayedAuthHook;
+import com.github.games647.fastlogin.bukkit.auth.proxy.ProxyManager;
+import com.github.games647.fastlogin.bukkit.auth.protocollib.ProtocolLibListener;
+import com.github.games647.fastlogin.bukkit.auth.protocolsupport.ProtocolSupportListener;
+import com.github.games647.fastlogin.bukkit.command.CrackedCommand;
+import com.github.games647.fastlogin.bukkit.command.PremiumCommand;
+import com.github.games647.fastlogin.bukkit.hook.DelayedAuthHook;
+import com.github.games647.fastlogin.bukkit.listener.ConnectionListener;
+import com.github.games647.fastlogin.bukkit.listener.PaperPreLoginListener;
+import com.github.games647.fastlogin.core.CommonUtil;
+import com.github.games647.fastlogin.core.PremiumStatus;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
 import com.github.games647.fastlogin.core.shared.FastLoginCore;
-import com.github.games647.fastlogin.core.shared.MojangApiConnector;
 import com.github.games647.fastlogin.core.shared.PlatformPlugin;
-import com.google.common.collect.Iterables;
-import com.google.common.io.ByteArrayDataOutput;
-import com.google.common.io.ByteStreams;
 
-import java.io.Reader;
-import java.security.KeyPair;
-import java.util.List;
+import io.papermc.lib.PaperLib;
+
+import java.nio.file.Path;
 import java.util.Map;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ThreadFactory;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
 
-import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
-import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
 import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.plugin.messaging.PluginMessageRecipient;
+import org.slf4j.Logger;
 
 /**
  * This plugin checks if a player has a paid account and if so tries to skip offline mode authentication.
  */
 public class FastLoginBukkit extends JavaPlugin implements PlatformPlugin<CommandSender> {
 
-    //provide a immutable key pair to be thread safe | used for encrypting and decrypting traffic
-    private final KeyPair keyPair = EncryptionUtil.generateKeyPair();
+    private final BukkitSessionManager sessionManager = new BukkitSessionManager();
+    private final Map<UUID, PremiumStatus> premiumPlayers = new ConcurrentHashMap<>();
+    private final FastLoginCore<Player, CommandSender, FastLoginBukkit> core = new FastLoginCore<>(this);
 
-    private boolean bungeeCord;
-    private FastLoginCore<Player, CommandSender, FastLoginBukkit> core;
-    private boolean serverStarted;
+    private final Logger logger;
+    private final BukkitScheduler scheduler;
 
-    //1 minutes should be enough as a timeout for bad internet connection (Server, Client and Mojang)
-    private final ConcurrentMap<String, BukkitLoginSession> loginSession = FastLoginCore.buildCache(1, -1);
+    private ProxyManager proxyManager;
+
+    private PremiumPlaceholder premiumPlaceholder;
+
+    public FastLoginBukkit() {
+        this.logger = CommonUtil.createLoggerFromJDK(getLogger());
+        this.scheduler = new BukkitScheduler(this, logger, getThreadFactory());
+    }
 
     @Override
     public void onEnable() {
-        core = new FastLoginCore<>(this);
         core.load();
-        try {
-            bungeeCord = Class.forName("org.spigotmc.SpigotConfig").getDeclaredField("bungee").getBoolean(null);
-        } catch (ClassNotFoundException notFoundEx) {
-            //ignore server has no bungee support
-        } catch (Exception ex) {
-            getLogger().log(Level.WARNING, "Cannot check bungeecord support. You use a non-spigot build", ex);
-        }
 
         if (getServer().getOnlineMode()) {
             //we need to require offline to prevent a loginSession request for a offline player
-            getLogger().severe("Server have to be in offline mode");
+            logger.error("Server has to be in offline mode");
             setEnabled(false);
             return;
         }
 
-        if (bungeeCord) {
-            setServerStarted();
-
-            //check for incoming messages from the bungeecord version of this plugin
-            getServer().getMessenger().registerIncomingPluginChannel(this, getName(), new BungeeCordListener(this));
-            getServer().getMessenger().registerOutgoingPluginChannel(this, getName());
-            //register listeners on success
-        } else {
+        proxyManager = new ProxyManager(this);
+        proxyManager.initialize();
+        
+        PluginManager pluginManager = getServer().getPluginManager();
+        if (!proxyManager.isEnabled()) {
             if (!core.setupDatabase()) {
                 setEnabled(false);
                 return;
             }
 
-            if (getServer().getPluginManager().isPluginEnabled("ProtocolSupport")) {
-                getServer().getPluginManager().registerEvents(new ProtocolSupportListener(this), this);
-            } else if (getServer().getPluginManager().isPluginEnabled("ProtocolLib")) {
-                //they will be created with a static builder, because otherwise it will throw a
-                //java.lang.NoClassDefFoundError: com/comphenix/protocol/events/PacketListener if ProtocolSupport was
-                //only found
-                ProtocolLibListener.register(this);
-
-                getServer().getPluginManager().registerEvents(new LoginSkinApplyListener(this), this);
+            if (pluginManager.isPluginEnabled("ProtocolSupport")) {
+                pluginManager.registerEvents(new ProtocolSupportListener(this, core.getRateLimiter()), this);
+            } else if (pluginManager.isPluginEnabled("ProtocolLib")) {
+                ProtocolLibListener.register(this, core.getRateLimiter());
             } else {
-                getLogger().warning("Either ProtocolLib or ProtocolSupport have to be installed "
-                        + "if you don't use BungeeCord");
+                logger.warn("Either ProtocolLib or ProtocolSupport have to be installed if you don't use proxies");
             }
         }
 
         //delay dependency setup because we load the plugin very early where plugins are initialized yet
         getServer().getScheduler().runTaskLater(this, new DelayedAuthHook(this), 5L);
 
-        getServer().getPluginManager().registerEvents(new BukkitJoinListener(this), this);
+        pluginManager.registerEvents(new ConnectionListener(this), this);
+
+        //if server is using paper - we need to add one more listener to correct the usercache usage
+        if (PaperLib.isPaper()) {
+            pluginManager.registerEvents(new PaperPreLoginListener(this), this);
+        }
 
         //register commands using a unique name
         getCommand("premium").setExecutor(new PremiumCommand(this));
         getCommand("cracked").setExecutor(new CrackedCommand(this));
 
-        if (getServer().getPluginManager().isPluginEnabled("PlaceholderAPI")) {
-            //prevents NoClassDef errors if it's not available
-            PremiumPlaceholder.register(this);
+        if (pluginManager.isPluginEnabled("PlaceholderAPI")) {
+            premiumPlaceholder = new PremiumPlaceholder(this);
+            premiumPlaceholder.register();
         }
     }
 
     @Override
     public void onDisable() {
-        loginSession.clear();
+        premiumPlayers.clear();
+        core.close();
 
-        if (core != null) {
-            core.close();
+        proxyManager.cleanup();
+        if (getServer().getPluginManager().isPluginEnabled("PlaceholderAPI") && premiumPlaceholder != null) {
+            premiumPlaceholder.unregister();
         }
-
-        //remove old blacklists
-        getServer().getOnlinePlayers().forEach(player -> player.removeMetadata(getName(), this));
     }
 
     public FastLoginCore<Player, CommandSender, FastLoginBukkit> getCore() {
         return core;
     }
 
-    public void sendBungeeActivateMessage(CommandSender sender, String target, boolean activate) {
-        if (sender instanceof Player) {
-            notifyBungeeCord((Player) sender, target, activate, sender instanceof Player);
-        } else {
-            Player firstPlayer = Iterables.getFirst(getServer().getOnlinePlayers(), null);
-            if (firstPlayer == null) {
-                getLogger().info("No player online to send a plugin message to the proxy");
-                return;
-            }
-
-            notifyBungeeCord(firstPlayer, target, activate, sender instanceof Player);
-        }
+    /**
+     * Fetches the premium status of an online player.
+     *
+     * @param onlinePlayer
+     * @return the online status or unknown if an error happened, the player isn't online or a proxy doesn't send
+     * us the status message yet (This means you cannot check the login status on the PlayerJoinEvent).
+     * @deprecated this method could be removed in future versions and exists only as a temporarily solution
+     */
+    @Deprecated
+    public PremiumStatus getStatus(UUID onlinePlayer) {
+        StoredProfile playSession = sessionManager.getPlaySession(onlinePlayer);
+        return Optional.ofNullable(playSession).map(profile -> {
+            if (profile.isPremium())
+                return PremiumStatus.PREMIUM;
+            return PremiumStatus.CRACKED;
+        }).orElse(PremiumStatus.UNKNOWN);
     }
 
     /**
@@ -144,77 +138,35 @@ public class FastLoginBukkit extends JavaPlugin implements PlatformPlugin<Comman
      *
      * @return a thread-safe loginSession map
      */
-    public ConcurrentMap<String, BukkitLoginSession> getLoginSessions() {
-        return loginSession;
+    public BukkitSessionManager getSessionManager() {
+        return sessionManager;
     }
 
-    /**
-     * Gets the server KeyPair. This is used to encrypt or decrypt traffic between the client and server
-     *
-     * @return the server KeyPair
-     */
-    public KeyPair getServerKey() {
-        return keyPair;
+    public Map<UUID, PremiumStatus> getPremiumPlayers() {
+        return premiumPlayers;
     }
 
-    public boolean isBungeeCord() {
-        return bungeeCord;
-    }
-
-    /**
-     * Wait before the server is fully started. This is workaround, because connections right on startup are not
-     * injected by ProtocolLib
-     *
-     * @return
-     */
-    public boolean isServerFullyStarted() {
-        return serverStarted;
-    }
-
-    public void setServerStarted() {
-        if (!this.serverStarted) {
-            this.serverStarted = true;
-        }
-    }
-
-    private void notifyBungeeCord(PluginMessageRecipient sender, String target, boolean activate, boolean isPlayer) {
-        ByteArrayDataOutput dataOutput = ByteStreams.newDataOutput();
-        if (activate) {
-            dataOutput.writeUTF("ON");
-        } else {
-            dataOutput.writeUTF("OFF");
-        }
-
-        dataOutput.writeUTF(target);
-        dataOutput.writeBoolean(isPlayer);
-        sender.sendPluginMessage(this, getName(), dataOutput.toByteArray());
+    public ProxyManager getProxyManager() {
+        return proxyManager;
     }
 
     @Override
-    public Map<String, Object> loadYamlFile(Reader reader) {
-        YamlConfiguration config = YamlConfiguration.loadConfiguration(reader);
-        return config.getValues(true);
+    public Path getPluginFolder() {
+        return getDataFolder().toPath();
+    }
+
+    @Override
+    public Logger getLog() {
+        return logger;
+    }
+
+    @Override
+    public BukkitScheduler getScheduler() {
+        return scheduler;
     }
 
     @Override
     public void sendMessage(CommandSender receiver, String message) {
         receiver.sendMessage(message);
     }
-
-    @Override
-    public String translateColorCodes(char colorChar, String rawMessage) {
-        return ChatColor.translateAlternateColorCodes(colorChar, rawMessage);
-    }
-
-    @Override
-    public ThreadFactory getThreadFactory() {
-        //not required here to make a custom thread factory
-        return null;
-    }
-
-    @Override
-    public MojangApiConnector makeApiConnector(Logger logger, List<String> addresses, int requests
-            , Map<String, Integer> proxies) {
-        return new MojangApiBukkit(logger, addresses, requests, proxies);
-    }
 }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/ForceLoginTask.java

@@ -0,0 +1,83 @@
+package com.github.games647.fastlogin.bukkit;
+
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.event.BukkitFastLoginAutoLoginEvent;
+import com.github.games647.fastlogin.core.PremiumStatus;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.message.SuccessMessage;
+import com.github.games647.fastlogin.core.shared.FastLoginCore;
+import com.github.games647.fastlogin.core.auth.ForceLoginManagement;
+import com.github.games647.fastlogin.core.auth.LoginSession;
+import com.github.games647.fastlogin.core.shared.event.FastLoginAutoLoginEvent;
+
+import java.util.concurrent.ExecutionException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.metadata.FixedMetadataValue;
+
+public class ForceLoginTask extends ForceLoginManagement<Player, CommandSender, BukkitLoginSession, FastLoginBukkit> {
+
+    public ForceLoginTask(FastLoginCore<Player, CommandSender, FastLoginBukkit> core, Player player,
+                          BukkitLoginSession session) {
+        super(core, player, session);
+    }
+
+    @Override
+    public void run() {
+        // block this target player for proxy ID brute force attacks
+        FastLoginBukkit plugin = core.getPlugin();
+        player.setMetadata(core.getPlugin().getName(), new FixedMetadataValue(plugin, true));
+
+        if (session != null && !session.getUsername().equals(player.getName())) {
+            String playerName = player.getName();
+            plugin.getLog().warn("Player username {} is not matching session {}", playerName, session.getUsername());
+            return;
+        }
+
+        super.run();
+
+        PremiumStatus status = PremiumStatus.CRACKED;
+        if (isOnlineMode()) {
+            status = PremiumStatus.PREMIUM;
+        }
+
+        plugin.getPremiumPlayers().put(player.getUniqueId(), status);
+    }
+
+    @Override
+    public FastLoginAutoLoginEvent callFastLoginAutoLoginEvent(LoginSession session, StoredProfile profile) {
+        BukkitFastLoginAutoLoginEvent event = new BukkitFastLoginAutoLoginEvent(session, profile);
+        core.getPlugin().getServer().getPluginManager().callEvent(event);
+        return event;
+    }
+
+    @Override
+    public void onForceActionSuccess(LoginSession session) {
+        if (core.getPlugin().getProxyManager().isEnabled()) {
+            core.getPlugin().getProxyManager().sendPluginMessage(player, new SuccessMessage());
+        }
+    }
+
+    @Override
+    public String getName(Player player) {
+        return player.getName();
+    }
+
+    @Override
+    public boolean isOnline(Player player) {
+        try {
+            //the player-list isn't thread-safe
+            return Bukkit.getScheduler().callSyncMethod(core.getPlugin(), player::isOnline).get();
+        } catch (InterruptedException | ExecutionException ex) {
+            core.getPlugin().getLog().error("Failed to perform thread-safe online check for {}", player, ex);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isOnlineMode() {
+        return session.isVerified();
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/MojangApiBukkit.java

@@ -1,91 +0,0 @@
-package com.github.games647.fastlogin.bukkit;
-
-import com.github.games647.fastlogin.core.shared.FastLoginCore;
-import com.github.games647.fastlogin.core.shared.LoginSession;
-import com.github.games647.fastlogin.core.shared.MojangApiConnector;
-
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.net.HttpURLConnection;
-import java.net.InetSocketAddress;
-import java.net.URLEncoder;
-import java.util.List;
-import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.json.simple.JSONArray;
-import org.json.simple.JSONObject;
-import org.json.simple.JSONValue;
-
-public class MojangApiBukkit extends MojangApiConnector {
-
-    //mojang api check to prove a player is logged in minecraft and made a join server request
-    private static final String HAS_JOINED_URL = "https://sessionserver.mojang.com/session/minecraft/hasJoined?" +
-            "username=%s&serverId=%s";
-
-    public MojangApiBukkit(Logger logger, List<String> localAddresses, int rateLimit, Map<String, Integer> proxies) {
-        super(logger, localAddresses, rateLimit, proxies);
-    }
-
-    @Override
-    public boolean hasJoinedServer(LoginSession session, String serverId, InetSocketAddress ip) {
-        BukkitLoginSession playerSession = (BukkitLoginSession) session;
-        try {
-            String url = String.format(HAS_JOINED_URL, playerSession.getUsername(), serverId);
-            if (ip != null) {
-                url += "&ip=" + URLEncoder.encode(ip.getAddress().getHostAddress(), "UTF-8");
-            }
-
-            HttpURLConnection conn = getConnection(url);
-
-            BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
-            String line = reader.readLine();
-            if (line != null && !"null".equals(line)) {
-                //validate parsing
-                //http://wiki.vg/Protocol_Encryption#Server
-                JSONObject userData = (JSONObject) JSONValue.parseWithException(line);
-                String uuid = (String) userData.get("id");
-                playerSession.setUuid(FastLoginCore.parseId(uuid));
-
-                JSONArray properties = (JSONArray) userData.get("properties");
-                JSONObject skinProperty = (JSONObject) properties.get(0);
-
-                String propertyName = (String) skinProperty.get("name");
-                if ("textures".equals(propertyName)) {
-                    String skinValue = (String) skinProperty.get("value");
-                    String signature = (String) skinProperty.get("signature");
-                    playerSession.setSkin(skinValue, signature);
-                }
-
-                return true;
-            }
-        } catch (Exception ex) {
-            //catch not only io-exceptions also parse and NPE on unexpected json format
-            logger.log(Level.WARNING, "Failed to verify session", ex);
-        }
-
-        //this connection doesn't need to be closed. So can make use of keep alive in java
-        return false;
-    }
-
-    @Override
-    protected String getUUIDFromJson(String json) {
-        boolean isArray = json.startsWith("[");
-
-        JSONObject mojangPlayer;
-        if (isArray) {
-            JSONArray array = (JSONArray) JSONValue.parse(json);
-            mojangPlayer = (JSONObject) array.get(0);
-        } else {
-            mojangPlayer = (JSONObject) JSONValue.parse(json);
-        }
-
-        String uuid = (String) mojangPlayer.get("id");
-        if ("null".equals(uuid)) {
-            return null;
-        }
-        
-        return uuid;
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/PremiumPlaceholder.java

@@ -1,14 +1,12 @@
 package com.github.games647.fastlogin.bukkit;
 
-import java.util.List;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 
-import me.clip.placeholderapi.PlaceholderAPI;
-import me.clip.placeholderapi.PlaceholderHook;
+import org.bukkit.OfflinePlayer;
 
-import org.bukkit.entity.Player;
-import org.bukkit.metadata.MetadataValue;
+public class PremiumPlaceholder extends PlaceholderExpansion {
 
-public class PremiumPlaceholder extends PlaceholderHook {
+    private static final String PLACEHOLDER_VARIABLE = "status";
 
     private final FastLoginBukkit plugin;
 
@@ -17,24 +15,32 @@ public class PremiumPlaceholder extends PlaceholderHook {
     }
 
     @Override
-    public String onPlaceholderRequest(Player player, String variable) {
-        if (player != null && "fastlogin_status".contains(variable)) {
-            List<MetadataValue> metadata = player.getMetadata(plugin.getName());
-            if (metadata == null) {
-                return "unknown";
-            }
-
-            if (!metadata.isEmpty()) {
-                return "premium";
-            } else {
-                return "cracked";
-            }
+    public String onRequest(OfflinePlayer player, String identifier) {
+        // player is null if offline
+        if (player != null && PLACEHOLDER_VARIABLE.equals(identifier)) {
+            return plugin.getStatus(player.getUniqueId()).getReadableName();
         }
 
         return null;
     }
 
-    public static boolean register(FastLoginBukkit plugin) {
-        return PlaceholderAPI.registerPlaceholderHook(plugin, new PremiumPlaceholder(plugin));
+    @Override
+    public String getIdentifier() {
+        return plugin.getName();
+    }
+
+    @Override
+    public String getRequiredPlugin() {
+        return plugin.getName();
+    }
+
+    @Override
+    public String getAuthor() {
+        return String.join(", ", plugin.getDescription().getAuthors());
+    }
+
+    @Override
+    public String getVersion() {
+        return plugin.getDescription().getVersion();
     }
 }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/BukkitLoginSession.java

@@ -0,0 +1,91 @@
+package com.github.games647.fastlogin.bukkit.auth;
+
+import com.github.games647.craftapi.model.skin.SkinProperty;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSession;
+
+import java.util.Optional;
+
+/**
+ * Represents a client connecting to the server.
+ *
+ * This session is invalid if the player disconnects or the login was successful
+ */
+public class BukkitLoginSession extends LoginSession {
+
+    private static final byte[] EMPTY_ARRAY = {};
+
+    private final String serverId;
+    private final byte[] verifyToken;
+
+    private boolean verified;
+
+    private SkinProperty skinProperty;
+
+    public BukkitLoginSession(String username, String serverId, byte[] verifyToken, boolean registered
+            , StoredProfile profile) {
+        super(username, registered, profile);
+
+        this.serverId = serverId;
+        this.verifyToken = verifyToken.clone();
+    }
+
+    // available for proxies
+    public BukkitLoginSession(String username, boolean registered) {
+        this(username, "", EMPTY_ARRAY, registered, null);
+    }
+
+    //cracked player
+    public BukkitLoginSession(String username, StoredProfile profile) {
+        this(username, "", EMPTY_ARRAY, false, profile);
+    }
+
+    //ProtocolSupport
+    public BukkitLoginSession(String username, boolean registered, StoredProfile profile) {
+        this(username, "", EMPTY_ARRAY, registered, profile);
+    }
+
+    /**
+     * Gets the verify token the server sent to the client.
+     *
+     * Empty if it's a proxy connection
+     *
+     * @return the verify token from the server
+     */
+    public synchronized byte[] getVerifyToken() {
+        return verifyToken.clone();
+    }
+
+    /**
+     * @return premium skin if available
+     */
+    public synchronized Optional<SkinProperty> getSkin() {
+        return Optional.ofNullable(skinProperty);
+    }
+
+    /**
+     * Sets the premium skin property which was retrieved by the session server
+     * @param skinProperty premium skin
+     */
+    public synchronized void setSkinProperty(SkinProperty skinProperty) {
+        this.skinProperty = skinProperty;
+    }
+
+    /**
+     * Sets whether the player has a premium (paid account) account and valid session
+     *
+     * @param verified whether the player has valid session
+     */
+    public synchronized void setVerified(boolean verified) {
+        this.verified = verified;
+    }
+
+    /**
+     * Get whether the player has a premium (paid account) account and valid session
+     *
+     * @return whether the player has a valid session
+     */
+    public synchronized boolean isVerified() {
+        return verified;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/EncryptionUtil.java

@@ -0,0 +1,131 @@
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
+
+import java.math.BigInteger;
+import java.nio.charset.StandardCharsets;
+import java.security.GeneralSecurityException;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.util.Random;
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+
+/**
+ * Encryption and decryption minecraft util for connection between servers
+ * and paid Minecraft account clients.
+ *
+ * @see net.minecraft.server.MinecraftEncryption
+ */
+public class EncryptionUtil {
+
+    public static final int VERIFY_TOKEN_LENGTH = 4;
+    public static final String KEY_PAIR_ALGORITHM = "RSA";
+
+    private EncryptionUtil() {
+        // utility
+    }
+
+    /**
+     * Generate a RSA key pair
+     *
+     * @return The RSA key pair.
+     */
+    public static KeyPair generateKeyPair() {
+        // KeyPair b()
+        try {
+            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_PAIR_ALGORITHM);
+
+            keyPairGenerator.initialize(1_024);
+            return keyPairGenerator.generateKeyPair();
+        } catch (NoSuchAlgorithmException nosuchalgorithmexception) {
+            // Should be existing in every vm
+            throw new ExceptionInInitializerError(nosuchalgorithmexception);
+        }
+    }
+
+    /**
+     * Generate a random token. This is used to verify that we are communicating with the same player
+     * in a login session.
+     *
+     * @param random random generator
+     * @return an error with 4 bytes long
+     */
+    public static byte[] generateVerifyToken(Random random) {
+        // extracted from LoginListener
+        byte[] token = new byte[VERIFY_TOKEN_LENGTH];
+        random.nextBytes(token);
+        return token;
+    }
+
+    /**
+     * Generate the server id based on client and server data.
+     *
+     * @param sessionId session for the current login attempt
+     * @param sharedSecret shared secret between the client and the server
+     * @param publicKey public key of the server
+     * @return the server id formatted as a hexadecimal string.
+     */
+    public static String getServerIdHashString(String sessionId, SecretKey sharedSecret, PublicKey publicKey) {
+        // found in LoginListener
+        try {
+            byte[] serverHash = getServerIdHash(sessionId, publicKey, sharedSecret);
+            return (new BigInteger(serverHash)).toString(16);
+        } catch (NoSuchAlgorithmException e) {
+            e.printStackTrace();
+        }
+
+        return "";
+    }
+
+    /**
+     * Decrypts the content and extracts the key spec.
+     *
+     * @param privateKey private server key
+     * @param sharedKey the encrypted shared key
+     * @return shared secret key
+     * @throws GeneralSecurityException if it fails to decrypt the data
+     */
+    public static SecretKey decryptSharedKey(PrivateKey privateKey, byte[] sharedKey) throws GeneralSecurityException {
+        // SecretKey a(PrivateKey var0, byte[] var1)
+        return new SecretKeySpec(decrypt(privateKey, sharedKey), "AES");
+    }
+
+    public static byte[] decrypt(PrivateKey key, byte[] data) throws GeneralSecurityException {
+        // b(Key var0, byte[] var1)
+        Cipher cipher = Cipher.getInstance(key.getAlgorithm());
+        cipher.init(Cipher.DECRYPT_MODE, key);
+        return decrypt(cipher, data);
+    }
+
+    /**
+     * Decrypted the given data using the cipher.
+     *
+     * @param cipher decryption cypher initialized with the private key
+     * @param data the encrypted data
+     * @return clear text data
+     * @throws GeneralSecurityException if it fails to decrypt the data
+     */
+    private static byte[] decrypt(Cipher cipher, byte[] data) throws GeneralSecurityException {
+        // inlined: byte[] a(int var0, Key var1, byte[] var2), Cipher a(int var0, String var1, Key
+        // var2)
+        return cipher.doFinal(data);
+    }
+
+    private static byte[] getServerIdHash(
+            String sessionId, PublicKey publicKey, SecretKey sharedSecret)
+            throws NoSuchAlgorithmException {
+        // byte[] a(String var0, PublicKey var1, SecretKey var2)
+        MessageDigest digest = MessageDigest.getInstance("SHA-1");
+
+        // inlined from byte[] a(String var0, byte[]... var1)
+        digest.update(sessionId.getBytes(StandardCharsets.ISO_8859_1));
+        digest.update(sharedSecret.getEncoded());
+        digest.update(publicKey.getEncoded());
+
+        return digest.digest();
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/InitializedListener.java

@@ -0,0 +1,23 @@
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerLoginEvent.Result;
+
+public class InitializedListener implements Listener {
+
+    private final ProtocolLibListener module;
+
+    protected InitializedListener(ProtocolLibListener protocolLibModule) {
+        this.module = protocolLibModule;
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onPlayerLogin(PlayerLoginEvent loginEvent) {
+        if (loginEvent.getResult() == Result.ALLOWED && !module.isReadyToInject()) {
+            loginEvent.disallow(Result.KICK_OTHER, module.getPlugin().getCore().getMessage("not-started"));
+        }
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/NameCheckTask.java

@@ -1,14 +1,16 @@
-package com.github.games647.fastlogin.bukkit.listener.protocollib;
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
 
 import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.events.PacketEvent;
-import com.github.games647.fastlogin.bukkit.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
 import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.core.PlayerProfile;
-import com.github.games647.fastlogin.core.shared.JoinManagement;
+import com.github.games647.fastlogin.bukkit.event.BukkitFastLoginPreLoginEvent;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.JoinManagement;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPreLoginEvent;
 
+import java.security.PublicKey;
 import java.util.Random;
-import java.util.logging.Level;
 
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -18,17 +20,20 @@ public class NameCheckTask extends JoinManagement<Player, CommandSender, Protoco
 
     private final FastLoginBukkit plugin;
     private final PacketEvent packetEvent;
+    private final PublicKey publicKey;
 
     private final Random random;
 
     private final Player player;
     private final String username;
 
-    public NameCheckTask(FastLoginBukkit plugin, PacketEvent packetEvent, Random random, Player player, String username) {
+    protected NameCheckTask(FastLoginBukkit plugin, PacketEvent packetEvent, Random random,
+                         Player player, String username, PublicKey publicKey) {
         super(plugin.getCore(), plugin.getCore().getAuthPluginHook());
 
         this.plugin = plugin;
         this.packetEvent = packetEvent;
+        this.publicKey = publicKey;
         this.random = random;
         this.player = player;
         this.username = username;
@@ -37,20 +42,28 @@ public class NameCheckTask extends JoinManagement<Player, CommandSender, Protoco
     @Override
     public void run() {
         try {
-            super.onLogin(username, new ProtocolLibLoginSource(plugin, packetEvent, player, random));
+            super.onLogin(username, new ProtocolLibLoginSource(packetEvent, player, random, publicKey));
         } finally {
             ProtocolLibrary.getProtocolManager().getAsynchronousManager().signalPacketTransmission(packetEvent);
         }
     }
 
-    //minecraft server implementation
+    @Override
+    public FastLoginPreLoginEvent callFastLoginPreLoginEvent(String username, ProtocolLibLoginSource source, StoredProfile profile) {
+        BukkitFastLoginPreLoginEvent event = new BukkitFastLoginPreLoginEvent(username, source, profile);
+        plugin.getServer().getPluginManager().callEvent(event);
+        return event;
+    }
+
+    //Minecraft server implementation
     //https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/LoginListener.java#L161
     @Override
-    public void requestPremiumLogin(ProtocolLibLoginSource source, PlayerProfile profile, String username, boolean registered) {
+    public void requestPremiumLogin(ProtocolLibLoginSource source, StoredProfile profile
+            , String username, boolean registered) {
         try {
             source.setOnlineMode();
         } catch (Exception ex) {
-            plugin.getLogger().log(Level.SEVERE, "Cannot send encryption packet. Falling back to cracked login", ex);
+            plugin.getLog().error("Cannot send encryption packet. Falling back to cracked login for: {}", profile, ex);
             return;
         }
 
@@ -61,7 +74,7 @@ public class NameCheckTask extends JoinManagement<Player, CommandSender, Protoco
         byte[] verify = source.getVerifyToken();
 
         BukkitLoginSession playerSession = new BukkitLoginSession(username, serverId, verify, registered, profile);
-        plugin.getLoginSessions().put(player.getAddress().toString(), playerSession);
+        plugin.getSessionManager().startLoginSession(player.getAddress(), playerSession);
         //cancel only if the player has a paid account otherwise login as normal offline player
         synchronized (packetEvent.getAsyncMarker().getProcessingLock()) {
             packetEvent.setCancelled(true);
@@ -69,8 +82,8 @@ public class NameCheckTask extends JoinManagement<Player, CommandSender, Protoco
     }
 
     @Override
-    public void startCrackedSession(ProtocolLibLoginSource source, PlayerProfile profile, String username) {
+    public void startCrackedSession(ProtocolLibLoginSource source, StoredProfile profile, String username) {
         BukkitLoginSession loginSession = new BukkitLoginSession(username, profile);
-        plugin.getLoginSessions().put(player.getAddress().toString(), loginSession);
+        plugin.getSessionManager().startLoginSession(player.getAddress(), loginSession);
     }
 }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/ProtocolLibListener.java

@@ -0,0 +1,124 @@
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.events.PacketAdapter;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.core.auth.RateLimiter;
+
+import io.papermc.lib.PaperLib;
+
+import java.security.KeyPair;
+import java.security.SecureRandom;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
+
+import static com.comphenix.protocol.PacketType.Login.Client.ENCRYPTION_BEGIN;
+import static com.comphenix.protocol.PacketType.Login.Client.START;
+
+public class ProtocolLibListener extends PacketAdapter {
+
+    private final FastLoginBukkit plugin;
+
+    //just create a new once on plugin enable. This used for verify token generation
+    private final SecureRandom random = new SecureRandom();
+    private final KeyPair keyPair = EncryptionUtil.generateKeyPair();
+    private final RateLimiter rateLimiter;
+
+    // Wait before the server is fully started. This is workaround, because connections right on startup are not
+    // injected by ProtocolLib
+    private boolean serverStarted;
+
+    protected ProtocolLibListener(FastLoginBukkit plugin, RateLimiter rateLimiter) {
+        //run async in order to not block the server, because we are making api calls to Mojang
+        super(params()
+                .plugin(plugin)
+                .types(START, ENCRYPTION_BEGIN)
+                .optionAsync());
+
+        this.plugin = plugin;
+        this.rateLimiter = rateLimiter;
+    }
+
+    public static void register(FastLoginBukkit plugin, RateLimiter rateLimiter) {
+        //they will be created with a static builder, because otherwise it will throw a NoClassDefFoundError
+        ProtocolLibListener packetListener = new ProtocolLibListener(plugin, rateLimiter);
+        ProtocolLibrary.getProtocolManager()
+                .getAsynchronousManager()
+                .registerAsyncHandler(packetListener)
+                .start();
+
+        PluginManager pluginManager = Bukkit.getServer().getPluginManager();
+        pluginManager.registerEvents(new InitializedListener(packetListener), plugin);
+
+        //if server is using paper - we need to set the skin at pre login anyway, so no need for this listener
+        if (!PaperLib.isPaper() && plugin.getConfig().getBoolean("forwardSkin")) {
+            pluginManager.registerEvents(new SkinApplyListener(plugin), plugin);
+        }
+    }
+
+    @Override
+    public void onPacketReceiving(PacketEvent packetEvent) {
+        if (packetEvent.isCancelled() || plugin.getCore().getAuthPluginHook() == null) {
+            return;
+        }
+
+        markReadyToInject();
+
+        Player sender = packetEvent.getPlayer();
+        PacketType packetType = packetEvent.getPacketType();
+        if (packetType == START) {
+            if (!rateLimiter.tryAcquire()) {
+                plugin.getLog().warn("Join limit hit - Ignoring player {}", sender);
+                return;
+            }
+
+            onLogin(packetEvent, sender);
+        } else {
+            onEncryptionBegin(packetEvent, sender);
+        }
+    }
+
+    private void onEncryptionBegin(PacketEvent packetEvent, Player sender) {
+        byte[] sharedSecret = packetEvent.getPacket().getByteArrays().read(0);
+
+        packetEvent.getAsyncMarker().incrementProcessingDelay();
+        Runnable verifyTask = new VerifyResponseTask(plugin, packetEvent, sender, sharedSecret, keyPair);
+        plugin.getScheduler().runAsync(verifyTask);
+    }
+
+    private void onLogin(PacketEvent packetEvent, Player player) {
+        //this includes ip:port. Should be unique for an incoming login request with a timeout of 2 minutes
+        String sessionKey = player.getAddress().toString();
+
+        //remove old data every time on a new login in order to keep the session only for one person
+        plugin.getSessionManager().endLoginSession(player.getAddress());
+
+        //player.getName() won't work at this state
+        PacketContainer packet = packetEvent.getPacket();
+
+        String username = packet.getGameProfiles().read(0).getName();
+        plugin.getLog().trace("GameProfile {} with {} connecting", sessionKey, username);
+
+        packetEvent.getAsyncMarker().incrementProcessingDelay();
+        Runnable nameCheckTask = new NameCheckTask(plugin, packetEvent, random, player, username, keyPair.getPublic());
+        plugin.getScheduler().runAsync(nameCheckTask);
+    }
+
+    public void markReadyToInject() {
+        this.serverStarted = true;
+    }
+
+    public boolean isReadyToInject() {
+        return serverStarted;
+    }
+
+    @Override
+    public FastLoginBukkit getPlugin() {
+        return plugin;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/ProtocolLibLoginSource.java

@@ -0,0 +1,108 @@
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
+
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.ProtocolManager;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.reflect.StructureModifier;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
+import com.github.games647.fastlogin.core.auth.LoginSource;
+
+import java.lang.reflect.InvocationTargetException;
+import java.net.InetSocketAddress;
+import java.security.PublicKey;
+import java.util.Arrays;
+import java.util.Random;
+
+import org.bukkit.entity.Player;
+
+import static com.comphenix.protocol.PacketType.Login.Server.DISCONNECT;
+import static com.comphenix.protocol.PacketType.Login.Server.ENCRYPTION_BEGIN;
+
+class ProtocolLibLoginSource implements LoginSource {
+
+    private final PacketEvent packetEvent;
+    private final Player player;
+
+    private final Random random;
+    private final PublicKey publicKey;
+
+    private final String serverId = "";
+    private byte[] verifyToken;
+
+    protected ProtocolLibLoginSource(PacketEvent packetEvent, Player player, Random random, PublicKey publicKey) {
+        this.packetEvent = packetEvent;
+        this.player = player;
+        this.random = random;
+        this.publicKey = publicKey;
+    }
+
+    @Override
+    public void setOnlineMode() throws Exception {
+        verifyToken = EncryptionUtil.generateVerifyToken(random);
+
+        /*
+         * Packet Information: https://wiki.vg/Protocol#Encryption_Request
+         *
+         * ServerID="" (String) key=public server key verifyToken=random 4 byte array
+         */
+        PacketContainer newPacket = new PacketContainer(ENCRYPTION_BEGIN);
+
+        newPacket.getStrings().write(0, serverId);
+        StructureModifier<PublicKey> keyModifier = newPacket.getSpecificModifier(PublicKey.class);
+        int verifyField = 0;
+        if (keyModifier.getFields().isEmpty()) {
+            // Since 1.16.4 this is now a byte field
+            newPacket.getByteArrays().write(0, publicKey.getEncoded());
+            verifyField++;
+        } else {
+            keyModifier.write(0, publicKey);
+        }
+
+        newPacket.getByteArrays().write(verifyField, verifyToken);
+
+        //serverId is a empty string
+        ProtocolLibrary.getProtocolManager().sendServerPacket(player, newPacket);
+    }
+
+    @Override
+    public void kick(String message) throws InvocationTargetException {
+        ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
+
+        PacketContainer kickPacket = new PacketContainer(DISCONNECT);
+        kickPacket.getChatComponents().write(0, WrappedChatComponent.fromText(message));
+
+        try {
+            //send kick packet at login state
+            //the normal event.getPlayer.kickPlayer(String) method does only work at play state
+            protocolManager.sendServerPacket(player, kickPacket);
+        } finally {
+            //tell the server that we want to close the connection
+            player.kickPlayer("Disconnect");
+        }
+    }
+
+    @Override
+    public InetSocketAddress getAddress() {
+        return packetEvent.getPlayer().getAddress();
+    }
+
+    public String getServerId() {
+        return serverId;
+    }
+
+    public byte[] getVerifyToken() {
+        return verifyToken.clone();
+    }
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + '{' +
+                "packetEvent=" + packetEvent +
+                ", player=" + player +
+                ", random=" + random +
+                ", serverId='" + serverId + '\'' +
+                ", verifyToken=" + Arrays.toString(verifyToken) +
+                '}';
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/SkinApplyListener.java

@@ -0,0 +1,52 @@
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
+
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.WrappedGameProfile;
+import com.comphenix.protocol.wrappers.WrappedSignedProperty;
+import com.github.games647.craftapi.model.skin.Textures;
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerLoginEvent.Result;
+
+public class SkinApplyListener implements Listener {
+
+    private static final Class<?> GAME_PROFILE = MinecraftReflection.getGameProfileClass();
+    private static final MethodAccessor GET_PROPERTIES = Accessors.getMethodAccessor(GAME_PROFILE, "getProperties");
+
+    private final FastLoginBukkit plugin;
+
+    protected SkinApplyListener(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.LOW)
+    //run this on the loginEvent to let skins plugins see the skin like in normal Minecraft behaviour
+    public void onPlayerLogin(PlayerLoginEvent loginEvent) {
+        if (loginEvent.getResult() != Result.ALLOWED) {
+            return;
+        }
+
+        Player player = loginEvent.getPlayer();
+
+        //go through every session, because player.getAddress is null
+        //loginEvent.getAddress is just a InetAddress not InetSocketAddress, so not unique enough
+        BukkitLoginSession session = plugin.getSessionManager().getLoginSession(player.getAddress());
+        if (session.getUsername().equals(player.getName())) {
+            session.getSkin().ifPresent(skin -> applySkin(player, skin.getValue(), skin.getSignature()));
+        }
+    }
+
+    private void applySkin(Player player, String skinData, String signature) {
+        WrappedGameProfile gameProfile = WrappedGameProfile.fromPlayer(player);
+        WrappedSignedProperty skin = WrappedSignedProperty.fromValues(Textures.KEY, skinData, signature);
+        gameProfile.getProperties().put(Textures.KEY, skin);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocollib/VerifyResponseTask.java

@@ -0,0 +1,264 @@
+package com.github.games647.fastlogin.bukkit.auth.protocollib;
+
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.injector.server.TemporaryPlayerFactory;
+import com.comphenix.protocol.reflect.FieldUtils;
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
+import com.comphenix.protocol.wrappers.WrappedGameProfile;
+import com.github.games647.craftapi.model.auth.Verification;
+import com.github.games647.craftapi.model.skin.SkinProperty;
+import com.github.games647.craftapi.resolver.MojangResolver;
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.security.GeneralSecurityException;
+import java.security.Key;
+import java.security.KeyPair;
+import java.security.PrivateKey;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.UUID;
+
+import javax.crypto.Cipher;
+import javax.crypto.SecretKey;
+
+import org.bukkit.entity.Player;
+
+import static com.comphenix.protocol.PacketType.Login.Client.START;
+import static com.comphenix.protocol.PacketType.Login.Server.DISCONNECT;
+
+public class VerifyResponseTask implements Runnable {
+
+    private final FastLoginBukkit plugin;
+    private final PacketEvent packetEvent;
+    private final KeyPair serverKey;
+
+    private final Player player;
+
+    private final byte[] sharedSecret;
+
+    private static Method encryptMethod;
+    private static Method cipherMethod;
+
+    protected VerifyResponseTask(FastLoginBukkit plugin, PacketEvent packetEvent, Player player,
+                              byte[] sharedSecret, KeyPair keyPair) {
+        this.plugin = plugin;
+        this.packetEvent = packetEvent;
+        this.player = player;
+        this.sharedSecret = Arrays.copyOf(sharedSecret, sharedSecret.length);
+        this.serverKey = keyPair;
+    }
+
+    @Override
+    public void run() {
+        try {
+            BukkitLoginSession session = plugin.getSessionManager().getLoginSession(player.getAddress());
+            if (session == null) {
+                disconnect("invalid-request", true
+                        , "GameProfile {0} tried to send encryption response at invalid state", player.getAddress());
+            } else {
+                verifyResponse(session);
+            }
+        } finally {
+            //this is a fake packet; it shouldn't be send to the server
+            synchronized (packetEvent.getAsyncMarker().getProcessingLock()) {
+                packetEvent.setCancelled(true);
+            }
+
+            ProtocolLibrary.getProtocolManager().getAsynchronousManager().signalPacketTransmission(packetEvent);
+        }
+    }
+
+    private void verifyResponse(BukkitLoginSession session) {
+        PrivateKey privateKey = serverKey.getPrivate();
+
+        SecretKey loginKey;
+        try {
+            loginKey = EncryptionUtil.decryptSharedKey(privateKey, sharedSecret);
+        } catch (GeneralSecurityException securityEx) {
+            disconnect("error-kick", false, "Cannot decrypt received contents", securityEx);
+            return;
+        }
+
+        try {
+            if (!checkVerifyToken(session) || !enableEncryption(loginKey)) {
+                return;
+            }
+        } catch (Exception ex) {
+            disconnect("error-kick", false, "Cannot decrypt received contents", ex);
+            return;
+        }
+
+        String serverId = EncryptionUtil.getServerIdHashString("", loginKey, serverKey.getPublic());
+
+        String requestedUsername = session.getRequestUsername();
+        InetSocketAddress socketAddress = player.getAddress();
+        try {
+            MojangResolver resolver = plugin.getCore().getResolver();
+            InetAddress address = socketAddress.getAddress();
+            Optional<Verification> response = resolver.hasJoined(requestedUsername, serverId, address);
+            if (response.isPresent()) {
+                Verification verification = response.get();
+                plugin.getLog().info("Profile {} has a verified premium account: {}", requestedUsername, verification);
+                String realUsername = verification.getName();
+                if (realUsername == null) {
+                    disconnect("invalid-session", true, "Username field null for {}", requestedUsername);
+                    return;
+                }
+
+                SkinProperty[] properties = verification.getProperties();
+                if (properties.length > 0) {
+                    session.setSkinProperty(properties[0]);
+                }
+
+                session.setVerifiedUsername(realUsername);
+                session.setUuid(verification.getId());
+                session.setVerified(true);
+
+                setPremiumUUID(session.getUuid());
+                receiveFakeStartPacket(realUsername);
+            } else {
+                //user tried to fake a authentication
+                disconnect("invalid-session", true
+                        , "GameProfile {0} ({1}) tried to log in with an invalid session ServerId: {2}"
+                        , session.getRequestUsername(), socketAddress, serverId);
+            }
+        } catch (IOException ioEx) {
+            disconnect("error-kick", false, "Failed to connect to session server", ioEx);
+        }
+    }
+
+    private void setPremiumUUID(UUID premiumUUID) {
+        if (plugin.getConfig().getBoolean("premiumUuid") && premiumUUID != null) {
+            try {
+                Object networkManager = getNetworkManager();
+                //https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/NetworkManager.java#L69
+                FieldUtils.writeField(networkManager, "spoofedUUID", premiumUUID, true);
+            } catch (Exception exc) {
+                plugin.getLog().error("Error setting premium uuid of {}", player, exc);
+            }
+        }
+    }
+
+    private boolean checkVerifyToken(BukkitLoginSession session) throws GeneralSecurityException {
+        byte[] requestVerify = session.getVerifyToken();
+        //encrypted verify token
+        byte[] responseVerify = packetEvent.getPacket().getByteArrays().read(1);
+
+        //https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/LoginListener.java#L182
+        if (!Arrays.equals(requestVerify, EncryptionUtil.decrypt(serverKey.getPrivate(), responseVerify))) {
+            //check if the verify token are equal to the server sent one
+            disconnect("invalid-verify-token", true
+                    , "GameProfile {0} ({1}) tried to login with an invalid verify token. Server: {2} Client: {3}"
+                    , session.getRequestUsername(), packetEvent.getPlayer().getAddress(), requestVerify, responseVerify);
+            return false;
+        }
+
+        return true;
+    }
+
+    //try to get the networkManager from ProtocolLib
+    private Object getNetworkManager() throws IllegalAccessException, ClassNotFoundException {
+        Object injectorContainer = TemporaryPlayerFactory.getInjectorFromPlayer(player);
+
+        //ChannelInjector
+        Class<?> injectorClass = Class.forName("com.comphenix.protocol.injector.netty.Injector");
+        Object rawInjector = FuzzyReflection.getFieldValue(injectorContainer, injectorClass, true);
+        return FieldUtils.readField(rawInjector, "networkManager", true);
+    }
+
+    private boolean enableEncryption(SecretKey loginKey) throws IllegalArgumentException {
+        // Initialize method reflections
+        if (encryptMethod == null) {
+            Class<?> networkManagerClass = MinecraftReflection.getNetworkManagerClass();
+
+            try {
+                // Try to get the old (pre MC 1.16.4) encryption method
+                encryptMethod = FuzzyReflection.fromClass(networkManagerClass)
+                        .getMethodByParameters("a", SecretKey.class);
+            } catch (IllegalArgumentException exception) {
+                // Get the new encryption method
+                encryptMethod = FuzzyReflection.fromClass(networkManagerClass)
+                        .getMethodByParameters("a", Cipher.class, Cipher.class);
+
+                // Get the needed Cipher helper method (used to generate ciphers from login key)
+                Class<?> encryptionClass = MinecraftReflection.getMinecraftClass("MinecraftEncryption");
+                cipherMethod = FuzzyReflection.fromClass(encryptionClass)
+                        .getMethodByParameters("a", int.class, Key.class);
+            }
+        }
+
+        try {
+            Object networkManager = this.getNetworkManager();
+
+            // If cipherMethod is null - use old encryption (pre MC 1.16.4), otherwise use the new cipher one
+            if (cipherMethod == null) {
+                // Encrypt/decrypt packet flow, this behaviour is expected by the client
+                encryptMethod.invoke(networkManager, loginKey);
+            } else {
+                // Create ciphers from login key
+                Object decryptionCipher = cipherMethod.invoke(null, Cipher.DECRYPT_MODE, loginKey);
+                Object encryptionCipher = cipherMethod.invoke(null, Cipher.ENCRYPT_MODE, loginKey);
+
+                // Encrypt/decrypt packet flow, this behaviour is expected by the client
+                encryptMethod.invoke(networkManager, decryptionCipher, encryptionCipher);
+            }
+        } catch (Exception ex) {
+            disconnect("error-kick", false, "Couldn't enable encryption", ex);
+            return false;
+        }
+
+        return true;
+    }
+
+    private void disconnect(String reasonKey, boolean debug, String logMessage, Object... arguments) {
+        if (debug) {
+            plugin.getLog().debug(logMessage, arguments);
+        } else {
+            plugin.getLog().error(logMessage, arguments);
+        }
+
+        kickPlayer(plugin.getCore().getMessage(reasonKey));
+    }
+
+    private void kickPlayer(String reason) {
+        PacketContainer kickPacket = new PacketContainer(DISCONNECT);
+        kickPacket.getChatComponents().write(0, WrappedChatComponent.fromText(reason));
+        try {
+            //send kick packet at login state
+            //the normal event.getPlayer.kickPlayer(String) method does only work at play state
+            ProtocolLibrary.getProtocolManager().sendServerPacket(player, kickPacket);
+            //tell the server that we want to close the connection
+            player.kickPlayer("Disconnect");
+        } catch (InvocationTargetException ex) {
+            plugin.getLog().error("Error sending kick packet for: {}", player, ex);
+        }
+    }
+
+    //fake a new login packet in order to let the server handle all the other stuff
+    private void receiveFakeStartPacket(String username) {
+        //see StartPacketListener for packet information
+        PacketContainer startPacket = new PacketContainer(START);
+
+        //uuid is ignored by the packet definition
+        WrappedGameProfile fakeProfile = new WrappedGameProfile(UUID.randomUUID(), username);
+        startPacket.getGameProfiles().write(0, fakeProfile);
+        try {
+            //we don't want to handle our own packets so ignore filters
+            ProtocolLibrary.getProtocolManager().recieveClientPacket(player, startPacket, false);
+        } catch (InvocationTargetException | IllegalAccessException ex) {
+            plugin.getLog().warn("Failed to fake a new start packet for: {}", username, ex);
+            //cancel the event in order to prevent the server receiving an invalid packet
+            kickPlayer(plugin.getCore().getMessage("error-kick"));
+        }
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocolsupport/ProtocolLoginSource.java

@@ -1,6 +1,6 @@
-package com.github.games647.fastlogin.bukkit.listener.protocolsupport;
+package com.github.games647.fastlogin.bukkit.auth.protocolsupport;
 
-import com.github.games647.fastlogin.core.shared.LoginSource;
+import com.github.games647.fastlogin.core.auth.LoginSource;
 
 import java.net.InetSocketAddress;
 
@@ -10,7 +10,7 @@ public class ProtocolLoginSource implements LoginSource {
 
     private final PlayerLoginStartEvent loginStartEvent;
 
-    public ProtocolLoginSource(PlayerLoginStartEvent loginStartEvent) {
+    protected ProtocolLoginSource(PlayerLoginStartEvent loginStartEvent) {
         this.loginStartEvent = loginStartEvent;
     }
 
@@ -32,4 +32,11 @@ public class ProtocolLoginSource implements LoginSource {
     public PlayerLoginStartEvent getLoginStartEvent() {
         return loginStartEvent;
     }
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + '{' +
+                "loginStartEvent=" + loginStartEvent +
+                '}';
+    }
 }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/protocolsupport/ProtocolSupportListener.java

@@ -0,0 +1,102 @@
+package com.github.games647.fastlogin.bukkit.auth.protocolsupport;
+
+import com.github.games647.craftapi.UUIDAdapter;
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.bukkit.event.BukkitFastLoginPreLoginEvent;
+import com.github.games647.fastlogin.core.auth.RateLimiter;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.JoinManagement;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPreLoginEvent;
+
+import java.net.InetSocketAddress;
+import java.util.Optional;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import protocolsupport.api.events.ConnectionCloseEvent;
+import protocolsupport.api.events.PlayerLoginStartEvent;
+import protocolsupport.api.events.PlayerProfileCompleteEvent;
+
+public class ProtocolSupportListener extends JoinManagement<Player, CommandSender, ProtocolLoginSource>
+        implements Listener {
+
+    private final FastLoginBukkit plugin;
+    private final RateLimiter rateLimiter;
+
+    public ProtocolSupportListener(FastLoginBukkit plugin, RateLimiter rateLimiter) {
+        super(plugin.getCore(), plugin.getCore().getAuthPluginHook());
+
+        this.plugin = plugin;
+        this.rateLimiter = rateLimiter;
+    }
+
+    @EventHandler
+    public void onLoginStart(PlayerLoginStartEvent loginStartEvent) {
+        if (loginStartEvent.isLoginDenied() || plugin.getCore().getAuthPluginHook() == null) {
+            return;
+        }
+
+        if (!rateLimiter.tryAcquire()) {
+            plugin.getLog().warn("Join limit hit - Ignoring player {}", loginStartEvent.getConnection());
+            return;
+        }
+
+        String username = loginStartEvent.getConnection().getProfile().getName();
+        InetSocketAddress address = loginStartEvent.getAddress();
+
+        //remove old data every time on a new login in order to keep the session only for one person
+        plugin.getSessionManager().endLoginSession(address);
+
+        super.onLogin(username, new ProtocolLoginSource(loginStartEvent));
+    }
+
+    @EventHandler
+    public void onConnectionClosed(ConnectionCloseEvent closeEvent) {
+        InetSocketAddress address = closeEvent.getConnection().getAddress();
+        plugin.getSessionManager().endLoginSession(address);
+    }
+
+    @EventHandler
+    public void onPropertiesResolve(PlayerProfileCompleteEvent profileCompleteEvent) {
+        InetSocketAddress address = profileCompleteEvent.getAddress();
+        BukkitLoginSession session = plugin.getSessionManager().getLoginSession(address);
+
+        if (session != null && profileCompleteEvent.getConnection().getProfile().isOnlineMode()) {
+            session.setVerified(true);
+
+            if (!plugin.getConfig().getBoolean("premiumUuid")) {
+                String username = Optional.ofNullable(profileCompleteEvent.getForcedName())
+                        .orElse(profileCompleteEvent.getConnection().getProfile().getName());
+                profileCompleteEvent.setForcedUUID(UUIDAdapter.generateOfflineId(username));
+            }
+        }
+    }
+
+    @Override
+    public FastLoginPreLoginEvent callFastLoginPreLoginEvent(String username, ProtocolLoginSource source, StoredProfile profile) {
+        BukkitFastLoginPreLoginEvent event = new BukkitFastLoginPreLoginEvent(username, source, profile);
+        plugin.getServer().getPluginManager().callEvent(event);
+        return event;
+    }
+
+    @Override
+    public void requestPremiumLogin(ProtocolLoginSource source, StoredProfile profile, String username
+            , boolean registered) {
+        source.setOnlineMode();
+
+        String ip = source.getAddress().getAddress().getHostAddress();
+        plugin.getCore().getPendingLogin().put(ip + username, new Object());
+
+        BukkitLoginSession playerSession = new BukkitLoginSession(username, registered, profile);
+        plugin.getSessionManager().startLoginSession(source.getAddress(), playerSession);
+    }
+
+    @Override
+    public void startCrackedSession(ProtocolLoginSource source, StoredProfile profile, String username) {
+        BukkitLoginSession loginSession = new BukkitLoginSession(username, profile);
+        plugin.getSessionManager().startLoginSession(source.getAddress(), loginSession);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/proxy/ProxyManager.java

@@ -0,0 +1,169 @@
+package com.github.games647.fastlogin.bukkit.auth.proxy;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.core.message.ChannelMessage;
+import com.github.games647.fastlogin.core.message.LoginActionMessage;
+import com.github.games647.fastlogin.core.message.NamespaceKey;
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageRecipient;
+
+import static com.github.games647.fastlogin.core.message.ChangePremiumMessage.CHANGE_CHANNEL;
+import static com.github.games647.fastlogin.core.message.SuccessMessage.SUCCESS_CHANNEL;
+import static java.util.stream.Collectors.toSet;
+
+public class ProxyManager {
+
+    private static final String LEGACY_FILE_NAME = "proxy-whitelist.txt";
+    private static final String FILE_NAME = "allowed-proxies.txt";
+
+    //null if proxies allowed list is empty so proxy support is disabled
+    private Set<UUID> proxyIds;
+
+    private final FastLoginBukkit plugin;
+    private boolean enabled;
+
+    private final Set<UUID> firedJoinEvents = new HashSet<>();
+
+    public ProxyManager(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    public void cleanup() {
+        //remove old blocked status
+        Bukkit.getOnlinePlayers().forEach(player -> player.removeMetadata(plugin.getName(), plugin));
+    }
+
+    public void sendPluginMessage(PluginMessageRecipient player, ChannelMessage message) {
+        if (player != null) {
+            ByteArrayDataOutput dataOutput = ByteStreams.newDataOutput();
+            message.writeTo(dataOutput);
+
+            NamespaceKey channel = new NamespaceKey(plugin.getName(), message.getChannelName());
+            player.sendPluginMessage(plugin, channel.getCombinedName(), dataOutput.toByteArray());
+        }
+    }
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void initialize() {
+        try {
+            enabled = detectProxy();
+        } catch (Exception ex) {
+            plugin.getLog().warn("Cannot check proxy support. Fallback to non-proxy mode", ex);
+        }
+
+        if (enabled) {
+            proxyIds = loadProxyIds();
+            registerPluginChannels();
+        }
+    }
+
+    private boolean detectProxy() throws Exception {
+        try {
+            enabled = Class.forName("org.spigotmc.SpigotConfig").getDeclaredField("bungee").getBoolean(null);
+            return enabled;
+        } catch (ClassNotFoundException notFoundEx) {
+            //ignore server has no proxy support
+            return false;
+        } catch (Exception ex) {
+            throw ex;
+        }
+    }
+
+    private void registerPluginChannels() {
+        Server server = Bukkit.getServer();
+
+        // check for incoming messages from the proxy version of this plugin
+        String groupId = plugin.getName();
+        String forceChannel = NamespaceKey.getCombined(groupId, LoginActionMessage.FORCE_CHANNEL);
+        server.getMessenger().registerIncomingPluginChannel(plugin, forceChannel, new ProxyMessagingListener(plugin));
+
+        // outgoing
+        String successChannel = new NamespaceKey(groupId, SUCCESS_CHANNEL).getCombinedName();
+        String changeChannel = new NamespaceKey(groupId, CHANGE_CHANNEL).getCombinedName();
+        server.getMessenger().registerOutgoingPluginChannel(plugin, successChannel);
+        server.getMessenger().registerOutgoingPluginChannel(plugin, changeChannel);
+    }
+
+    private Set<UUID> loadProxyIds() {
+        Path proxiesFile = plugin.getPluginFolder().resolve(FILE_NAME);
+        Path legacyFile = plugin.getPluginFolder().resolve(LEGACY_FILE_NAME);
+        try {
+            if (Files.notExists(proxiesFile)) {
+                if (Files.exists(legacyFile)) {
+                    Files.move(legacyFile, proxiesFile);
+                }
+
+                if (Files.notExists(legacyFile)) {
+                    Files.createFile(proxiesFile);
+                }
+            }
+
+            Files.deleteIfExists(legacyFile);
+            try (Stream<String> lines = Files.lines(proxiesFile)) {
+                return lines.map(String::trim)
+                        .map(UUID::fromString)
+                        .collect(toSet());
+            }
+        } catch (IOException ex) {
+            plugin.getLog().error("Failed to read proxies", ex);
+        } catch (Exception ex) {
+            plugin.getLog().error("Failed to retrieve proxy Id. Disabling proxy support", ex);
+        }
+
+        return Collections.emptySet();
+    }
+
+    public boolean isProxyAllowed(UUID proxyId) {
+        return proxyIds != null && proxyIds.contains(proxyId);
+    }
+
+    /**
+     * Mark the event to be fired including the task delay.
+     *
+     * @param player
+     */
+    public synchronized void markJoinEventFired(Player player) {
+        firedJoinEvents.add(player.getUniqueId());
+    }
+
+    /**
+     * Check if the event fired including with the task delay. This necessary to restore the order of processing the
+     * proxy messages after the PlayerJoinEvent fires including the delay.
+     *
+     * If the join event fired, the delay exceeded, but it ran earlier and couldn't find the recently started login
+     * session. If not fired, we can start a new force login task. This will still match the requirement that we wait
+     * a certain time after the player join event fired.
+     *
+     * @param player
+     * @return event fired including delay
+     */
+    public synchronized boolean didJoinEventFired(Player player) {
+        return firedJoinEvents.contains(player.getUniqueId());
+    }
+
+    /**
+     * Player quit clean up
+     *
+     * @param player
+     */
+    public synchronized void cleanup(Player player) {
+        firedJoinEvents.remove(player.getUniqueId());
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/auth/proxy/ProxyMessagingListener.java

@@ -0,0 +1,114 @@
+package com.github.games647.fastlogin.bukkit.auth.proxy;
+
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.bukkit.ForceLoginTask;
+import com.github.games647.fastlogin.core.PremiumStatus;
+import com.github.games647.fastlogin.core.hooks.AuthPlugin;
+import com.github.games647.fastlogin.core.message.LoginActionMessage;
+import com.github.games647.fastlogin.core.message.LoginActionMessage.Type;
+import com.google.common.io.ByteArrayDataInput;
+import com.google.common.io.ByteStreams;
+
+import java.net.InetSocketAddress;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageListener;
+
+/**
+ * Responsible for receiving messages from a proxy instance.
+ *
+ * This class also receives the plugin message from the proxy version of this plugin in order to get notified if
+ * the connection is in online mode.
+ */
+public class ProxyMessagingListener implements PluginMessageListener {
+
+    private final FastLoginBukkit plugin;
+
+    protected ProxyMessagingListener(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void onPluginMessageReceived(String channel, Player player, byte[] message) {
+        ByteArrayDataInput dataInput = ByteStreams.newDataInput(message);
+
+        LoginActionMessage loginMessage = new LoginActionMessage();
+        loginMessage.readFrom(dataInput);
+
+        plugin.getLog().debug("Received plugin message {}", loginMessage);
+
+        Player targetPlayer = player;
+        if (!loginMessage.getPlayerName().equals(player.getName())) {
+            targetPlayer = Bukkit.getPlayerExact(loginMessage.getPlayerName());;
+        }
+
+        if (targetPlayer == null) {
+            plugin.getLog().warn("Force action player {} not found", loginMessage.getPlayerName());
+            return;
+        }
+
+        // fail if target player is blocked because already authenticated or wrong proxy id
+        if (targetPlayer.hasMetadata(plugin.getName())) {
+            plugin.getLog().warn("Received message {} from a blocked player {}", loginMessage, targetPlayer);
+        } else {
+            UUID sourceId = loginMessage.getProxyId();
+            if (plugin.getProxyManager().isProxyAllowed(sourceId)) {
+                readMessage(targetPlayer, loginMessage);
+            } else {
+                plugin.getLog().warn("Received proxy id: {} that doesn't exist in the proxy file", sourceId);
+            }
+        }
+    }
+
+    private void readMessage(Player player, LoginActionMessage message) {
+        String playerName = message.getPlayerName();
+        Type type = message.getType();
+
+        InetSocketAddress address = player.getAddress();
+        plugin.getLog().info("Player info {} command for {} from proxy", type, playerName);
+        if (type == Type.LOGIN) {
+            onLoginMessage(player, playerName, address);
+        } else if (type == Type.REGISTER) {
+            onRegisterMessage(player, playerName, address);
+        } else if (type == Type.CRACKED) {
+            //we don't start a force login task here so update it manually
+            plugin.getPremiumPlayers().put(player.getUniqueId(), PremiumStatus.CRACKED);
+        }
+    }
+
+    private void onLoginMessage(Player player, String playerName, InetSocketAddress address) {
+        BukkitLoginSession playerSession = new BukkitLoginSession(playerName, true);
+        startLoginTaskIfReady(player, playerSession);
+    }
+
+    private void onRegisterMessage(Player player, String playerName, InetSocketAddress address) {
+        Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+            AuthPlugin<Player> authPlugin = plugin.getCore().getAuthPluginHook();
+            try {
+                //we need to check if the player is registered on Bukkit too
+                if (authPlugin == null || !authPlugin.isRegistered(playerName)) {
+                    BukkitLoginSession playerSession = new BukkitLoginSession(playerName, false);
+                    startLoginTaskIfReady(player, playerSession);
+                }
+            } catch (Exception ex) {
+                plugin.getLog().error("Failed to query isRegistered for player: {}", player, ex);
+            }
+        });
+    }
+
+    private void startLoginTaskIfReady(Player player, BukkitLoginSession session) {
+        session.setVerified(true);
+        plugin.getSessionManager().startLoginSession(player.getAddress(), session);
+
+        // only start a new login task if the join event fired earlier. This event then didn
+        boolean result = plugin.getProxyManager().didJoinEventFired(player);
+        plugin.getLog().info("Delaying force login until join event fired?: {}", result);
+        if (result) {
+            Runnable forceLoginTask = new ForceLoginTask(plugin.getCore(), player, session);
+            Bukkit.getScheduler().runTaskAsynchronously(plugin, forceLoginTask);
+        }
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/command/CrackedCommand.java

@@ -0,0 +1,94 @@
+package com.github.games647.fastlogin.bukkit.command;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.bukkit.event.BukkitFastLoginPremiumToggleEvent;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+
+import static com.github.games647.fastlogin.core.shared.event.FastLoginPremiumToggleEvent.*;
+
+public class CrackedCommand extends ToggleCommand {
+
+    public CrackedCommand(FastLoginBukkit plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length == 0) {
+            onCrackedSelf(sender, command, args);
+        } else {
+            onCrackedOther(sender, command, args);
+        }
+
+        return true;
+    }
+
+    private void onCrackedSelf(CommandSender sender, Command cmd, String[] args) {
+        if (isConsole(sender)) {
+            return;
+        }
+
+        if (forwardCrackedCommand(sender, sender.getName())) {
+            return;
+        }
+
+        if (plugin.getProxyManager().isEnabled()) {
+            sendProxyActivateMessage(sender, sender.getName(), false);
+            plugin.getCore().sendLocaleMessage("wait-on-proxy", sender);
+        } else {
+            //todo: load async if
+            StoredProfile profile = plugin.getCore().getStorage().loadProfile(sender.getName());
+            if (profile.isPremium()) {
+                plugin.getCore().sendLocaleMessage("remove-premium", sender);
+
+                profile.setPremium(false);
+                profile.setId(null);
+                plugin.getScheduler().runAsync(() -> {
+                    plugin.getCore().getStorage().save(profile);
+                    plugin.getServer().getPluginManager().callEvent(
+                            new BukkitFastLoginPremiumToggleEvent(profile, PremiumToggleReason.COMMAND_OTHER));
+                });
+            } else {
+                plugin.getCore().sendLocaleMessage("not-premium", sender);
+            }
+        }
+    }
+
+    private void onCrackedOther(CommandSender sender, Command command, String[] args) {
+        if (!hasOtherPermission(sender, command)) {
+            return;
+        }
+
+        if (forwardCrackedCommand(sender, args[0])) {
+            return;
+        }
+
+        //todo: load async
+        StoredProfile profile = plugin.getCore().getStorage().loadProfile(args[0]);
+        if (profile == null) {
+            sender.sendMessage("Error occurred");
+            return;
+        }
+
+        //existing player is already cracked
+        if (profile.isSaved() && !profile.isPremium()) {
+            plugin.getCore().sendLocaleMessage("not-premium-other", sender);
+        } else {
+            plugin.getCore().sendLocaleMessage("remove-premium", sender);
+
+            profile.setPremium(false);
+            plugin.getScheduler().runAsync(() -> {
+                plugin.getCore().getStorage().save(profile);
+                plugin.getServer().getPluginManager().callEvent(
+                        new BukkitFastLoginPremiumToggleEvent(profile, PremiumToggleReason.COMMAND_OTHER));
+            });
+        }
+    }
+
+    private boolean forwardCrackedCommand(CommandSender sender, String target) {
+        return forwardProxyCommand(sender, target, false);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/command/PremiumCommand.java

@@ -0,0 +1,104 @@
+package com.github.games647.fastlogin.bukkit.command;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.bukkit.event.BukkitFastLoginPremiumToggleEvent;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPremiumToggleEvent.PremiumToggleReason;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+
+import java.util.UUID;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+/**
+ * Let users activate fast login by command. This only be accessible if
+ * the user has access to it's account. So we can make sure that not another
+ * person with a paid account and the same username can steal their account.
+ */
+public class PremiumCommand extends ToggleCommand {
+
+    public PremiumCommand(FastLoginBukkit plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (args.length == 0) {
+            onPremiumSelf(sender, command, args);
+        } else {
+            onPremiumOther(sender, command, args);
+        }
+
+        return true;
+    }
+
+    private void onPremiumSelf(CommandSender sender, Command cmd, String[] args) {
+        if (isConsole(sender)) {
+            return;
+        }
+
+        if (forwardPremiumCommand(sender, sender.getName())) {
+            return;
+        }
+
+        UUID id = ((Player) sender).getUniqueId();
+        if (plugin.getConfig().getBoolean("premium-warning") && !plugin.getCore().getPendingConfirms().contains(id)) {
+            sender.sendMessage(plugin.getCore().getMessage("premium-warning"));
+            plugin.getCore().getPendingConfirms().add(id);
+            return;
+        }
+
+        plugin.getCore().getPendingConfirms().remove(id);
+        //todo: load async
+        StoredProfile profile = plugin.getCore().getStorage().loadProfile(sender.getName());
+        if (profile.isPremium()) {
+            plugin.getCore().sendLocaleMessage("already-exists", sender);
+        } else {
+            //todo: resolve uuid
+            profile.setPremium(true);
+            plugin.getScheduler().runAsync(() -> {
+                plugin.getCore().getStorage().save(profile);
+                plugin.getServer().getPluginManager().callEvent(
+                        new BukkitFastLoginPremiumToggleEvent(profile, PremiumToggleReason.COMMAND_SELF));
+            });
+
+            plugin.getCore().sendLocaleMessage("add-premium", sender);
+        }
+    }
+
+    private void onPremiumOther(CommandSender sender, Command command, String[] args) {
+        if (!hasOtherPermission(sender, command)) {
+            return;
+        }
+
+        if (forwardPremiumCommand(sender, args[0])) {
+            return;
+        }
+
+        //todo: load async
+        StoredProfile profile = plugin.getCore().getStorage().loadProfile(args[0]);
+        if (profile == null) {
+            plugin.getCore().sendLocaleMessage("player-unknown", sender);
+            return;
+        }
+
+        if (profile.isPremium()) {
+            plugin.getCore().sendLocaleMessage("already-exists-other", sender);
+        } else {
+            //todo: resolve uuid
+            profile.setPremium(true);
+            plugin.getScheduler().runAsync(() -> {
+                plugin.getCore().getStorage().save(profile);
+                plugin.getServer().getPluginManager().callEvent(
+                        new BukkitFastLoginPremiumToggleEvent(profile, PremiumToggleReason.COMMAND_OTHER));
+            });
+
+            plugin.getCore().sendLocaleMessage("add-premium-other", sender);
+        }
+    }
+
+    private boolean forwardPremiumCommand(CommandSender sender, String target) {
+        return forwardProxyCommand(sender, target, true);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/command/ToggleCommand.java

@@ -0,0 +1,69 @@
+package com.github.games647.fastlogin.bukkit.command;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.core.message.ChangePremiumMessage;
+import com.github.games647.fastlogin.core.message.ChannelMessage;
+
+import java.util.Optional;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.messaging.PluginMessageRecipient;
+
+public abstract class ToggleCommand implements CommandExecutor {
+
+    protected final FastLoginBukkit plugin;
+
+    public ToggleCommand(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    protected boolean hasOtherPermission(CommandSender sender, Command cmd) {
+        if (!sender.hasPermission(cmd.getPermission() + ".other")) {
+            plugin.getCore().sendLocaleMessage("no-permission", sender);
+            return false;
+        }
+
+        return true;
+    }
+
+    protected boolean forwardProxyCommand(CommandSender sender, String target, boolean activate) {
+        if (plugin.getProxyManager().isEnabled()) {
+            sendProxyActivateMessage(sender, target, activate);
+            plugin.getCore().sendLocaleMessage("wait-on-proxy", sender);
+            return true;
+        }
+
+        return false;
+    }
+
+    protected boolean isConsole(CommandSender sender) {
+        if (sender instanceof Player) {
+            return false;
+        }
+
+        //console or command block
+        sender.sendMessage(plugin.getCore().getMessage("no-console"));
+        return true;
+    }
+
+    protected void sendProxyActivateMessage(CommandSender invoker, String target, boolean activate) {
+        if (invoker instanceof PluginMessageRecipient) {
+            ChannelMessage message = new ChangePremiumMessage(target, activate, true);
+            plugin.getProxyManager().sendPluginMessage((PluginMessageRecipient) invoker, message);
+        } else {
+            Optional<? extends Player> optPlayer = Bukkit.getServer().getOnlinePlayers().stream().findFirst();
+            if (!optPlayer.isPresent()) {
+                plugin.getLog().info("No player online to send a plugin message to the proxy");
+                return;
+            }
+
+            Player sender = optPlayer.get();
+            ChannelMessage message = new ChangePremiumMessage(target, activate, false);
+            plugin.getProxyManager().sendPluginMessage(sender, message);
+        }
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/commands/CrackedCommand.java

@@ -1,86 +0,0 @@
-package com.github.games647.fastlogin.bukkit.commands;
-
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.core.PlayerProfile;
-
-import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-public class CrackedCommand implements CommandExecutor {
-
-    private final FastLoginBukkit plugin;
-
-    public CrackedCommand(FastLoginBukkit plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (args.length == 0) {
-            if (!(sender instanceof Player)) {
-                //console or command block
-                sender.sendMessage(plugin.getCore().getMessage("no-console"));
-                return true;
-            }
-
-            if (plugin.isBungeeCord()) {
-                plugin.sendBungeeActivateMessage(sender, sender.getName(), false);
-                plugin.getCore().sendLocaleMessage("wait-on-proxy", sender);
-            } else {
-                //todo: load async if
-                PlayerProfile profile = plugin.getCore().getStorage().loadProfile(sender.getName());
-                if (profile.isPremium()) {
-                    plugin.getCore().sendLocaleMessage("remove-premium", sender);
-
-                    profile.setPremium(false);
-                    profile.setUuid(null);
-                    Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                        plugin.getCore().getStorage().save(profile);
-                    });
-                } else {
-                    plugin.getCore().sendLocaleMessage("not-premium", sender);
-                }
-            }
-
-            return true;
-        } else {
-            onCrackedOther(sender, command, args);
-        }
-
-        return true;
-    }
-
-    private void onCrackedOther(CommandSender sender, Command command, String[] args) {
-        if (!sender.hasPermission(command.getPermission() + ".other")) {
-            plugin.getCore().sendLocaleMessage("no-permission", sender);
-            return;
-        }
-        
-        if (plugin.isBungeeCord()) {
-            plugin.sendBungeeActivateMessage(sender, args[0], false);
-            plugin.getCore().sendLocaleMessage("wait-on-proxy", sender);
-        } else {
-            //todo: load async
-            PlayerProfile profile = plugin.getCore().getStorage().loadProfile(args[0]);
-            if (profile == null) {
-                sender.sendMessage("Error occurred");
-                return;
-            }
-
-            //existing player is already cracked
-            if (profile.getUserId() != -1 && !profile.isPremium()) {
-                plugin.getCore().sendLocaleMessage("not-premium-other", sender);
-            } else {
-                plugin.getCore().sendLocaleMessage("remove-premium", sender);
-
-                profile.setPremium(false);
-                Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                    plugin.getCore().getStorage().save(profile);
-                });
-            }
-        }
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/commands/PremiumCommand.java

@@ -1,102 +0,0 @@
-package com.github.games647.fastlogin.bukkit.commands;
-
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.core.PlayerProfile;
-
-import java.util.UUID;
-
-import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-/**
- * Let users activate fast login by command. This only be accessible if
- * the user has access to it's account. So we can make sure that not another
- * person with a paid account and the same username can steal his account.
- */
-public class PremiumCommand implements CommandExecutor {
-
-    private final FastLoginBukkit plugin;
-
-    public PremiumCommand(FastLoginBukkit plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (args.length == 0) {
-            if (!(sender instanceof Player)) {
-                //console or command block
-                plugin.getCore().sendLocaleMessage("no-console", sender);
-                return true;
-            }
-
-            if (plugin.isBungeeCord()) {
-                plugin.sendBungeeActivateMessage(sender, sender.getName(), true);
-                plugin.getCore().sendLocaleMessage("wait-on-proxy", sender);
-            } else {
-                UUID id = ((Player) sender).getUniqueId();
-                if (plugin.getConfig().getBoolean("premium-warning")
-                        && !plugin.getCore().getPendingConfirms().contains(id)) {
-                    sender.sendMessage(plugin.getCore().getMessage("premium-warning"));
-                    plugin.getCore().getPendingConfirms().add(id);
-                    return true;
-                }
-
-                plugin.getCore().getPendingConfirms().remove(id);
-                //todo: load async
-                PlayerProfile profile = plugin.getCore().getStorage().loadProfile(sender.getName());
-                if (profile.isPremium()) {
-                    plugin.getCore().sendLocaleMessage("already-exists", sender);
-                } else {
-                    //todo: resolve uuid
-                    profile.setPremium(true);
-                    Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                        plugin.getCore().getStorage().save(profile);
-                    });
-
-                    plugin.getCore().sendLocaleMessage("add-premium", sender);
-                }
-            }
-
-            return true;
-        } else {
-            onPremiumOther(sender, command, args);
-        }
-
-        return true;
-    }
-
-    private void onPremiumOther(CommandSender sender, Command command, String[] args) {
-        if (!sender.hasPermission(command.getPermission() + ".other")) {
-            plugin.getCore().sendLocaleMessage("no-permission", sender);
-            return ;
-        }
-
-        if (plugin.isBungeeCord()) {
-            plugin.sendBungeeActivateMessage(sender, args[0], true);
-            plugin.getCore().sendLocaleMessage("wait-on-proxy", sender);
-        } else {
-            //todo: load async
-            PlayerProfile profile = plugin.getCore().getStorage().loadProfile(args[0]);
-            if (profile == null) {
-                plugin.getCore().sendLocaleMessage("player-unknown", sender);
-                return;
-            }
-            
-            if (profile.isPremium()) {
-                plugin.getCore().sendLocaleMessage("already-exists-other", sender);
-            } else {
-                //todo: resolve uuid
-                profile.setPremium(true);
-                Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                    plugin.getCore().getStorage().save(profile);
-                });
-
-                plugin.getCore().sendLocaleMessage("add-premium-other", sender);
-            }
-        }
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/event/BukkitFastLoginAutoLoginEvent.java

@@ -0,0 +1,52 @@
+package com.github.games647.fastlogin.bukkit.event;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSession;
+import com.github.games647.fastlogin.core.shared.event.FastLoginAutoLoginEvent;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class BukkitFastLoginAutoLoginEvent extends Event implements FastLoginAutoLoginEvent, Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final LoginSession session;
+    private final StoredProfile profile;
+    private boolean cancelled;
+
+    public BukkitFastLoginAutoLoginEvent(LoginSession session, StoredProfile profile) {
+        super(true);
+
+        this.session = session;
+        this.profile = profile;
+    }
+
+    @Override
+    public LoginSession getSession() {
+        return session;
+    }
+
+    @Override
+    public StoredProfile getProfile() {
+        return profile;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/event/BukkitFastLoginPreLoginEvent.java

@@ -0,0 +1,47 @@
+package com.github.games647.fastlogin.bukkit.event;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSource;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPreLoginEvent;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class BukkitFastLoginPreLoginEvent extends Event implements FastLoginPreLoginEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final String username;
+    private final LoginSource source;
+    private final StoredProfile profile;
+
+    public BukkitFastLoginPreLoginEvent(String username, LoginSource source, StoredProfile profile) {
+        super(true);
+
+        this.username = username;
+        this.source = source;
+        this.profile = profile;
+    }
+
+    @Override
+    public String getUsername() {
+        return username;
+    }
+
+    @Override
+    public LoginSource getSource() {
+        return source;
+    }
+
+    @Override
+    public StoredProfile getProfile() {
+        return profile;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/event/BukkitFastLoginPremiumToggleEvent.java

@@ -0,0 +1,38 @@
+package com.github.games647.fastlogin.bukkit.event;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPremiumToggleEvent;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class BukkitFastLoginPremiumToggleEvent extends Event implements FastLoginPremiumToggleEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    private final StoredProfile profile;
+    private final PremiumToggleReason reason;
+
+    public BukkitFastLoginPremiumToggleEvent(StoredProfile profile, PremiumToggleReason reason) {
+        super(true);
+        this.profile = profile;
+        this.reason = reason;
+    }
+
+    @Override
+    public StoredProfile getProfile() {
+        return profile;
+    }
+
+    @Override
+    public PremiumToggleReason getReason() {
+        return reason;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/AuthMeHook.java

@@ -0,0 +1,91 @@
+package com.github.games647.fastlogin.bukkit.hook;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.hooks.AuthPlugin;
+
+import fr.xephi.authme.api.v3.AuthMeApi;
+import fr.xephi.authme.events.RestoreSessionEvent;
+import fr.xephi.authme.process.Management;
+import fr.xephi.authme.process.register.executors.ApiPasswordRegisterParams;
+import fr.xephi.authme.process.register.executors.RegistrationMethod;
+
+import java.lang.reflect.Field;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+/**
+ * GitHub: https://github.com/Xephi/AuthMeReloaded/
+ * <p>
+ * Project page:
+ * <p>
+ * Bukkit: https://dev.bukkit.org/bukkit-plugins/authme-reloaded/
+ * <p>
+ * Spigot: https://www.spigotmc.org/resources/authme-reloaded.6269/
+ */
+public class AuthMeHook implements AuthPlugin<Player>, Listener {
+
+    private final FastLoginBukkit plugin;
+
+    private final AuthMeApi authmeAPI;
+    private Management authmeManagement;
+
+    protected AuthMeHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+        this.authmeAPI = AuthMeApi.getInstance();
+
+        if (plugin.getConfig().getBoolean("respectIpLimit", false)) {
+            try {
+                Field managementField = this.authmeAPI.getClass().getDeclaredField("management");
+                managementField.setAccessible(true);
+                this.authmeManagement = (Management) managementField.get(this.authmeAPI);
+            } catch (NoSuchFieldException | IllegalAccessException exception) {
+                this.authmeManagement = null;
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onSessionRestore(RestoreSessionEvent restoreSessionEvent) {
+        Player player = restoreSessionEvent.getPlayer();
+
+        StoredProfile session = plugin.getSessionManager().getPlaySession(player.getUniqueId());
+        if (session != null && session.isPremium()) {
+            restoreSessionEvent.setCancelled(true);
+        }
+    }
+
+    @Override
+    public boolean forceLogin(Player player) {
+        if (authmeAPI.isAuthenticated(player)) {
+            plugin.getLog().warn(ALREADY_AUTHENTICATED, player);
+            return false;
+        }
+
+        //skips registration and login
+        authmeAPI.forceLogin(player);
+        return true;
+    }
+
+    @Override
+    public boolean isRegistered(String playerName) {
+        return authmeAPI.isRegistered(playerName);
+    }
+
+    @Override
+    //this automatically login the player too
+    public boolean forceRegister(Player player, String password) {
+        //if we have the management - we can trigger register with IP limit checks
+        if (authmeManagement != null) {
+            authmeManagement.performRegister(RegistrationMethod.PASSWORD_REGISTRATION,
+                    ApiPasswordRegisterParams.of(player, password, true));
+        } else {
+            authmeAPI.forceRegister(player, password);
+        }
+
+        return true;
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/CrazyLoginHook.java

@@ -1,5 +1,7 @@
-package com.github.games647.fastlogin.bukkit.hooks;
+package com.github.games647.fastlogin.bukkit.hook;
 
+import com.comphenix.protocol.reflect.FieldUtils;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
 
 import de.st_ddt.crazylogin.CrazyLogin;
@@ -8,30 +10,38 @@ import de.st_ddt.crazylogin.databases.CrazyLoginDataDatabase;
 import de.st_ddt.crazylogin.listener.PlayerListener;
 import de.st_ddt.crazylogin.metadata.Authenticated;
 
+import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.logging.Level;
 
-import org.apache.commons.lang.reflect.FieldUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
 /**
- * Github: https://github.com/ST-DDT/CrazyLogin
- *
+ * GitHub: https://github.com/ST-DDT/CrazyLogin
+ * <p>
  * Project page:
- *
- * Bukkit: http://dev.bukkit.org/server-mods/crazylogin/
+ * <p>
+ * Bukkit: https://dev.bukkit.org/server-mods/crazylogin/
  */
 public class CrazyLoginHook implements AuthPlugin<Player> {
 
-    private final CrazyLogin crazyLoginPlugin = CrazyLogin.getPlugin();
-    private final PlayerListener playerListener = getListener();
+    private final FastLoginBukkit plugin;
+
+    private final CrazyLogin crazyLoginPlugin;
+    private final PlayerListener playerListener;
+
+    protected CrazyLoginHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+
+        crazyLoginPlugin = CrazyLogin.getPlugin();
+        playerListener = getListener();
+    }
 
     @Override
     public boolean forceLogin(Player player) {
         //not thread-safe operation
-        Future<LoginPlayerData> future = Bukkit.getScheduler().callSyncMethod(crazyLoginPlugin, () -> {
+        Future<Optional<LoginPlayerData>> future = Bukkit.getScheduler().callSyncMethod(plugin, () -> {
             LoginPlayerData playerData = crazyLoginPlugin.getPlayerData(player);
             if (playerData != null) {
                 //mark the account as logged in
@@ -56,21 +66,21 @@ public class CrazyLoginHook implements AuthPlugin<Player> {
                 playerData.addIP(ip);
                 player.setMetadata("Authenticated", new Authenticated(crazyLoginPlugin, player));
                 crazyLoginPlugin.unregisterDynamicHooks();
-                return playerData;
+                return Optional.of(playerData);
             }
 
-            return null;
+            return Optional.empty();
         });
 
         try {
-            LoginPlayerData result = future.get();
-            if (result != null && result.isLoggedIn()) {
+            Optional<LoginPlayerData> result = future.get().filter(LoginPlayerData::isLoggedIn);
+            if (result.isPresent()) {
                 //SQL-Queries should run async
-                crazyLoginPlugin.getCrazyDatabase().saveWithoutPassword(result);
+                crazyLoginPlugin.getCrazyDatabase().saveWithoutPassword(result.get());
                 return true;
             }
         } catch (InterruptedException | ExecutionException ex) {
-            crazyLoginPlugin.getLogger().log(Level.SEVERE, "Failed to forceLogin", ex);
+            plugin.getLog().error("Failed to forceLogin player: {}", player, ex);
             return false;
         }
 
@@ -78,7 +88,7 @@ public class CrazyLoginHook implements AuthPlugin<Player> {
     }
 
     @Override
-    public boolean isRegistered(String playerName) throws Exception {
+    public boolean isRegistered(String playerName) {
         return crazyLoginPlugin.getPlayerData(playerName) != null;
     }
 
@@ -92,9 +102,7 @@ public class CrazyLoginHook implements AuthPlugin<Player> {
             //create a fake account - this will be saved to the database with the password=FAILEDLOADING
             //user cannot login with that password unless the admin uses plain text
             //this automatically marks the player as logged in
-            playerData = new LoginPlayerData(player);
-            crazyDatabase.save(playerData);
-
+            crazyDatabase.save(new LoginPlayerData(player));
             return forceLogin(player);
         }
 
@@ -106,7 +114,7 @@ public class CrazyLoginHook implements AuthPlugin<Player> {
         try {
             listener = (PlayerListener) FieldUtils.readField(crazyLoginPlugin, "playerListener", true);
         } catch (IllegalAccessException ex) {
-            crazyLoginPlugin.getLogger().log(Level.SEVERE, "Failed to get the listener instance for auto login", ex);
+            plugin.getLog().error("Failed to get the listener instance for auto login", ex);
             listener = null;
         }
 

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/DelayedAuthHook.java

@@ -0,0 +1,90 @@
+package com.github.games647.fastlogin.bukkit.hook;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.core.hooks.AuthPlugin;
+
+import java.lang.reflect.Constructor;
+import java.util.Arrays;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+
+public class DelayedAuthHook implements Runnable {
+
+    private final FastLoginBukkit plugin;
+
+    public DelayedAuthHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void run() {
+        boolean hookFound = isHookFound();
+        if (plugin.getProxyManager().isEnabled()) {
+            plugin.getLog().info("Proxy setting detected. No auth plugin is required");
+        } else if (!hookFound) {
+            plugin.getLog().warn("No auth plugin were found by this plugin "
+                    + "(other plugins could hook into this after the initialization of this plugin)"
+                    + "and BungeeCord (or similar proxies) is deactivated. "
+                    + "Either one or both of the checks have to pass in order to use this plugin");
+        }
+    }
+
+    private boolean isHookFound() {
+        return plugin.getCore().getAuthPluginHook() != null || registerHooks();
+    }
+
+    private boolean registerHooks() {
+        AuthPlugin<Player> authPluginHook = getAuthHook();
+        if (authPluginHook == null) {
+            //run this check for exceptions (errors) and not found plugins
+            plugin.getLog().warn("No support offline Auth plugin found. ");
+            return false;
+        }
+
+        if (authPluginHook instanceof Listener) {
+            Bukkit.getPluginManager().registerEvents((Listener) authPluginHook, plugin);
+        }
+
+        if (plugin.getCore().getAuthPluginHook() == null) {
+            plugin.getLog().info("Hooking into auth plugin: {}", authPluginHook.getClass().getSimpleName());
+            plugin.getCore().setAuthPluginHook(authPluginHook);
+        }
+
+        return true;
+    }
+
+    private AuthPlugin<Player> getAuthHook() {
+        try {
+            @SuppressWarnings("unchecked")
+            List<Class<? extends AuthPlugin<Player>>> hooks = Arrays.asList(AuthMeHook.class,
+                    CrazyLoginHook.class, LogItHook.class, LoginSecurityHook.class,
+                    SodionAuthHook.class, UltraAuthHook.class, xAuthHook.class);
+
+            for (Class<? extends AuthPlugin<Player>> clazz : hooks) {
+                String pluginName = clazz.getSimpleName().replace("Hook", "");
+                //uses only member classes which uses AuthPlugin interface (skip interfaces)
+                if (Bukkit.getPluginManager().isPluginEnabled(pluginName)) {
+                    //check only for enabled plugins. A single plugin could be disabled by plugin managers
+                    return newInstance(clazz);
+                }
+            }
+        } catch (ReflectiveOperationException ex) {
+            plugin.getLog().error("Couldn't load the auth hook class", ex);
+        }
+
+        return null;
+    }
+
+    private AuthPlugin<Player> newInstance(Class<? extends AuthPlugin<Player>> clazz)
+            throws ReflectiveOperationException {
+        try {
+            Constructor<? extends AuthPlugin<Player>> cons = clazz.getDeclaredConstructor(FastLoginBukkit.class);
+            return cons.newInstance(plugin);
+        } catch (NoSuchMethodException noMethodEx) {
+            return clazz.getDeclaredConstructor().newInstance();
+        }
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/LogItHook.java

@@ -1,34 +1,47 @@
-package com.github.games647.fastlogin.bukkit.hooks;
+package com.github.games647.fastlogin.bukkit.hook;
 
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
 
 import io.github.lucaseasedup.logit.CancelledState;
 import io.github.lucaseasedup.logit.LogItCore;
 import io.github.lucaseasedup.logit.account.Account;
 import io.github.lucaseasedup.logit.session.SessionManager;
+
+import java.time.Instant;
+
 import org.bukkit.entity.Player;
 
 /**
- * Github: https://github.com/XziomekX/LogIt
+ * GitHub: https://github.com/XziomekX/LogIt
+ * <p>
  * Project page:
- *
+ * <p>
  * Bukkit: Unknown
+ * <p>
  * Spigot: Unknown
  */
 public class LogItHook implements AuthPlugin<Player> {
 
+    private final FastLoginBukkit plugin;
+
+    protected LogItHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
     @Override
     public boolean forceLogin(Player player) {
         SessionManager sessionManager = LogItCore.getInstance().getSessionManager();
         if (sessionManager.isSessionAlive(player)) {
-            return true;
+            plugin.getLog().warn(ALREADY_AUTHENTICATED, player);
+            return false;
         }
 
         return sessionManager.startSession(player) == CancelledState.NOT_CANCELLED;
     }
 
     @Override
-    public boolean isRegistered(String playerName) throws Exception {
+    public boolean isRegistered(String playerName) {
         return LogItCore.getInstance().getAccountManager().isRegistered(playerName);
     }
 
@@ -36,8 +49,10 @@ public class LogItHook implements AuthPlugin<Player> {
     public boolean forceRegister(Player player, String password) {
         Account account = new Account(player.getName());
         account.changePassword(password);
-        account.setLastActiveDate(System.currentTimeMillis() / 1000);
-        account.setRegistrationDate(System.currentTimeMillis() / 1000);
+
+        Instant now = Instant.now();
+        account.setLastActiveDate(now.getEpochSecond());
+        account.setRegistrationDate(now.getEpochSecond());
         return LogItCore.getInstance().getAccountManager().insertAccount(account) == CancelledState.NOT_CANCELLED;
     }
 }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/LoginSecurityHook.java

@@ -1,4 +1,4 @@
-package com.github.games647.fastlogin.bukkit.hooks;
+package com.github.games647.fastlogin.bukkit.hook;
 
 import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
@@ -8,31 +8,39 @@ import com.lenis0012.bukkit.loginsecurity.session.PlayerSession;
 import com.lenis0012.bukkit.loginsecurity.session.action.LoginAction;
 import com.lenis0012.bukkit.loginsecurity.session.action.RegisterAction;
 
-import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
 /**
- * Github: https://github.com/lenis0012/LoginSecurity-2 Project page:
- *
- * Bukkit: http://dev.bukkit.org/bukkit-plugins/loginsecurity/
+ * GitHub: https://github.com/lenis0012/LoginSecurity-2
+ * <p>
+ * Project page:
+ * <p>
+ * Bukkit: https://dev.bukkit.org/bukkit-plugins/loginsecurity/
+ * <p>
  * Spigot: https://www.spigotmc.org/resources/loginsecurity.19362/
  */
 public class LoginSecurityHook implements AuthPlugin<Player> {
 
-    private final FastLoginBukkit plugin = (FastLoginBukkit) Bukkit.getPluginManager().getPlugin("FastLogin");
+    private final FastLoginBukkit plugin;
+
+    protected LoginSecurityHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
 
     @Override
     public boolean forceLogin(Player player) {
         PlayerSession session = LoginSecurity.getSessionManager().getPlayerSession(player);
         if (session.isAuthorized()) {
+            plugin.getLog().warn(ALREADY_AUTHENTICATED, player);
             return true;
         }
 
-        return session.performAction(new LoginAction(AuthService.PLUGIN, plugin)).isSuccess();
+        return session.isAuthorized()
+                || session.performAction(new LoginAction(AuthService.PLUGIN, plugin)).isSuccess();
     }
 
     @Override
-    public boolean isRegistered(String playerName) throws Exception {
+    public boolean isRegistered(String playerName) {
         PlayerSession session = LoginSecurity.getSessionManager().getOfflineSession(playerName);
         return session.isRegistered();
     }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/SodionAuthHook.java

@@ -0,0 +1,53 @@
+package com.github.games647.fastlogin.bukkit.hook;
+
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.core.hooks.AuthPlugin;
+import org.bukkit.entity.Player;
+import red.mohist.sodionauth.bukkit.implementation.BukkitPlayer;
+import red.mohist.sodionauth.core.SodionAuthApi;
+import red.mohist.sodionauth.core.exception.AuthenticatedException;
+
+/**
+ * GitHub: https://github.com/Mohist-Community/SodionAuth
+ * <p>
+ * Project page:
+ * <p>
+ * Bukkit: Unknown
+ * <p>
+ * Spigot: Unknown
+ */
+public class SodionAuthHook implements AuthPlugin<Player> {
+
+    private final FastLoginBukkit plugin;
+
+    protected SodionAuthHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean forceLogin(Player player) {
+        try {
+            SodionAuthApi.login(new BukkitPlayer(player));
+        } catch (AuthenticatedException e) {
+            plugin.getLog().warn(ALREADY_AUTHENTICATED, player);
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean forceRegister(Player player, String password) {
+        try{
+            return SodionAuthApi.register(new BukkitPlayer(player), password);
+        } catch (UnsupportedOperationException e){
+            plugin.getLog().warn("Currently SodionAuth is not accepting forceRegister, " +
+                    "It may be caused by unsupported AuthBackend");
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isRegistered(String playerName) {
+        return SodionAuthApi.isRegistered(playerName);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/UltraAuthHook.java

@@ -1,10 +1,10 @@
-package com.github.games647.fastlogin.bukkit.hooks;
+package com.github.games647.fastlogin.bukkit.hook;
 
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.logging.Level;
 
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
@@ -15,21 +15,27 @@ import ultraauth.managers.PlayerManager;
 
 /**
  * Project page:
- *
- * Bukkit: http://dev.bukkit.org/bukkit-plugins/ultraauth-aa/
- *
+ * <p>
+ * Bukkit: https://dev.bukkit.org/bukkit-plugins/ultraauth-aa/
+ * <p>
  * Spigot: https://www.spigotmc.org/resources/ultraauth.17044/
  */
 public class UltraAuthHook implements AuthPlugin<Player> {
 
     private final Plugin ultraAuthPlugin = Main.main;
+    private final FastLoginBukkit plugin;
+
+    protected UltraAuthHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
 
     @Override
     public boolean forceLogin(Player player) {
         //not thread-safe
-        Future<Boolean> future = Bukkit.getScheduler().callSyncMethod(ultraAuthPlugin, () -> {
+        Future<Boolean> future = Bukkit.getScheduler().callSyncMethod(plugin, () -> {
             if (UltraAuthAPI.isAuthenticated(player)) {
-                return true;
+                plugin.getLog().warn(ALREADY_AUTHENTICATED, player);
+                return false;
             }
 
             UltraAuthAPI.authenticatedPlayer(player);
@@ -39,24 +45,20 @@ public class UltraAuthHook implements AuthPlugin<Player> {
         try {
             return future.get();
         } catch (InterruptedException | ExecutionException ex) {
-            ultraAuthPlugin.getLogger().log(Level.SEVERE, "Failed to forceLogin", ex);
+            plugin.getLog().error("Failed to forceLogin player: {}", player, ex);
             return false;
         }
     }
 
     @Override
-    public boolean isRegistered(String playerName) throws Exception {
+    public boolean isRegistered(String playerName) {
         return UltraAuthAPI.isRegisterd(playerName);
     }
 
     @Override
     public boolean forceRegister(Player player, String password) {
         UltraAuthAPI.setPlayerPasswordOnline(player, password);
-        if (PlayerManager.getInstance().checkPlayerPassword(player, password)) {
-            //the register method silents any exception so check if our entry was saved
-            return forceLogin(player);
-        }
-
-        return false;
+        //the register method silents any exception so check if our entry was saved
+        return PlayerManager.getInstance().checkPlayerPassword(player, password) && forceLogin(player);
     }
 }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hook/xAuthHook.java

@@ -1,5 +1,6 @@
-package com.github.games647.fastlogin.bukkit.hooks;
+package com.github.games647.fastlogin.bukkit.hook;
 
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
 
 import de.luricos.bukkit.xAuth.xAuth;
@@ -7,30 +8,35 @@ import de.luricos.bukkit.xAuth.xAuthPlayer;
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.logging.Level;
 
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
 /**
- * Github: https://github.com/LycanDevelopment/xAuth/
- *
+ * GitHub: https://github.com/LycanDevelopment/xAuth/
+ * <p>
  * Project page:
- *
- * Bukkit: http://dev.bukkit.org/bukkit-plugins/xauth/
+ * <p>
+ * Bukkit: https://dev.bukkit.org/bukkit-plugins/xauth/
  */
 public class xAuthHook implements AuthPlugin<Player> {
 
     private final xAuth xAuthPlugin = xAuth.getPlugin();
+    private final FastLoginBukkit plugin;
+
+    protected xAuthHook(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
 
     @Override
     public boolean forceLogin(Player player) {
         //not thread-safe
-        Future<Boolean> future = Bukkit.getScheduler().callSyncMethod(xAuthPlugin, () -> {
+        Future<Boolean> future = Bukkit.getScheduler().callSyncMethod(plugin, () -> {
             xAuthPlayer xAuthPlayer = xAuthPlugin.getPlayerManager().getPlayer(player);
             if (xAuthPlayer != null) {
                 if (xAuthPlayer.isAuthenticated()) {
-                    return true;
+                    plugin.getLog().warn(ALREADY_AUTHENTICATED, player);
+                    return false;
                 }
 
                 //we checked that the player is premium (paid account)
@@ -46,13 +52,13 @@ public class xAuthHook implements AuthPlugin<Player> {
         try {
             return future.get();
         } catch (InterruptedException | ExecutionException ex) {
-            xAuthPlugin.getLogger().log(Level.SEVERE, "Failed to forceLogin", ex);
+            plugin.getLog().error("Failed to forceLogin player: {}", player, ex);
             return false;
         }
     }
 
     @Override
-    public boolean isRegistered(String playerName) throws Exception {
+    public boolean isRegistered(String playerName) {
         //this will load the player if it's not in the cache
         xAuthPlayer xAuthPlayer = xAuthPlugin.getPlayerManager().getPlayer(playerName);
         return xAuthPlayer != null && xAuthPlayer.isRegistered();
@@ -63,22 +69,18 @@ public class xAuthHook implements AuthPlugin<Player> {
         //not thread-safe
         Future<Boolean> future = Bukkit.getScheduler().callSyncMethod(xAuthPlugin, () -> {
             xAuthPlayer xAuthPlayer = xAuthPlugin.getPlayerManager().getPlayer(player);
-            if (xAuthPlayer != null) {
-                //this should run async because the plugin executes a sql query, but the method
-                //accesses non thread-safe collections :(
+            //this should run async because the plugin executes a sql query, but the method
+            //accesses non thread-safe collections :(
+            return xAuthPlayer != null
+                    && xAuthPlugin.getAuthClass(xAuthPlayer).adminRegister(player.getName(), password, null);
 
-                return xAuthPlugin.getAuthClass(xAuthPlayer)
-                        .adminRegister(player.getName(), password, null);
-            }
-
-            return false;
         });
 
         try {
             //login in the player after registration
             return future.get() && forceLogin(player);
         } catch (InterruptedException | ExecutionException ex) {
-            xAuthPlugin.getLogger().log(Level.SEVERE, "Failed to forceLogin", ex);
+            plugin.getLog().error("Failed to forceRegister player: {}", player, ex);
             return false;
         }
     }

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hooks/AuthMeHook.java

@@ -1,74 +0,0 @@
-package com.github.games647.fastlogin.bukkit.hooks;
-
-import com.github.games647.fastlogin.core.hooks.AuthPlugin;
-
-import fr.xephi.authme.api.NewAPI;
-import fr.xephi.authme.api.v3.AuthMeApi;
-import org.bukkit.entity.Player;
-
-/**
- * Github: https://github.com/Xephi/AuthMeReloaded/
- *
- * Project page:
- *
- * Bukkit: http://dev.bukkit.org/bukkit-plugins/authme-reloaded/
- *
- * Spigot: https://www.spigotmc.org/resources/authme-reloaded.6269/
- */
-public class AuthMeHook implements AuthPlugin<Player> {
-
-    private final boolean v3APIAvailable;
-
-    public AuthMeHook() {
-        boolean apiAvailable = true;
-        try {
-            Class.forName("fr.xephi.authme.api.v3.AuthMeApi");
-        } catch (ClassNotFoundException classNotFoundEx) {
-            apiAvailable = false;
-        }
-
-        this.v3APIAvailable = apiAvailable;
-    }
-
-    @Override
-    public boolean forceLogin(Player player) {
-        if (v3APIAvailable) {
-            //skips registration and login
-            if (AuthMeApi.getInstance().isAuthenticated(player)) {
-                return false;
-            } else {
-                AuthMeApi.getInstance().forceLogin(player);
-            }
-        } else {
-            //skips registration and login
-            if (NewAPI.getInstance().isAuthenticated(player)) {
-                return false;
-            } else {
-                NewAPI.getInstance().forceLogin(player);
-            }
-        }
-
-        return true;
-    }
-
-    @Override
-    public boolean isRegistered(String playerName) throws Exception {
-        if (v3APIAvailable) {
-            return AuthMeApi.getInstance().isRegistered(playerName);
-        }
-
-        return NewAPI.getInstance().isRegistered(playerName);
-    }
-
-    @Override
-    public boolean forceRegister(Player player, String password) {
-        //this automatically registers the player too
-        if (v3APIAvailable) {
-            AuthMeApi.getInstance().forceRegister(player, password);
-        } else {
-            NewAPI.getInstance().forceRegister(player, password);
-        }
-
-        return true;
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/hooks/RoyalAuthHook.java

@@ -1,67 +0,0 @@
-package com.github.games647.fastlogin.bukkit.hooks;
-
-import com.github.games647.fastlogin.core.hooks.AuthPlugin;
-
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.logging.Level;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.royaldev.royalauth.AuthPlayer;
-import org.royaldev.royalauth.Config;
-import org.royaldev.royalauth.RoyalAuth;
-
-/**
- * Github: https://github.com/RoyalDev/RoyalAuth
- *
- * Project page:
- *
- * Bukkit: http://dev.bukkit.org/bukkit-plugins/royalauth/
- */
-public class RoyalAuthHook implements AuthPlugin<Player> {
-
-    private final Plugin royalAuthPlugin = (RoyalAuth) Bukkit.getPluginManager().getPlugin("RoyalAuth");
-
-    @Override
-    public boolean forceLogin(Player player) {
-        AuthPlayer authPlayer = AuthPlayer.getAuthPlayer(player);
-
-        Future<Boolean> future = Bukkit.getScheduler().callSyncMethod(royalAuthPlugin, () -> {
-            if (authPlayer.isLoggedIn()) {
-                return true;
-            }
-
-//https://github.com/RoyalDev/RoyalAuth/blob/master/src/main/java/org/royaldev/royalauth/commands/CmdLogin.java#L62
-//not thread-safe
-            authPlayer.login();
-
-            return authPlayer.isLoggedIn();
-        });
-
-        try {
-            return future.get();
-        } catch (InterruptedException | ExecutionException ex) {
-            royalAuthPlugin.getLogger().log(Level.SEVERE, "Failed to forceLogin", ex);
-            return false;
-        }
-    }
-
-    @Override
-    public boolean isRegistered(String playerName) throws Exception {
-        AuthPlayer authPlayer = AuthPlayer.getAuthPlayer(playerName);
-        return authPlayer.isRegistered();
-    }
-
-    @Override
-    public boolean forceRegister(Player player, String password) {
-//https://github.com/RoyalDev/RoyalAuth/blob/master/src/main/java/org/royaldev/royalauth/commands/CmdRegister.java#L50
-        AuthPlayer authPlayer = AuthPlayer.getAuthPlayer(player);
-
-        boolean registerSuccess = authPlayer.setPassword(password, Config.passwordHashType);
-
-        //login in the player after registration
-        return registerSuccess && forceLogin(player);
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/BukkitJoinListener.java

@@ -1,54 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener;
-
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.bukkit.tasks.ForceLoginTask;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerLoginEvent.Result;
-import org.bukkit.event.player.PlayerQuitEvent;
-
-/**
- * This listener tells authentication plugins if the player has a premium account and we checked it successfully. So the
- * plugin can skip authentication.
- */
-public class BukkitJoinListener implements Listener {
-
-    private static final long DELAY_LOGIN = 20L / 2;
-
-    private final FastLoginBukkit plugin;
-
-    public BukkitJoinListener(FastLoginBukkit plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerLogin(PlayerLoginEvent loginEvent) {
-        if (loginEvent.getResult() == Result.ALLOWED && !plugin.isServerFullyStarted()) {
-            loginEvent.disallow(Result.KICK_OTHER, plugin.getCore().getMessage("not-started"));
-        }
-    }
-
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerJoin(PlayerJoinEvent joinEvent) {
-        Player player = joinEvent.getPlayer();
-
-        if (!plugin.isBungeeCord()) {
-            //Wait before auth plugin and we received a message from BungeeCord initializes the player
-            Runnable forceLoginTask = new ForceLoginTask(plugin.getCore(), player);
-            Bukkit.getScheduler().runTaskLaterAsynchronously(plugin, forceLoginTask, DELAY_LOGIN);
-        }
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent quitEvent) {
-        Player player = quitEvent.getPlayer();
-        player.removeMetadata(plugin.getName(), plugin);
-        plugin.getCore().getPendingConfirms().remove(player.getUniqueId());
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/BungeeCordListener.java

@@ -1,117 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener;
-
-import com.github.games647.fastlogin.bukkit.BukkitLoginSession;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.bukkit.tasks.ForceLoginTask;
-import com.github.games647.fastlogin.core.hooks.AuthPlugin;
-import com.google.common.io.ByteArrayDataInput;
-import com.google.common.io.ByteStreams;
-
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Set;
-import java.util.UUID;
-import java.util.logging.Level;
-import java.util.stream.Collectors;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.messaging.PluginMessageListener;
-
-/**
- * Responsible for receiving messages from a BungeeCord instance.
- *
- * This class also receives the plugin message from the bungeecord version of this plugin in order to get notified if
- * the connection is in online mode.
- */
-public class BungeeCordListener implements PluginMessageListener {
-
-    private static final String FILE_NAME = "proxy-whitelist.txt";
-
-    private final FastLoginBukkit plugin;
-    //null if whitelist is empty so bungeecord support is disabled
-    private final Set<UUID> proxyIds;
-
-    public BungeeCordListener(FastLoginBukkit plugin) {
-        this.plugin = plugin;
-        this.proxyIds = loadBungeeCordIds();
-    }
-
-    @Override
-    public void onPluginMessageReceived(String channel, Player player, byte[] message) {
-        if (!channel.equals(plugin.getName())) {
-            return;
-        }
-
-        ByteArrayDataInput dataInput = ByteStreams.newDataInput(message);
-        String subChannel = dataInput.readUTF();
-        plugin.getLogger().log(Level.FINEST, "Received plugin message for sub channel {0} from {1}"
-                , new Object[]{subChannel, player});
-
-        String playerName = dataInput.readUTF();
-
-        //check if the player is still online or disconnected
-        Player checkedPlayer = plugin.getServer().getPlayerExact(playerName);
-        //fail if target player is blacklisted because already authenticated or wrong bungeecord id
-        if (checkedPlayer != null && !checkedPlayer.hasMetadata(plugin.getName())) {
-            //bungeecord UUID
-            long mostSignificantBits = dataInput.readLong();
-            long leastSignificantBits = dataInput.readLong();
-            UUID sourceId = new UUID(mostSignificantBits, leastSignificantBits);
-            plugin.getLogger().log(Level.FINEST, "Received proxy id {0} from {1}", new Object[]{sourceId, player});
-
-            //fail if BungeeCord support is disabled (id = null)
-            if (proxyIds.contains(sourceId)) {
-                readMessage(checkedPlayer, subChannel, playerName, player);
-            }
-        }
-    }
-
-    private void readMessage(Player checkedPlayer, String subchannel, String playerName, Player player) {
-        InetSocketAddress address = checkedPlayer.getAddress();
-        String id = '/' + address.getAddress().getHostAddress() + ':' + address.getPort();
-        if ("AUTO_LOGIN".equalsIgnoreCase(subchannel)) {
-            BukkitLoginSession playerSession = new BukkitLoginSession(playerName, true);
-            playerSession.setVerified(true);
-            plugin.getLoginSessions().put(id, playerSession);
-            Bukkit.getScheduler().runTaskAsynchronously(plugin, new ForceLoginTask(plugin.getCore(), player));
-        } else if ("AUTO_REGISTER".equalsIgnoreCase(subchannel)) {
-            Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
-                AuthPlugin<Player> authPlugin = plugin.getCore().getAuthPluginHook();
-                try {
-                    //we need to check if the player is registered on Bukkit too
-                    if (authPlugin == null || !authPlugin.isRegistered(playerName)) {
-                        BukkitLoginSession playerSession = new BukkitLoginSession(playerName, false);
-                        playerSession.setVerified(true);
-                        plugin.getLoginSessions().put(id, playerSession);
-                        new ForceLoginTask(plugin.getCore(), player).run();
-                    }
-                } catch (Exception ex) {
-                    plugin.getLogger().log(Level.SEVERE, "Failed to query isRegistered", ex);
-                }
-            });
-        }
-    }
-
-    public Set<UUID> loadBungeeCordIds() {
-        Path whitelistFile = plugin.getDataFolder().toPath().resolve(FILE_NAME);
-        try {
-            if (Files.notExists(whitelistFile)) {
-                Files.createFile(whitelistFile);
-            }
-
-            return Files.lines(whitelistFile)
-                    .map(String::trim)
-                    .map(UUID::fromString)
-                    .collect(Collectors.toSet());
-        } catch (IOException ex) {
-            plugin.getLogger().log(Level.SEVERE, "Failed to create file for Proxy whitelist", ex);
-        } catch (Exception ex) {
-            plugin.getLogger().log(Level.SEVERE, "Failed to retrieve proxy Id. Disabling BungeeCord support", ex);
-        }
-
-        return null;
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/ConnectionListener.java

@@ -0,0 +1,68 @@
+package com.github.games647.fastlogin.bukkit.listener;
+
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+import com.github.games647.fastlogin.bukkit.ForceLoginTask;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+/**
+ * This listener tells authentication plugins if the player has a premium account and we checked it successfully. So the
+ * plugin can skip authentication.
+ */
+public class ConnectionListener implements Listener {
+
+    private static final long DELAY_LOGIN = 20L / 2;
+
+    private final FastLoginBukkit plugin;
+
+    public ConnectionListener(FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onPlayerLogin(PlayerLoginEvent loginEvent) {
+        removeBlockedStatus(loginEvent.getPlayer());
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onPlayerJoin(PlayerJoinEvent joinEvent) {
+        Player player = joinEvent.getPlayer();
+
+        Bukkit.getScheduler().runTaskLater(plugin, () -> {
+            // session exists so the player is ready for force login
+            // cases: Paper (firing proxy message before PlayerJoinEvent) or not running proxy and already
+            // having the login session from the login process
+            BukkitLoginSession session = plugin.getSessionManager().getLoginSession(player.getAddress());
+            if (session != null) {
+                Runnable forceLoginTask = new ForceLoginTask(plugin.getCore(), player, session);
+                Bukkit.getScheduler().runTaskAsynchronously(plugin, forceLoginTask);
+            }
+
+            plugin.getProxyManager().markJoinEventFired(player);
+            // delay the login process to let auth plugins initialize the player
+            // Magic number however as there is no direct event from those plugins
+        }, DELAY_LOGIN);
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent quitEvent) {
+        Player player = quitEvent.getPlayer();
+
+        removeBlockedStatus(player);
+        plugin.getCore().getPendingConfirms().remove(player.getUniqueId());
+        plugin.getPremiumPlayers().remove(player.getUniqueId());
+        plugin.getProxyManager().cleanup(player);
+    }
+
+    private void removeBlockedStatus(Player player) {
+        player.removeMetadata(plugin.getName(), plugin);
+    }
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/PaperPreLoginListener.java

@@ -0,0 +1,42 @@
+package com.github.games647.fastlogin.bukkit.listener;
+
+import com.destroystokyo.paper.profile.ProfileProperty;
+import com.github.games647.craftapi.model.skin.Textures;
+import com.github.games647.fastlogin.bukkit.auth.BukkitLoginSession;
+import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent.Result;
+
+public class PaperPreLoginListener implements Listener {
+
+    private final FastLoginBukkit plugin;
+
+    public PaperPreLoginListener(final FastLoginBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.HIGHEST)
+    //if paper is used - player skin must be set at pre login, otherwise usercache is used
+    //using usercache makes premium name change basically impossible
+    public void onAsyncPlayerPreLogin(AsyncPlayerPreLoginEvent event) {
+        if (event.getLoginResult() != Result.ALLOWED) {
+            return;
+        }
+
+        // event gives us only IP, not the port, so we need to loop through all the sessions
+        for (BukkitLoginSession session : plugin.getSessionManager().getLoginSessions().values()) {
+            if (!event.getName().equals(session.getUsername())) {
+                continue;
+            }
+
+            session.getSkin().ifPresent(skin -> event.getPlayerProfile().setProperty(new ProfileProperty(Textures.KEY,
+                    skin.getValue(), skin.getSignature())));
+            break;
+        }
+    }
+
+}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/protocollib/LoginSkinApplyListener.java

@@ -1,74 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener.protocollib;
-
-import com.comphenix.protocol.reflect.MethodUtils;
-import com.comphenix.protocol.reflect.accessors.Accessors;
-import com.comphenix.protocol.reflect.accessors.MethodAccessor;
-import com.comphenix.protocol.utility.MinecraftReflection;
-import com.comphenix.protocol.wrappers.WrappedGameProfile;
-import com.comphenix.protocol.wrappers.WrappedSignedProperty;
-import com.github.games647.fastlogin.bukkit.BukkitLoginSession;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.logging.Level;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerLoginEvent.Result;
-
-public class LoginSkinApplyListener implements Listener {
-
-    private static final Class<?> GAME_PROFILE = MinecraftReflection.getGameProfileClass();
-
-    private static final MethodAccessor GET_PROPERTIES = Accessors.getMethodAccessor(GAME_PROFILE, "getProperties");
-
-    private final FastLoginBukkit plugin;
-
-    public LoginSkinApplyListener(FastLoginBukkit plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler(priority = EventPriority.LOW)
-    //run this on the loginEvent to let skins plugins see the skin like in normal minecraft behaviour
-    public void onPlayerLogin(PlayerLoginEvent loginEvent) {
-        if (loginEvent.getResult() != Result.ALLOWED) {
-            return;
-        }
-
-        Player player = loginEvent.getPlayer();
-
-        if (plugin.getConfig().getBoolean("forwardSkin")) {
-            //go through every session, because player.getAddress is null 
-            //loginEvent.getAddress is just a InetAddress not InetSocketAddress, so not unique enough
-            for (BukkitLoginSession session : plugin.getLoginSessions().values()) {
-                if (session.getUsername().equals(player.getName())) {
-                    String signature = session.getSkinSignature();
-                    String skinData = session.getEncodedSkinData();
-
-                    applySkin(player, skinData, signature);
-                    break;
-                }
-            }
-        }
-    }
-
-    private void applySkin(Player player, String skinData, String signature) {
-        WrappedGameProfile gameProfile = WrappedGameProfile.fromPlayer(player);
-        if (skinData != null && signature != null) {
-            WrappedSignedProperty skin = WrappedSignedProperty.fromValues("textures", skinData, signature);
-            try {
-                gameProfile.getProperties().put("textures", skin);
-            } catch (ClassCastException castException) {
-                Object map = GET_PROPERTIES.invoke(gameProfile.getHandle());
-                try {
-                    MethodUtils.invokeMethod(map, "put", new Object[]{"textures", skin.getHandle()});
-                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException ex) {
-                    plugin.getLogger().log(Level.SEVERE, "Error setting premium skin", ex);
-                }
-            }
-        }
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/protocollib/ProtocolLibListener.java

@@ -1,83 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener.protocollib;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.PacketType.Login.Client;
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.events.PacketAdapter;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-
-import java.util.Random;
-import java.util.logging.Level;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-public class ProtocolLibListener extends PacketAdapter {
-
-    private static final int WORKER_THREADS = 3;
-
-    private final FastLoginBukkit plugin;
-    //just create a new once on plugin enable. This used for verify token generation
-    private final Random random = new Random();
-
-    public ProtocolLibListener(FastLoginBukkit plugin) {
-        //run async in order to not block the server, because we are making api calls to Mojang
-        super(params().plugin(plugin)
-                .types(PacketType.Login.Client.START, PacketType.Login.Client.ENCRYPTION_BEGIN)
-                .optionAsync());
-
-        this.plugin = plugin;
-    }
-
-    public static void register(FastLoginBukkit plugin) {
-        ProtocolLibrary.getProtocolManager()
-                .getAsynchronousManager()
-                .registerAsyncHandler(new ProtocolLibListener(plugin))
-                .start(WORKER_THREADS);
-    }
-
-    @Override
-    public void onPacketReceiving(PacketEvent packetEvent) {
-        if (packetEvent.isCancelled()
-                || plugin.getCore().getAuthPluginHook()== null
-                || !plugin.isServerFullyStarted()) {
-            return;
-        }
-
-        Player sender = packetEvent.getPlayer();
-        PacketType packetType = packetEvent.getPacketType();
-        if (packetType == Client.START) {
-            onLogin(packetEvent, sender);
-        } else {
-            onEncryptionBegin(packetEvent, sender);
-        }
-    }
-
-    private void onEncryptionBegin(PacketEvent packetEvent, Player sender) {
-        byte[] sharedSecret = packetEvent.getPacket().getByteArrays().read(0);
-
-        packetEvent.getAsyncMarker().incrementProcessingDelay();
-        Runnable verifyTask = new VerifyResponseTask(plugin, packetEvent, sender, sharedSecret);
-        Bukkit.getScheduler().runTaskAsynchronously(plugin, verifyTask);
-    }
-
-    private void onLogin(PacketEvent packetEvent, Player player) {
-        //this includes ip:port. Should be unique for an incoming login request with a timeout of 2 minutes
-        String sessionKey = player.getAddress().toString();
-
-        //remove old data every time on a new login in order to keep the session only for one person
-        plugin.getLoginSessions().remove(sessionKey);
-
-        //player.getName() won't work at this state
-        PacketContainer packet = packetEvent.getPacket();
-
-        String username = packet.getGameProfiles().read(0).getName();
-        plugin.getLogger().log(Level.FINER, "Player {0} with {1} connecting", new Object[]{sessionKey, username});
-
-        packetEvent.getAsyncMarker().incrementProcessingDelay();
-        Runnable nameCheckTask = new NameCheckTask(plugin, packetEvent, random, player, username);
-        Bukkit.getScheduler().runTaskAsynchronously(plugin, nameCheckTask);
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/protocollib/ProtocolLibLoginSource.java

@@ -1,99 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener.protocollib;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.wrappers.WrappedChatComponent;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.core.shared.LoginSource;
-
-import java.lang.reflect.InvocationTargetException;
-import java.net.InetSocketAddress;
-import java.security.PublicKey;
-import java.util.Random;
-
-import org.bukkit.entity.Player;
-
-public class ProtocolLibLoginSource implements LoginSource {
-
-    private static final int VERIFY_TOKEN_LENGTH = 4;
-
-    private final FastLoginBukkit plugin;
-
-    private final PacketEvent packetEvent;
-    private final Player player;
-
-    private final Random random;
-
-    private String serverId;
-    private final byte[] verifyToken = new byte[VERIFY_TOKEN_LENGTH];
-
-    public ProtocolLibLoginSource(FastLoginBukkit plugin, PacketEvent packetEvent, Player player, Random random) {
-        this.plugin = plugin;
-        this.packetEvent = packetEvent;
-        this.player = player;
-        this.random = random;
-    }
-
-    @Override
-    public void setOnlineMode() throws Exception {
-        //randomized server id to make sure the request is for our server
-        //this could be relevant http://www.sk89q.com/2011/09/minecraft-name-spoofing-exploit/
-        serverId = Long.toString(random.nextLong(), 16);
-
-        //generate a random token which should be the same when we receive it from the client
-        random.nextBytes(verifyToken);
-        
-        sentEncryptionRequest();
-    }
-
-    @Override
-    public void kick(String message) throws Exception {
-        ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
-
-        PacketContainer kickPacket = protocolManager.createPacket(PacketType.Login.Server.DISCONNECT);
-        kickPacket.getChatComponents().write(0, WrappedChatComponent.fromText(message));
-
-        try {
-            //send kick packet at login state
-            //the normal event.getPlayer.kickPlayer(String) method does only work at play state
-            protocolManager.sendServerPacket(player, kickPacket);
-        } finally {
-            //tell the server that we want to close the connection
-            player.kickPlayer("Disconnect");
-        }
-    }
-
-    @Override
-    public InetSocketAddress getAddress() {
-        return packetEvent.getPlayer().getAddress();
-    }
-
-    private void sentEncryptionRequest() throws InvocationTargetException {
-        ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
-        /**
-         * Packet Information: http://wiki.vg/Protocol#Encryption_Request
-         *
-         * ServerID="" (String) key=public server key verifyToken=random 4 byte array
-         */
-        PacketContainer newPacket = protocolManager.createPacket(PacketType.Login.Server.ENCRYPTION_BEGIN);
-
-        newPacket.getStrings().write(0, serverId);
-        newPacket.getSpecificModifier(PublicKey.class).write(0, plugin.getServerKey().getPublic());
-
-        newPacket.getByteArrays().write(0, verifyToken);
-
-        //serverId is a empty string
-        protocolManager.sendServerPacket(player, newPacket);
-    }
-
-    public String getServerId() {
-        return serverId;
-    }
-
-    public byte[] getVerifyToken() {
-        return verifyToken;
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/protocollib/VerifyResponseTask.java

@@ -1,203 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener.protocollib;
-
-import com.comphenix.protocol.PacketType;
-import com.comphenix.protocol.ProtocolLibrary;
-import com.comphenix.protocol.ProtocolManager;
-import com.comphenix.protocol.events.PacketContainer;
-import com.comphenix.protocol.events.PacketEvent;
-import com.comphenix.protocol.injector.server.TemporaryPlayerFactory;
-import com.comphenix.protocol.reflect.FieldUtils;
-import com.comphenix.protocol.reflect.FuzzyReflection;
-import com.comphenix.protocol.wrappers.WrappedChatComponent;
-import com.comphenix.protocol.wrappers.WrappedGameProfile;
-import com.github.games647.fastlogin.bukkit.BukkitLoginSession;
-import com.github.games647.fastlogin.bukkit.EncryptionUtil;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.math.BigInteger;
-import java.security.Key;
-import java.security.PrivateKey;
-import java.util.Arrays;
-import java.util.UUID;
-import java.util.logging.Level;
-
-import javax.crypto.SecretKey;
-
-import org.bukkit.entity.Player;
-
-public class VerifyResponseTask implements Runnable {
-
-    private final FastLoginBukkit plugin;
-    private final PacketEvent packetEvent;
-
-    private final Player fromPlayer;
-
-    private final byte[] sharedSecret;
-
-    public VerifyResponseTask(FastLoginBukkit plugin, PacketEvent packetEvent, Player fromPlayer, byte[] sharedSecret) {
-        this.plugin = plugin;
-        this.packetEvent = packetEvent;
-        this.fromPlayer = fromPlayer;
-        this.sharedSecret = sharedSecret;
-    }
-
-    @Override
-    public void run() {
-        try {
-            BukkitLoginSession session = plugin.getLoginSessions().get(fromPlayer.getAddress().toString());
-            if (session == null) {
-                disconnect(plugin.getCore().getMessage("invalid-request"), true
-                        , "Player {0} tried to send encryption response at invalid state", fromPlayer.getAddress());
-            } else {
-                verifyResponse(session);
-            }
-        } finally {
-            //this is a fake packet; it shouldn't be send to the server
-            synchronized (packetEvent.getAsyncMarker().getProcessingLock()) {
-                packetEvent.setCancelled(true);
-            }
-
-            ProtocolLibrary.getProtocolManager().getAsynchronousManager().signalPacketTransmission(packetEvent);
-        }
-    }
-
-    private void verifyResponse(BukkitLoginSession session) {
-        PrivateKey privateKey = plugin.getServerKey().getPrivate();
-
-        SecretKey loginKey = EncryptionUtil.decryptSharedKey(privateKey, sharedSecret);
-        if (!checkVerifyToken(session, privateKey) || !encryptConnection(loginKey)) {
-            return;
-        }
-
-        //this makes sure the request from the client is for us
-        //this might be relevant http://www.sk89q.com/2011/09/minecraft-name-spoofing-exploit/
-        String generatedId = session.getServerId();
-
-        //https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/LoginListener.java#L193
-        //generate the server id based on client and server data
-        byte[] serverIdHash = EncryptionUtil.getServerIdHash(generatedId, plugin.getServerKey().getPublic(), loginKey);
-        String serverId = (new BigInteger(serverIdHash)).toString(16);
-
-        String username = session.getUsername();
-        if (plugin.getCore().getApiConnector().hasJoinedServer(session, serverId, fromPlayer.getAddress())) {
-            plugin.getLogger().log(Level.INFO, "Player {0} has a verified premium account", username);
-
-            session.setVerified(true);
-            setPremiumUUID(session.getUuid());
-            receiveFakeStartPacket(username);
-        } else {
-            //user tried to fake a authentication
-            disconnect(plugin.getCore().getMessage("invalid-session"), true
-                    , "Player {0} ({1}) tried to log in with an invalid session ServerId: {2}"
-                    , session.getUsername(), fromPlayer.getAddress(), serverId);
-        }
-    }
-
-    private void setPremiumUUID(UUID premiumUUID) {
-        if (plugin.getConfig().getBoolean("premiumUuid") && premiumUUID != null) {
-            try {
-                Object networkManager = getNetworkManager();
-                //https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/NetworkManager.java#L69
-                FieldUtils.writeField(networkManager, "spoofedUUID", premiumUUID, true);
-            } catch (Exception exc) {
-                plugin.getLogger().log(Level.SEVERE, "Error setting premium uuid", exc);
-            }
-        }
-    }
-
-    private boolean checkVerifyToken(BukkitLoginSession session, Key privateKey) {
-        byte[] requestVerify = session.getVerifyToken();
-        //encrypted verify token
-        byte[] responseVerify = packetEvent.getPacket().getByteArrays().read(1);
-
-        //https://github.com/bergerkiller/CraftSource/blob/master/net.minecraft.server/LoginListener.java#L182
-        if (!Arrays.equals(requestVerify, EncryptionUtil.decryptData(privateKey, responseVerify))) {
-            //check if the verify token are equal to the server sent one
-            disconnect(plugin.getCore().getMessage("invalid-verify-token"), true
-                    , "Player {0} ({1}) tried to login with an invalid verify token. Server: {2} Client: {3}"
-                    , session.getUsername(), packetEvent.getPlayer().getAddress(), requestVerify, responseVerify);
-            return false;
-        }
-
-        return true;
-    }
-
-    //try to get the networkManager from ProtocolLib
-    private Object getNetworkManager() throws IllegalAccessException, NoSuchFieldException, ClassNotFoundException {
-        Object injectorContainer = TemporaryPlayerFactory.getInjectorFromPlayer(fromPlayer);
-
-        //ChannelInjector
-        Class<?> injectorClass = Class.forName("com.comphenix.protocol.injector.netty.Injector");
-        Object rawInjector = FuzzyReflection.getFieldValue(injectorContainer, injectorClass, true);
-        return FieldUtils.readField(rawInjector, "networkManager", true);
-    }
-
-    private boolean encryptConnection(SecretKey loginKey) throws IllegalArgumentException {
-        try {
-            //get the NMS connection handle of this player
-            Object networkManager = getNetworkManager();
-
-            //try to detect the method by parameters
-            Method encryptMethod = FuzzyReflection
-                    .fromObject(networkManager).getMethodByParameters("a", SecretKey.class);
-
-            //encrypt/decrypt following packets
-            //the client expects this behaviour
-            encryptMethod.invoke(networkManager, loginKey);
-        } catch (Exception ex) {
-            plugin.getLogger().log(Level.SEVERE, "Couldn't enable encryption", ex);
-            disconnect(plugin.getCore().getMessage("error-kick"), false, "Couldn't enable encryption");
-            return false;
-        }
-
-        return true;
-    }
-
-    private void disconnect(String kickReason, boolean debug, String logMessage, Object... arguments) {
-        if (debug) {
-            plugin.getLogger().log(Level.FINE, logMessage, arguments);
-        } else {
-            plugin.getLogger().log(Level.SEVERE, logMessage, arguments);
-        }
-
-        kickPlayer(packetEvent.getPlayer(), kickReason);
-    }
-
-    private void kickPlayer(Player player, String reason) {
-        ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
-
-        PacketContainer kickPacket = protocolManager.createPacket(PacketType.Login.Server.DISCONNECT);
-        kickPacket.getChatComponents().write(0, WrappedChatComponent.fromText(reason));
-        try {
-            //send kick packet at login state
-            //the normal event.getPlayer.kickPlayer(String) method does only work at play state
-            protocolManager.sendServerPacket(player, kickPacket);
-            //tell the server that we want to close the connection
-            player.kickPlayer("Disconnect");
-        } catch (InvocationTargetException ex) {
-            plugin.getLogger().log(Level.SEVERE, "Error sending kick packet", ex);
-        }
-    }
-
-    //fake a new login packet in order to let the server handle all the other stuff
-    private void receiveFakeStartPacket(String username) {
-        ProtocolManager protocolManager = ProtocolLibrary.getProtocolManager();
-        
-        //see StartPacketListener for packet information
-        PacketContainer startPacket = protocolManager.createPacket(PacketType.Login.Client.START);
-
-        //uuid is ignored by the packet definition
-        WrappedGameProfile fakeProfile = new WrappedGameProfile(UUID.randomUUID(), username);
-        startPacket.getGameProfiles().write(0, fakeProfile);
-        try {
-            //we don't want to handle our own packets so ignore filters
-            protocolManager.recieveClientPacket(fromPlayer, startPacket, false);
-        } catch (InvocationTargetException | IllegalAccessException ex) {
-            plugin.getLogger().log(Level.WARNING, "Failed to fake a new start packet", ex);
-            //cancel the event in order to prevent the server receiving an invalid packet
-            kickPlayer(fromPlayer, plugin.getCore().getMessage("error-kick"));
-        }
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/listener/protocolsupport/ProtocolSupportListener.java

@@ -1,73 +0,0 @@
-package com.github.games647.fastlogin.bukkit.listener.protocolsupport;
-
-import com.github.games647.fastlogin.bukkit.BukkitLoginSession;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.core.PlayerProfile;
-import com.github.games647.fastlogin.core.shared.JoinManagement;
-
-import java.net.InetSocketAddress;
-
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import protocolsupport.api.events.PlayerLoginStartEvent;
-import protocolsupport.api.events.PlayerPropertiesResolveEvent;
-
-public class ProtocolSupportListener extends JoinManagement<Player, CommandSender, ProtocolLoginSource>
-        implements Listener {
-
-    private final FastLoginBukkit plugin;
-
-    public ProtocolSupportListener(FastLoginBukkit plugin) {
-        super(plugin.getCore(), plugin.getCore().getAuthPluginHook());
-
-        this.plugin = plugin;
-    }
-
-    @EventHandler
-    public void onLoginStart(PlayerLoginStartEvent loginStartEvent) {
-        if (loginStartEvent.isLoginDenied() || plugin.getCore().getAuthPluginHook() == null) {
-            return;
-        }
-
-        String username = loginStartEvent.getName();
-        InetSocketAddress address = loginStartEvent.getAddress();
-
-        //remove old data every time on a new login in order to keep the session only for one person
-        plugin.getLoginSessions().remove(address.toString());
-
-        super.onLogin(username, new ProtocolLoginSource(loginStartEvent));
-    }
-
-    @EventHandler
-    public void onPropertiesResolve(PlayerPropertiesResolveEvent propertiesResolveEvent) {
-        InetSocketAddress address = propertiesResolveEvent.getAddress();
-        BukkitLoginSession session = plugin.getLoginSessions().get(address.toString());
-
-        //skin was resolved -> premium player
-        if (propertiesResolveEvent.hasProperty("textures") && session != null) {
-            session.setVerified(true);
-        }
-    }
-
-    @Override
-    public void requestPremiumLogin(ProtocolLoginSource source, PlayerProfile profile, String username, boolean registered) {
-        source.setOnlineMode();
-
-        String ip = source.getAddress().getAddress().getHostAddress();
-        plugin.getCore().getPendingLogin().put(ip + username, new Object());
-
-        BukkitLoginSession playerSession = new BukkitLoginSession(username, null, null, registered, profile);
-        plugin.getLoginSessions().put(source.getAddress().toString(), playerSession);
-        if (plugin.getConfig().getBoolean("premiumUuid")) {
-            source.getLoginStartEvent().setUseOnlineModeUUID(true);
-        }
-    }
-
-    @Override
-    public void startCrackedSession(ProtocolLoginSource source, PlayerProfile profile, String username) {
-        BukkitLoginSession loginSession = new BukkitLoginSession(username, profile);
-        plugin.getLoginSessions().put(source.getAddress().toString(), loginSession);
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/tasks/DelayedAuthHook.java

@@ -1,79 +0,0 @@
-package com.github.games647.fastlogin.bukkit.tasks;
-
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.bukkit.hooks.AuthMeHook;
-import com.github.games647.fastlogin.bukkit.hooks.CrazyLoginHook;
-import com.github.games647.fastlogin.bukkit.hooks.LogItHook;
-import com.github.games647.fastlogin.bukkit.hooks.LoginSecurityHook;
-import com.github.games647.fastlogin.bukkit.hooks.UltraAuthHook;
-import com.github.games647.fastlogin.bukkit.hooks.xAuthHook;
-import com.github.games647.fastlogin.core.hooks.AuthPlugin;
-import com.google.common.collect.Lists;
-
-import java.util.List;
-import java.util.logging.Level;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-public class DelayedAuthHook implements Runnable {
-
-    private final FastLoginBukkit plugin;
-
-    public DelayedAuthHook(FastLoginBukkit plugin) {
-        this.plugin = plugin;
-    }
-
-    @Override
-    public void run() {
-        boolean hookFound = plugin.getCore().getAuthPluginHook() != null || registerHooks();
-        if (plugin.isBungeeCord()) {
-            plugin.getLogger().info("BungeeCord setting detected. No auth plugin is required");
-        } else if (!hookFound) {
-            plugin.getLogger().warning("No auth plugin were found by this plugin "
-                    + "(other plugins could hook into this after the initialization of this plugin)"
-                    + "and BungeeCord is deactivated. "
-                    + "Either one or both of the checks have to pass in order to use this plugin");
-        }
-
-        if (hookFound) {
-            plugin.setServerStarted();
-        }
-    }
-
-    private boolean registerHooks() {
-        AuthPlugin<Player> authPluginHook = null;
-
-        try {
-            @SuppressWarnings("unchecked")
-            List<Class<? extends AuthPlugin<Player>>> supportedHooks = Lists.newArrayList(AuthMeHook.class
-                    , CrazyLoginHook.class, LogItHook.class, LoginSecurityHook.class, UltraAuthHook.class
-                    , xAuthHook.class);
-
-            for (Class<? extends AuthPlugin<Player>> clazz : supportedHooks) {
-                String pluginName = clazz.getSimpleName().replace("Hook", "");
-                //uses only member classes which uses AuthPlugin interface (skip interfaces)
-                if (Bukkit.getServer().getPluginManager().getPlugin(pluginName) != null) {
-                    //check only for enabled plugins. A single plugin could be disabled by plugin managers
-                    authPluginHook = clazz.newInstance();
-                    plugin.getLogger().log(Level.INFO, "Hooking into auth plugin: {0}", pluginName);
-                    break;
-                }
-            }
-        } catch (InstantiationException | IllegalAccessException ex) {
-            plugin.getLogger().log(Level.SEVERE, "Couldn't load the integration class", ex);
-        }
-
-        if (authPluginHook == null) {
-            //run this check for exceptions (errors) and not found plugins
-            plugin.getLogger().warning("No support offline Auth plugin found. ");
-            return false;
-        }
-
-        if (plugin.getCore().getAuthPluginHook() == null) {
-            plugin.getCore().setAuthPluginHook(authPluginHook);
-        }
-
-        return true;
-    }
-}

bukkit/src/main/java/com/github/games647/fastlogin/bukkit/tasks/ForceLoginTask.java

@@ -1,68 +0,0 @@
-package com.github.games647.fastlogin.bukkit.tasks;
-
-import com.github.games647.fastlogin.bukkit.BukkitLoginSession;
-import com.github.games647.fastlogin.bukkit.FastLoginBukkit;
-import com.github.games647.fastlogin.core.shared.FastLoginCore;
-import com.github.games647.fastlogin.core.shared.ForceLoginManagement;
-import com.github.games647.fastlogin.core.shared.LoginSession;
-import com.google.common.io.ByteArrayDataOutput;
-import com.google.common.io.ByteStreams;
-
-import java.util.concurrent.ExecutionException;
-import java.util.logging.Level;
-
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.metadata.FixedMetadataValue;
-
-public class ForceLoginTask extends ForceLoginManagement<Player, CommandSender, BukkitLoginSession, FastLoginBukkit> {
-
-    public ForceLoginTask(FastLoginCore<Player, CommandSender, FastLoginBukkit> core, Player player) {
-        super(core, player);
-    }
-
-    @Override
-    public void run() {
-        //remove the bungeecord identifier if there is ones
-        String id = '/' + player.getAddress().getAddress().getHostAddress() + ':' + player.getAddress().getPort();
-        session = core.getPlugin().getLoginSessions().remove(id);
-
-        //blacklist this target player for BungeeCord Id brute force attacks
-        FastLoginBukkit plugin = core.getPlugin();
-        player.setMetadata(core.getPlugin().getName(), new FixedMetadataValue(plugin, true));
-
-        super.run();
-    }
-
-    @Override
-    public void onForceActionSuccess(LoginSession session) {
-        if (core.getPlugin().isBungeeCord()) {
-            ByteArrayDataOutput dataOutput = ByteStreams.newDataOutput();
-            dataOutput.writeUTF("SUCCESS");
-
-            player.sendPluginMessage(core.getPlugin(), core.getPlugin().getName(), dataOutput.toByteArray());
-        }
-    }
-
-    @Override
-    public String getName(Player player) {
-        return player.getName();
-    }
-
-    @Override
-    public boolean isOnline(Player player) {
-        try {
-            //the playerlist isn't thread-safe
-            return Bukkit.getScheduler().callSyncMethod(core.getPlugin(), player::isOnline).get();
-        } catch (InterruptedException | ExecutionException ex) {
-            core.getPlugin().getLogger().log(Level.SEVERE, "Failed to perform thread-safe online check", ex);
-            return false;
-        }
-    }
-
-    @Override
-    public boolean isOnlineMode() {
-        return session.isVerified() && player.getName().equals(session.getUsername());
-    }
-}

bukkit/src/main/resources/plugin.yml

@@ -1,7 +1,7 @@
 # project data for Bukkit in order to register our plugin with all it components
 # ${-} are variables from Maven (pom.xml) which will be replaced after the build
 name: ${project.parent.name}
-version: ${project.version}-git${git.commit.id}
+version: ${project.version}-${git.commit.id.abbrev}
 main: ${project.groupId}.${project.artifactId}.${project.name}
 
 # meta data for plugin managers
@@ -11,14 +11,22 @@ description: |
 website: ${project.url}
 dev-url: ${project.url}
 
-# Load the plugin as early as possible to inject it for all players
-load: STARTUP
+# This plugin don't have to be transformed for compatibility with Minecraft >= 1.13
+api-version: '1.13'
 
 softdepend:
     # We depend either ProtocolLib or ProtocolSupport
     - ProtocolSupport
     - ProtocolLib
+    # Premium variable
     - PlaceholderAPI
+    # Auth plugins
+    - AuthMe
+    - LoginSecurity
+    - xAuth
+    - LogIt
+    - UltraAuth
+    - CrazyLogin
 
 commands:
     ${project.parent.name}:
@@ -28,7 +36,7 @@ commands:
         permission: ${project.artifactId}.command.premium
 
     cracked:
-        description: 'Label the invoker or the player specified as cracked if he was marked premium before'
+        description: 'Label the invoker or the player specified as cracked if marked premium before'
         aliases: [unpremium]
         usage: /<command> [player]
         permission: ${project.artifactId}.command.cracked

bukkit/src/test/java/com/github/games647/fastlogin/bukkit/listener/protocollib/EncryptionUtilTest.java

@@ -0,0 +1,43 @@
+package com.github.games647.fastlogin.bukkit.listener.protocollib;
+
+import com.github.games647.fastlogin.bukkit.auth.protocollib.EncryptionUtil;
+
+import java.security.SecureRandom;
+
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+public class EncryptionUtilTest {
+
+    @Test
+    public void testVerifyToken() throws Exception {
+        SecureRandom random = new SecureRandom();
+        byte[] token = EncryptionUtil.generateVerifyToken(random);
+
+        assertThat(token, notNullValue());
+        assertThat(token.length, is(4));
+    }
+
+    // @Test
+    // public void testDecryptSharedSecret() throws Exception {
+    //
+    // }
+    //
+    // @Test
+    // public void testDecryptData() throws Exception {
+    //
+    // }
+
+    // private static SecretKey createNewSharedKey() {
+    //     try {
+    //         KeyGenerator keygenerator = KeyGenerator.getInstance("AES");
+    //         keygenerator.init(128);
+    //         return keygenerator.generateKey();
+    //     } catch (NoSuchAlgorithmException nosuchalgorithmexception) {
+    //         throw new Error(nosuchalgorithmexception);
+    //     }
+    // }
+}

bungee/pom.xml

@@ -1,11 +1,11 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
         <groupId>com.github.games647</groupId>
         <artifactId>fastlogin</artifactId>
-        <version>1.10</version>
+        <version>1.11-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -16,44 +16,100 @@
     <!--Represents the main plugin-->
     <name>FastLoginBungee</name>
 
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.4</version>
+                <configuration>
+                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                    <shadedArtifactAttached>false</shadedArtifactAttached>
+                    <artifactSet>
+                        <excludes>
+                            <!--Those classes are already present in BungeeCord version-->
+                            <exclude>net.md-5:bungeecord-config</exclude>
+                            <exclude>com.google.code.gson:gson</exclude>
+                        </excludes>
+                    </artifactSet>
+                    <relocations>
+                        <relocation>
+                            <pattern>com.zaxxer.hikari</pattern>
+                            <shadedPattern>fastlogin.hikari</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>org.slf4j</pattern>
+                            <shadedPattern>fastlogin.slf4j</shadedPattern>
+                        </relocation>
+                    </relocations>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+
     <repositories>
-        <!--BungeeCord with also the part outside the API-->
         <repository>
-            <id>luck-repo</id>
-            <url>https://ci.lucko.me/plugin/repository/everything</url>
+            <id>codemc-repo</id>
+            <url>https://repo.codemc.io/repository/maven-public/</url>
         </repository>
 
         <repository>
-            <id>vik1395-repo</id>
-            <url>http://repo.vik1395.me/repositories</url>
+            <id>nukkitx-repo</id>
+            <url>https://repo.nukkitx.com/maven-snapshots/</url>
+        </repository>
+
+        <repository>
+            <id>spigotplugins-repo</id>
+            <url>https://maven.gamestrike.de/mvn/</url>
         </repository>
     </repositories>
 
     <dependencies>
+        <!--Common plugin component-->
         <dependency>
             <groupId>${project.groupId}</groupId>
             <artifactId>fastlogin.core</artifactId>
             <version>${project.version}</version>
-            <scope>provided</scope>
         </dependency>
 
+        <!--BungeeCord with also the part outside the API-->
         <dependency>
             <groupId>net.md-5</groupId>
             <artifactId>bungeecord-proxy</artifactId>
-            <version>1.12-SNAPSHOT</version>
+            <version>1.16-R0.5-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
 
+        <!-- Bedrock player bridge -->
+        <dependency>
+            <groupId>org.geysermc</groupId>
+            <artifactId>floodgate-bungee</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!--Login plugin-->
         <dependency>
             <groupId>me.vik1395</groupId>
             <artifactId>BungeeAuth</artifactId>
             <version>1.4</version>
-            <exclusions>
-                <exclusion>
-                    <groupId>*</groupId>
-                    <artifactId>*</artifactId>
-                </exclusion>
-            </exclusions>
+            <scope>system</scope>
+            <systemPath>${project.basedir}/lib/BungeeAuth-1.4.jar</systemPath>
+        </dependency>
+
+        <dependency>
+            <groupId>de.xxschrandxx.bca</groupId>
+            <artifactId>BungeeCordAuthenticator</artifactId>
+            <version>0.0.2-SNAPSHOT</version>
+            <scope>provided</scope>
         </dependency>
     </dependencies>
 </project>

bungee/src/main/java/com/github/games647/fastlogin/bungee/BungeeLoginSession.java

@@ -1,34 +1,43 @@
 package com.github.games647.fastlogin.bungee;
 
-import com.github.games647.fastlogin.core.PlayerProfile;
-import com.github.games647.fastlogin.core.shared.LoginSession;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSession;
 
 public class BungeeLoginSession extends LoginSession {
 
     private boolean alreadySaved;
     private boolean alreadyLogged;
 
-    public BungeeLoginSession(String username, boolean registered, PlayerProfile profile) {
+    public BungeeLoginSession(String username, boolean registered, StoredProfile profile) {
         super(username, registered, profile);
     }
 
-    public void setRegistered(boolean registered) {
+    public synchronized void setRegistered(boolean registered) {
         this.registered = registered;
     }
 
-    public boolean isAlreadySaved() {
+    public synchronized boolean isAlreadySaved() {
         return alreadySaved;
     }
 
-    public void setAlreadySaved(boolean alreadySaved) {
+    public synchronized void setAlreadySaved(boolean alreadySaved) {
         this.alreadySaved = alreadySaved;
     }
 
-    public boolean isAlreadyLogged() {
+    public synchronized boolean isAlreadyLogged() {
         return alreadyLogged;
     }
 
-    public void setAlreadyLogged(boolean alreadyLogged) {
+    public synchronized void setAlreadyLogged(boolean alreadyLogged) {
         this.alreadyLogged = alreadyLogged;
     }
+
+    @Override
+    public synchronized String toString() {
+        return this.getClass().getSimpleName() + '{' +
+                "alreadySaved=" + alreadySaved +
+                ", alreadyLogged=" + alreadyLogged +
+                ", registered=" + registered +
+                "} " + super.toString();
+    }
 }

bungee/src/main/java/com/github/games647/fastlogin/bungee/BungeeLoginSource.java

@@ -1,18 +1,23 @@
 package com.github.games647.fastlogin.bungee;
 
-import com.github.games647.fastlogin.core.shared.LoginSource;
+import com.github.games647.fastlogin.core.auth.LoginSource;
 
 import java.net.InetSocketAddress;
 
+import net.md_5.bungee.api.ChatColor;
+import net.md_5.bungee.api.chat.ComponentBuilder;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.PendingConnection;
+import net.md_5.bungee.api.event.PreLoginEvent;
 
 public class BungeeLoginSource implements LoginSource {
 
     private final PendingConnection connection;
+    private final PreLoginEvent preLoginEvent;
 
-    public BungeeLoginSource(PendingConnection connection) {
+    public BungeeLoginSource(PendingConnection connection, PreLoginEvent preLoginEvent) {
         this.connection = connection;
+        this.preLoginEvent = preLoginEvent;
     }
 
     @Override
@@ -22,7 +27,13 @@ public class BungeeLoginSource implements LoginSource {
 
     @Override
     public void kick(String message) {
-        connection.disconnect(TextComponent.fromLegacyText(message));
+        preLoginEvent.setCancelled(true);
+
+        if (message == null) {
+            preLoginEvent.setCancelReason(new ComponentBuilder("Kicked").color(ChatColor.WHITE).create());
+        } else {
+            preLoginEvent.setCancelReason(TextComponent.fromLegacyText(message));
+        }
     }
 
     @Override
@@ -33,4 +44,11 @@ public class BungeeLoginSource implements LoginSource {
     public PendingConnection getConnection() {
         return connection;
     }
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + '{' +
+                "connection=" + connection +
+                '}';
+    }
 }

bungee/src/main/java/com/github/games647/fastlogin/bungee/BungeeSessionManager.java

@@ -0,0 +1,23 @@
+package com.github.games647.fastlogin.bungee;
+
+import com.github.games647.fastlogin.core.SessionManager;
+
+import java.util.UUID;
+
+import net.md_5.bungee.api.connection.PendingConnection;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.event.PlayerDisconnectEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.event.EventHandler;
+
+public class BungeeSessionManager extends SessionManager<PlayerDisconnectEvent, PendingConnection, BungeeLoginSession>
+        implements Listener {
+
+    //todo: memory leak on cancelled login event
+    @EventHandler
+    public void onPlayQuit(PlayerDisconnectEvent disconnectEvent) {
+        ProxiedPlayer player = disconnectEvent.getPlayer();
+        UUID playerId = player.getUniqueId();
+        endPlaySession(playerId);
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/FastLoginBungee.java

@@ -1,44 +1,50 @@
 package com.github.games647.fastlogin.bungee;
 
-import com.github.games647.fastlogin.bungee.hooks.BungeeAuthHook;
-import com.github.games647.fastlogin.bungee.listener.PlayerConnectionListener;
+import com.github.games647.fastlogin.bungee.hook.BungeeAuthHook;
+import com.github.games647.fastlogin.bungee.hook.BungeeCordAuthenticatorHook;
+import com.github.games647.fastlogin.bungee.listener.ConnectListener;
 import com.github.games647.fastlogin.bungee.listener.PluginMessageListener;
+import com.github.games647.fastlogin.core.AsyncScheduler;
+import com.github.games647.fastlogin.core.CommonUtil;
+import com.github.games647.fastlogin.core.message.ChangePremiumMessage;
+import com.github.games647.fastlogin.core.message.ChannelMessage;
+import com.github.games647.fastlogin.core.message.NamespaceKey;
+import com.github.games647.fastlogin.core.message.SuccessMessage;
 import com.github.games647.fastlogin.core.shared.FastLoginCore;
-import com.github.games647.fastlogin.core.shared.MojangApiConnector;
 import com.github.games647.fastlogin.core.shared.PlatformPlugin;
-import com.google.common.collect.Maps;
+import com.google.common.io.ByteArrayDataOutput;
+import com.google.common.io.ByteStreams;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
 
-import java.io.Reader;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentMap;
+import java.nio.file.Path;
 import java.util.concurrent.ThreadFactory;
-import java.util.function.Function;
-import java.util.logging.Logger;
-import java.util.stream.Collectors;
 
-import net.md_5.bungee.api.ChatColor;
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.chat.TextComponent;
-import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.connection.Server;
 import net.md_5.bungee.api.plugin.Plugin;
+import net.md_5.bungee.api.plugin.PluginManager;
 import net.md_5.bungee.api.scheduler.GroupedThreadFactory;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
+
+import org.slf4j.Logger;
 
 /**
  * BungeeCord version of FastLogin. This plugin keeps track on online mode connections.
  */
 public class FastLoginBungee extends Plugin implements PlatformPlugin<CommandSender> {
 
-    private final ConcurrentMap<PendingConnection, BungeeLoginSession> session = Maps.newConcurrentMap();
+    private final BungeeSessionManager sessionManager = new BungeeSessionManager();
 
     private FastLoginCore<ProxiedPlayer, CommandSender, FastLoginBungee> core;
+    private AsyncScheduler scheduler;
+    private Logger logger;
 
     @Override
     public void onEnable() {
+        logger = CommonUtil.createLoggerFromJDK(getLogger());
+        scheduler = new AsyncScheduler(logger, getThreadFactory());
+
         core = new FastLoginCore<>(this);
         core.load();
         if (!core.setupDatabase()) {
@@ -46,11 +52,16 @@ public class FastLoginBungee extends Plugin implements PlatformPlugin<CommandSen
         }
 
         //events
-        getProxy().getPluginManager().registerListener(this, new PlayerConnectionListener(this));
-        getProxy().getPluginManager().registerListener(this, new PluginMessageListener(this));
+        PluginManager pluginManager = getProxy().getPluginManager();
+        boolean floodgateAvail = pluginManager.getPlugin("floodgate") != null;
+        ConnectListener connectListener = new ConnectListener(this, core.getRateLimiter(), floodgateAvail);
 
-        //this is required to listen to messages from the server
-        getProxy().registerChannel(getDescription().getName());
+        pluginManager.registerListener(this, connectListener);
+        pluginManager.registerListener(this, new PluginMessageListener(this));
+
+        //this is required to listen to incoming messages from the server
+        getProxy().registerChannel(NamespaceKey.getCombined(getName(), ChangePremiumMessage.CHANGE_CHANNEL));
+        getProxy().registerChannel(NamespaceKey.getCombined(getName(), SuccessMessage.SUCCESS_CHANNEL));
 
         registerHook();
     }
@@ -66,15 +77,27 @@ public class FastLoginBungee extends Plugin implements PlatformPlugin<CommandSen
         return core;
     }
 
-    public ConcurrentMap<PendingConnection, BungeeLoginSession> getSession() {
-        return session;
+    private void registerHook() {
+        Plugin BungeeAuth = getProxy().getPluginManager().getPlugin("BungeeAuth");
+        if (BungeeAuth != null) {
+            core.setAuthPluginHook(new BungeeAuthHook());
+            logger.info("Hooked into BungeeAuth");
+        }
+        Plugin BungeeCordAuthenticatorBungee = getProxy().getPluginManager().getPlugin("BungeeCordAuthenticatorBungee");
+        if (BungeeCordAuthenticatorBungee != null) {
+            logger.info("Try to hook into BungeeCordAuthenticatorBungee...");
+            BungeeCordAuthenticatorHook hook = new BungeeCordAuthenticatorHook(BungeeCordAuthenticatorBungee, logger);
+            core.setAuthPluginHook(hook);
+        }
     }
 
-    private void registerHook() {
-        Plugin plugin = getProxy().getPluginManager().getPlugin("BungeeAuth");
-        if (plugin != null) {
-            core.setAuthPluginHook(new BungeeAuthHook());
-            getLogger().info("Hooked into BungeeAuth");
+    public void sendPluginMessage(Server server, ChannelMessage message) {
+        if (server != null) {
+            ByteArrayDataOutput dataOutput = ByteStreams.newDataOutput();
+            message.writeTo(dataOutput);
+
+            NamespaceKey channel = new NamespaceKey(getName(), message.getChannelName());
+            server.sendData(channel.getCombinedName(), dataOutput.toByteArray());
         }
     }
 
@@ -84,12 +107,13 @@ public class FastLoginBungee extends Plugin implements PlatformPlugin<CommandSen
     }
 
     @Override
-    public Map<String, Object> loadYamlFile(Reader reader) {
-        ConfigurationProvider configProvider = ConfigurationProvider.getProvider(YamlConfiguration.class);
-        Configuration config = configProvider.load(reader);
-        return config.getKeys().stream()
-                .filter(key -> config.get(key) != null)
-                .collect(Collectors.toMap(Function.identity(), config::get));
+    public Path getPluginFolder() {
+        return getDataFolder().toPath();
+    }
+
+    @Override
+    public Logger getLog() {
+        return logger;
     }
 
     @Override
@@ -97,20 +121,19 @@ public class FastLoginBungee extends Plugin implements PlatformPlugin<CommandSen
         receiver.sendMessage(TextComponent.fromLegacyText(message));
     }
 
-    @Override
-    public String translateColorCodes(char colorChar, String rawMessage) {
-        return ChatColor.translateAlternateColorCodes(colorChar, rawMessage);
-    }
-
     @Override
     @SuppressWarnings("deprecation")
     public ThreadFactory getThreadFactory() {
-        return new GroupedThreadFactory(this, getName());
+        return new ThreadFactoryBuilder()
+                .setNameFormat(getName() + " Pool Thread #%1$d")
+                //Hikari create daemons by default
+                .setDaemon(true)
+                .setThreadFactory(new GroupedThreadFactory(this, getName()))
+                .build();
     }
 
     @Override
-    public MojangApiConnector makeApiConnector(Logger logger, List<String> addresses, int requests
-            , Map<String, Integer> proxies) {
-        return new MojangApiBungee(logger, addresses, requests, proxies);
+    public AsyncScheduler getScheduler() {
+        return scheduler;
     }
 }

bungee/src/main/java/com/github/games647/fastlogin/bungee/MojangApiBungee.java

@@ -1,43 +0,0 @@
-package com.github.games647.fastlogin.bungee;
-
-import com.github.games647.fastlogin.core.shared.LoginSession;
-import com.github.games647.fastlogin.core.shared.MojangApiConnector;
-
-import java.net.InetSocketAddress;
-import java.util.List;
-import java.util.Map;
-import java.util.logging.Logger;
-
-import net.md_5.bungee.BungeeCord;
-
-public class MojangApiBungee extends MojangApiConnector {
-
-    public MojangApiBungee(Logger logger, List<String> localAddresses, int rateLimit, Map<String, Integer> proxies) {
-        super(logger, localAddresses, rateLimit, proxies);
-    }
-
-    @Override
-    protected String getUUIDFromJson(String json) {
-        boolean isArray = json.startsWith("[");
-
-        MojangPlayer mojangPlayer;
-        if (isArray) {
-            mojangPlayer = BungeeCord.getInstance().gson.fromJson(json, MojangPlayer[].class)[0];
-        } else {
-            mojangPlayer = BungeeCord.getInstance().gson.fromJson(json, MojangPlayer.class);
-        }
-
-        String id = mojangPlayer.getId();
-        if ("null".equals(id)) {
-            return null;
-        }
-
-        return id;
-    }
-
-    @Override
-    public boolean hasJoinedServer(LoginSession session, String serverId, InetSocketAddress ip) {
-        //this is not needed in Bungee
-        throw new UnsupportedOperationException("Not supported");
-    }
-}

bungee/src/main/java/com/github/games647/fastlogin/bungee/MojangPlayer.java

@@ -1,15 +0,0 @@
-package com.github.games647.fastlogin.bungee;
-
-public class MojangPlayer {
-
-    private String id;
-    private String name;
-
-    public String getId() {
-        return id;
-    }
-
-    public String getName() {
-        return name;
-    }
-}

bungee/src/main/java/com/github/games647/fastlogin/bungee/event/BungeeFastLoginAutoLoginEvent.java

@@ -0,0 +1,39 @@
+package com.github.games647.fastlogin.bungee.event;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSession;
+import com.github.games647.fastlogin.core.shared.event.FastLoginAutoLoginEvent;
+import net.md_5.bungee.api.plugin.Cancellable;
+import net.md_5.bungee.api.plugin.Event;
+
+public class BungeeFastLoginAutoLoginEvent extends Event implements FastLoginAutoLoginEvent, Cancellable {
+
+    private final LoginSession session;
+    private final StoredProfile profile;
+    private boolean cancelled;
+
+    public BungeeFastLoginAutoLoginEvent(LoginSession session, StoredProfile profile) {
+        this.session = session;
+        this.profile = profile;
+    }
+
+    @Override
+    public LoginSession getSession() {
+        return session;
+    }
+
+    @Override
+    public StoredProfile getProfile() {
+        return profile;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/event/BungeeFastLoginPreLoginEvent.java

@@ -0,0 +1,34 @@
+package com.github.games647.fastlogin.bungee.event;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSource;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPreLoginEvent;
+import net.md_5.bungee.api.plugin.Event;
+
+public class BungeeFastLoginPreLoginEvent extends Event implements FastLoginPreLoginEvent {
+
+    private final String username;
+    private final LoginSource source;
+    private final StoredProfile profile;
+
+    public BungeeFastLoginPreLoginEvent(String username, LoginSource source, StoredProfile profile) {
+        this.username = username;
+        this.source = source;
+        this.profile = profile;
+    }
+
+    @Override
+    public String getUsername() {
+        return username;
+    }
+
+    @Override
+    public LoginSource getSource() {
+        return source;
+    }
+
+    @Override
+    public StoredProfile getProfile() {
+        return profile;
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/event/BungeeFastLoginPremiumToggleEvent.java

@@ -0,0 +1,26 @@
+package com.github.games647.fastlogin.bungee.event;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPremiumToggleEvent;
+import net.md_5.bungee.api.plugin.Event;
+
+public class BungeeFastLoginPremiumToggleEvent extends Event implements FastLoginPremiumToggleEvent {
+
+    private final StoredProfile profile;
+    private final PremiumToggleReason reason;
+
+    public BungeeFastLoginPremiumToggleEvent(StoredProfile profile, PremiumToggleReason reason) {
+        this.profile = profile;
+        this.reason = reason;
+    }
+
+    @Override
+    public StoredProfile getProfile() {
+        return profile;
+    }
+
+    @Override
+    public FastLoginPremiumToggleEvent.PremiumToggleReason getReason() {
+        return reason;
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/hook/BungeeAuthHook.java

@@ -1,4 +1,4 @@
-package com.github.games647.fastlogin.bungee.hooks;
+package com.github.games647.fastlogin.bungee.hook;
 
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
 
@@ -8,7 +8,7 @@ import me.vik1395.BungeeAuthAPI.RequestHandler;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 
 /**
- * Github: https://github.com/vik1395/BungeeAuth-Minecraft
+ * GitHub: https://github.com/vik1395/BungeeAuth-Minecraft
  *
  * Project page:
  *
@@ -21,15 +21,11 @@ public class BungeeAuthHook implements AuthPlugin<ProxiedPlayer> {
     @Override
     public boolean forceLogin(ProxiedPlayer player) {
         String playerName = player.getName();
-        if (Main.plonline.contains(playerName)) {
-            return true;
-        }
-
-        return requestHandler.forceLogin(playerName);
+        return Main.plonline.contains(playerName) || requestHandler.forceLogin(playerName);
     }
 
     @Override
-    public boolean isRegistered(String playerName) throws Exception {
+    public boolean isRegistered(String playerName) {
         return requestHandler.isRegistered(playerName);
     }
 

bungee/src/main/java/com/github/games647/fastlogin/bungee/hook/BungeeCordAuthenticatorHook.java

@@ -0,0 +1,70 @@
+package com.github.games647.fastlogin.bungee.hook;
+
+import java.sql.SQLException;
+
+import com.github.games647.fastlogin.core.hooks.AuthPlugin;
+
+import org.slf4j.Logger;
+
+import de.xxschrandxx.bca.bungee.BungeeCordAuthenticatorBungee;
+import de.xxschrandxx.bca.bungee.api.BungeeCordAuthenticatorBungeeAPI;
+
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.plugin.Plugin;
+
+/**
+ * GitHub:
+ * https://github.com/xXSchrandXx/SpigotPlugins/tree/master/BungeeCordAuthenticator
+ *
+ * Project page:
+ *
+ * Spigot: https://www.spigotmc.org/resources/bungeecordauthenticator.87669/
+ */
+public class BungeeCordAuthenticatorHook implements AuthPlugin<ProxiedPlayer> {
+
+    public final BungeeCordAuthenticatorBungeeAPI api;
+
+    public BungeeCordAuthenticatorHook(Plugin plugin, Logger logger) {
+        BungeeCordAuthenticatorBungee bcab = (BungeeCordAuthenticatorBungee) plugin;
+        api = bcab.getAPI();
+        logger.info("BungeeCordAuthenticatorHook | Hooked successful!");
+    }
+
+    @Override
+    public boolean forceLogin(ProxiedPlayer player) {
+        if (api.isAuthenticated(player)) {
+            return true;
+        } else {
+            try {
+                api.setAuthenticated(player);
+            }
+            catch (SQLException e) {
+                e.printStackTrace();
+                return false;
+            }
+            return true;
+        }
+    }
+
+    @Override
+    public boolean isRegistered(String playerName) {
+        try {
+            return api.getSQL().checkPlayerEntry(playerName);
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
+    @Override
+    public boolean forceRegister(ProxiedPlayer player, String password) {
+        try {
+            return api.createPlayerEntry(player, password);
+        }
+        catch (SQLException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/listener/ConnectListener.java

@@ -0,0 +1,191 @@
+package com.github.games647.fastlogin.bungee.listener;
+
+import com.github.games647.craftapi.UUIDAdapter;
+import com.github.games647.fastlogin.bungee.BungeeLoginSession;
+import com.github.games647.fastlogin.bungee.FastLoginBungee;
+import com.github.games647.fastlogin.bungee.task.AsyncPremiumCheck;
+import com.github.games647.fastlogin.bungee.task.ForceLoginTask;
+import com.github.games647.fastlogin.core.auth.RateLimiter;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.LoginSession;
+import com.google.common.base.Throwables;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodHandles.Lookup;
+import java.lang.reflect.Field;
+import java.util.UUID;
+
+import net.md_5.bungee.api.connection.PendingConnection;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.connection.Server;
+import net.md_5.bungee.api.event.LoginEvent;
+import net.md_5.bungee.api.event.PlayerDisconnectEvent;
+import net.md_5.bungee.api.event.PreLoginEvent;
+import net.md_5.bungee.api.event.ServerConnectedEvent;
+import net.md_5.bungee.api.plugin.Listener;
+import net.md_5.bungee.connection.InitialHandler;
+import net.md_5.bungee.connection.LoginResult;
+import net.md_5.bungee.connection.LoginResult.Property;
+import net.md_5.bungee.event.EventHandler;
+import net.md_5.bungee.event.EventPriority;
+
+import org.geysermc.floodgate.FloodgateAPI;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Enables online mode logins for specified users and sends plugin message to the Bukkit version of this plugin in
+ * order to clear that the connection is online mode.
+ */
+public class ConnectListener implements Listener {
+
+    private static final String UUID_FIELD_NAME = "uniqueId";
+    private static final boolean initialHandlerClazzFound;
+    private static final MethodHandle uniqueIdSetter;
+
+    static {
+        MethodHandle setHandle = null;
+        boolean handlerFound = false;
+        try {
+            Lookup lookup = MethodHandles.lookup();
+
+            Class.forName("net.md_5.bungee.connection.InitialHandler");
+            handlerFound = true;
+
+            Field uuidField = InitialHandler.class.getDeclaredField(UUID_FIELD_NAME);
+            uuidField.setAccessible(true);
+            setHandle = lookup.unreflectSetter(uuidField);
+        } catch (ClassNotFoundException classNotFoundException) {
+            Logger logger = LoggerFactory.getLogger(ConnectListener.class);
+            logger.error(
+                    "Cannot find Bungee initial handler; Disabling premium UUID and skin won't work.",
+                    classNotFoundException
+            );
+        } catch (ReflectiveOperationException reflectiveOperationException) {
+            reflectiveOperationException.printStackTrace();
+        }
+
+        initialHandlerClazzFound = handlerFound;
+        uniqueIdSetter = setHandle;
+    }
+
+    private final FastLoginBungee plugin;
+    private final RateLimiter rateLimiter;
+    private final Property[] emptyProperties = {};
+    private final boolean floodGateAvailable;
+
+    public ConnectListener(FastLoginBungee plugin, RateLimiter rateLimiter, boolean floodgateAvailable) {
+        this.plugin = plugin;
+        this.rateLimiter = rateLimiter;
+        this.floodGateAvailable = floodgateAvailable;
+    }
+
+    @EventHandler
+    public void onPreLogin(PreLoginEvent preLoginEvent) {
+        PendingConnection connection = preLoginEvent.getConnection();
+        if (preLoginEvent.isCancelled() || isBedrockPlayer(connection.getUniqueId())) {
+            return;
+        }
+
+        if (!rateLimiter.tryAcquire()) {
+            plugin.getLog().warn("Join limit hit - Ignoring player {}", connection);
+            return;
+        }
+
+        String username = connection.getName();
+        plugin.getLog().info("Incoming login request for {} from {}", username, connection.getSocketAddress());
+
+        preLoginEvent.registerIntent(plugin);
+        Runnable asyncPremiumCheck = new AsyncPremiumCheck(plugin, preLoginEvent, connection, username);
+        plugin.getScheduler().runAsync(asyncPremiumCheck);
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onLogin(LoginEvent loginEvent) {
+        if (loginEvent.isCancelled()) {
+            return;
+        }
+
+        //use the login event instead of the post login event in order to send the login success packet to the client
+        //with the offline uuid this makes it possible to set the skin then
+        PendingConnection connection = loginEvent.getConnection();
+        if (connection.isOnlineMode()) {
+            LoginSession session = plugin.getSession().get(connection);
+
+            UUID verifiedUUID = connection.getUniqueId();
+            String verifiedUsername = connection.getName();
+            session.setUuid(verifiedUUID);
+            session.setVerifiedUsername(verifiedUsername);
+
+            StoredProfile playerProfile = session.getProfile();
+            playerProfile.setId(verifiedUUID);
+
+            // bungeecord will do this automatically so override it on disabled option
+            if (uniqueIdSetter != null) {
+                InitialHandler initialHandler = (InitialHandler) connection;
+
+                if (!plugin.getCore().getConfig().get("premiumUuid", true)) {
+                    setOfflineId(initialHandler, verifiedUsername);
+                }
+
+                if (!plugin.getCore().getConfig().get("forwardSkin", true)) {
+                    // this is null on offline mode
+                    LoginResult loginProfile = initialHandler.getLoginProfile();
+                    loginProfile.setProperties(emptyProperties);
+                }
+            }
+        }
+    }
+
+    private void setOfflineId(InitialHandler connection, String username) {
+        try {
+            final UUID oldPremiumId = connection.getUniqueId();
+            final UUID offlineUUID = UUIDAdapter.generateOfflineId(username);
+
+            // BungeeCord only allows setting the UUID in PreLogin events and before requesting online mode
+            // However if online mode is requested, it will override previous values
+            // So we have to do it with reflection
+            uniqueIdSetter.invokeExact(connection, offlineUUID);
+
+            String format = "Overridden UUID from {} to {} (based of {}) on {}";
+            plugin.getLog().info(format, oldPremiumId, offlineUUID, username, connection);
+        } catch (Exception ex) {
+            plugin.getLog().error("Failed to set offline uuid of {}", username, ex);
+        } catch (Throwable throwable) {
+            // throw remaining exceptions like outofmemory that we shouldn't handle ourself
+            Throwables.throwIfUnchecked(throwable);
+        }
+    }
+
+    @EventHandler
+    public void onServerConnected(ServerConnectedEvent serverConnectedEvent) {
+        ProxiedPlayer player = serverConnectedEvent.getPlayer();
+        Server server = serverConnectedEvent.getServer();
+
+        BungeeLoginSession session = plugin.getSession().get(player.getPendingConnection());
+        if (session == null) {
+            return;
+        }
+
+        // delay sending force command, because Paper will process the login event asynchronously
+        // In this case it means that the force command (plugin message) is already received and processed while
+        // player is still in the login phase and reported to be offline.
+        Runnable loginTask = new ForceLoginTask(plugin.getCore(), player, server, session);
+        plugin.getScheduler().runAsync(loginTask);
+    }
+
+    @EventHandler
+    public void onDisconnect(PlayerDisconnectEvent disconnectEvent) {
+        ProxiedPlayer player = disconnectEvent.getPlayer();
+        plugin.getSession().remove(player.getPendingConnection());
+        plugin.getCore().getPendingConfirms().remove(player.getUniqueId());
+    }
+
+    private boolean isBedrockPlayer(UUID correctedUUID) {
+        // Floodgate will set a correct UUID at the beginning of the PreLoginEvent
+        // and will cancel the online mode login for those players
+        // Therefore we just ignore those
+        return floodGateAvailable && FloodgateAPI.isBedrockPlayer(correctedUUID);
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/listener/PlayerConnectionListener.java

@@ -1,114 +0,0 @@
-package com.github.games647.fastlogin.bungee.listener;
-
-import com.github.games647.fastlogin.bungee.FastLoginBungee;
-import com.github.games647.fastlogin.bungee.tasks.AsyncPremiumCheck;
-import com.github.games647.fastlogin.bungee.tasks.ForceLoginTask;
-import com.github.games647.fastlogin.core.PlayerProfile;
-import com.github.games647.fastlogin.core.shared.LoginSession;
-import com.google.common.base.Charsets;
-
-import java.lang.reflect.Field;
-import java.util.UUID;
-import java.util.logging.Level;
-
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.connection.PendingConnection;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.connection.Server;
-import net.md_5.bungee.api.event.LoginEvent;
-import net.md_5.bungee.api.event.PlayerDisconnectEvent;
-import net.md_5.bungee.api.event.PreLoginEvent;
-import net.md_5.bungee.api.event.ServerConnectedEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.connection.InitialHandler;
-import net.md_5.bungee.connection.LoginResult;
-import net.md_5.bungee.connection.LoginResult.Property;
-import net.md_5.bungee.event.EventHandler;
-import net.md_5.bungee.event.EventPriority;
-
-/**
- * Enables online mode logins for specified users and sends
- * plugin message to the Bukkit version of this plugin in
- * order to clear that the connection is online mode.
- */
-public class PlayerConnectionListener implements Listener {
-
-    private final FastLoginBungee plugin;
-
-    public PlayerConnectionListener(FastLoginBungee plugin) {
-        this.plugin = plugin;
-    }
-
-    @EventHandler
-    public void onPreLogin(PreLoginEvent preLoginEvent) {
-        if (preLoginEvent.isCancelled()) {
-            return;
-        }
-
-        preLoginEvent.registerIntent(plugin);
-        
-        PendingConnection connection = preLoginEvent.getConnection();
-        Runnable asyncPremiumCheck = new AsyncPremiumCheck(plugin, preLoginEvent, connection);
-        ProxyServer.getInstance().getScheduler().runAsync(plugin, asyncPremiumCheck);
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onLogin(LoginEvent loginEvent) {
-        if (loginEvent.isCancelled()) {
-            return;
-        }
-
-        //use the login event instead of the postlogin event in order to send the loginsuccess packet to the client
-        //with the offline uuid this makes it possible to set the skin then
-        PendingConnection connection = loginEvent.getConnection();
-        InitialHandler initialHandler = (InitialHandler) connection;
-
-        String username = initialHandler.getLoginRequest().getData();
-        if (connection.isOnlineMode()) {
-            LoginSession session = plugin.getSession().get(connection);
-            session.setUuid(connection.getUniqueId());
-
-            PlayerProfile playerProfile = session.getProfile();
-            playerProfile.setUuid(connection.getUniqueId());
-
-            //bungeecord will do this automatically so override it on disabled option
-            if (!plugin.getCore().getConfig().get("premiumUuid", true)) {
-                try {
-                    UUID offlineUUID = UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes(Charsets.UTF_8));
-
-                    //bungeecord doesn't support overriding the premium uuid
-                    //so we have to do it with reflection
-                    Field idField = InitialHandler.class.getDeclaredField("uniqueId");
-                    idField.setAccessible(true);
-                    idField.set(connection, offlineUUID);
-                } catch (NoSuchFieldException | IllegalAccessException ex) {
-                    plugin.getLogger().log(Level.SEVERE, "Failed to set offline uuid", ex);
-                }
-            }
-
-            if (!plugin.getCore().getConfig().get("forwardSkin", true)) {
-                //this is null on offline mode
-                LoginResult loginProfile = initialHandler.getLoginProfile();
-                if (loginProfile != null) {
-                    loginProfile.setProperties(new Property[]{});
-                }
-            }
-        }
-    }
-
-    @EventHandler
-    public void onServerConnected(ServerConnectedEvent serverConnectedEvent) {
-        ProxiedPlayer player = serverConnectedEvent.getPlayer();
-        Server server = serverConnectedEvent.getServer();
-
-        Runnable loginTask = new ForceLoginTask(plugin.getCore(), player, server);
-        ProxyServer.getInstance().getScheduler().runAsync(plugin, loginTask);
-    }
-
-    @EventHandler
-    public void onDisconnect(PlayerDisconnectEvent disconnectEvent) {
-        ProxiedPlayer player = disconnectEvent.getPlayer();
-        plugin.getSession().remove(player.getPendingConnection());
-        plugin.getCore().getPendingConfirms().remove(player.getUniqueId());
-    }
-}

bungee/src/main/java/com/github/games647/fastlogin/bungee/listener/PluginMessageListener.java

@@ -2,8 +2,11 @@ package com.github.games647.fastlogin.bungee.listener;
 
 import com.github.games647.fastlogin.bungee.BungeeLoginSession;
 import com.github.games647.fastlogin.bungee.FastLoginBungee;
-import com.github.games647.fastlogin.bungee.tasks.AsyncToggleMessage;
-import com.github.games647.fastlogin.core.PlayerProfile;
+import com.github.games647.fastlogin.bungee.task.AsyncToggleMessage;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.message.ChangePremiumMessage;
+import com.github.games647.fastlogin.core.message.NamespaceKey;
+import com.github.games647.fastlogin.core.message.SuccessMessage;
 import com.github.games647.fastlogin.core.shared.FastLoginCore;
 import com.google.common.io.ByteArrayDataInput;
 import com.google.common.io.ByteStreams;
@@ -11,7 +14,6 @@ import com.google.common.io.ByteStreams;
 import java.util.Arrays;
 
 import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.chat.TextComponent;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
 import net.md_5.bungee.api.connection.Server;
@@ -23,14 +25,20 @@ public class PluginMessageListener implements Listener {
 
     private final FastLoginBungee plugin;
 
+    private final String successChannel;
+    private final String changeChannel;
+
     public PluginMessageListener(FastLoginBungee plugin) {
         this.plugin = plugin;
+
+        this.successChannel = new NamespaceKey(plugin.getName(), SuccessMessage.SUCCESS_CHANNEL).getCombinedName();
+        this.changeChannel = new NamespaceKey(plugin.getName(), ChangePremiumMessage.CHANGE_CHANNEL).getCombinedName();
     }
 
     @EventHandler
     public void onPluginMessage(PluginMessageEvent pluginMessageEvent) {
         String channel = pluginMessageEvent.getTag();
-        if (pluginMessageEvent.isCancelled() || !plugin.getDescription().getName().equals(channel)) {
+        if (pluginMessageEvent.isCancelled() || !channel.startsWith(plugin.getName().toLowerCase())) {
             return;
         }
 
@@ -38,45 +46,47 @@ public class PluginMessageListener implements Listener {
         //moreover the client shouldn't be able fake a running premium check by sending the result message
         pluginMessageEvent.setCancelled(true);
 
-        //check if the message is sent from the server
-        if (Server.class.isAssignableFrom(pluginMessageEvent.getSender().getClass())) {
-            //so that we can safely process this in the background
-            byte[] data = Arrays.copyOf(pluginMessageEvent.getData(), pluginMessageEvent.getData().length);
-            ProxiedPlayer forPlayer = (ProxiedPlayer) pluginMessageEvent.getReceiver();
-            
-            ProxyServer.getInstance().getScheduler().runAsync(plugin, () -> readMessage(forPlayer, data));
+        if (!(pluginMessageEvent.getSender() instanceof Server)) {
+            //check if the message is sent from the server
+            return;
         }
+
+        //so that we can safely process this in the background
+        byte[] data = Arrays.copyOf(pluginMessageEvent.getData(), pluginMessageEvent.getData().length);
+        ProxiedPlayer forPlayer = (ProxiedPlayer) pluginMessageEvent.getReceiver();
+
+        plugin.getScheduler().runAsync(() -> readMessage(forPlayer, channel, data));
     }
 
-    private void readMessage(ProxiedPlayer forPlayer, byte[] data) {
+    private void readMessage(ProxiedPlayer forPlayer, String channel, byte[] data) {
         FastLoginCore<ProxiedPlayer, CommandSender, FastLoginBungee> core = plugin.getCore();
 
         ByteArrayDataInput dataInput = ByteStreams.newDataInput(data);
-        String subchannel = dataInput.readUTF();
-        if ("SUCCESS".equals(subchannel)) {
+        if (successChannel.equals(channel)) {
             onSuccessMessage(forPlayer);
-        } else if ("ON".equals(subchannel)) {
-            String playerName = dataInput.readUTF();
-            boolean isPlayerSender = dataInput.readBoolean();
+        } else if (changeChannel.equals(channel)) {
+            ChangePremiumMessage changeMessage = new ChangePremiumMessage();
+            changeMessage.readFrom(dataInput);
 
-            if (playerName.equals(forPlayer.getName()) && plugin.getCore().getConfig().get("premium-warning", true)
-                    && !core.getPendingConfirms().contains(forPlayer.getUniqueId())) {
-                String message = core.getMessage("premium-warning");
-                forPlayer.sendMessage(TextComponent.fromLegacyText(message));
-                core.getPendingConfirms().add(forPlayer.getUniqueId());
-                return;
+            String playerName = changeMessage.getPlayerName();
+            boolean isSourceInvoker = changeMessage.isSourceInvoker();
+            if (changeMessage.shouldEnable()) {
+                if (playerName.equals(forPlayer.getName()) && plugin.getCore().getConfig().get("premium-warning", true)
+                        && !core.getPendingConfirms().contains(forPlayer.getUniqueId())) {
+                    String message = core.getMessage("premium-warning");
+                    forPlayer.sendMessage(TextComponent.fromLegacyText(message));
+                    core.getPendingConfirms().add(forPlayer.getUniqueId());
+                    return;
+                }
+
+                core.getPendingConfirms().remove(forPlayer.getUniqueId());
+                Runnable task = new AsyncToggleMessage(core, forPlayer, playerName, true, isSourceInvoker);
+                plugin.getScheduler().runAsync(task);
+            } else {
+                Runnable task = new AsyncToggleMessage(core, forPlayer, playerName, false, isSourceInvoker);
+                plugin.getScheduler().runAsync(task);
             }
-
-            core.getPendingConfirms().remove(forPlayer.getUniqueId());
-            Runnable task = new AsyncToggleMessage(core, forPlayer, playerName, true, isPlayerSender);
-            ProxyServer.getInstance().getScheduler().runAsync(plugin, task);
-        } else if ("OFF".equals(subchannel)) {
-            String playerName = dataInput.readUTF();
-            boolean isPlayerSender = dataInput.readBoolean();
-
-            Runnable task = new AsyncToggleMessage(core, forPlayer, playerName, false, isPlayerSender);
-            ProxyServer.getInstance().getScheduler().runAsync(plugin, task);
-        } 
+        }
     }
 
     private void onSuccessMessage(ProxiedPlayer forPlayer) {
@@ -84,7 +94,7 @@ public class PluginMessageListener implements Listener {
             //bukkit module successfully received and force logged in the user
             //update only on success to prevent corrupt data
             BungeeLoginSession loginSession = plugin.getSession().get(forPlayer.getPendingConnection());
-            PlayerProfile playerProfile = loginSession.getProfile();
+            StoredProfile playerProfile = loginSession.getProfile();
             loginSession.setRegistered(true);
 
             if (!loginSession.isAlreadySaved()) {

bungee/src/main/java/com/github/games647/fastlogin/bungee/task/AsyncPremiumCheck.java

@@ -1,48 +1,58 @@
-package com.github.games647.fastlogin.bungee.tasks;
+package com.github.games647.fastlogin.bungee.task;
 
 import com.github.games647.fastlogin.bungee.BungeeLoginSession;
 import com.github.games647.fastlogin.bungee.BungeeLoginSource;
 import com.github.games647.fastlogin.bungee.FastLoginBungee;
-import com.github.games647.fastlogin.core.PlayerProfile;
-import com.github.games647.fastlogin.core.shared.JoinManagement;
+import com.github.games647.fastlogin.bungee.event.BungeeFastLoginPreLoginEvent;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.auth.JoinManagement;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPreLoginEvent;
 
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.connection.PendingConnection;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.AsyncEvent;
-import net.md_5.bungee.connection.InitialHandler;
+import net.md_5.bungee.api.event.PreLoginEvent;
 
 public class AsyncPremiumCheck extends JoinManagement<ProxiedPlayer, CommandSender, BungeeLoginSource>
         implements Runnable {
 
     private final FastLoginBungee plugin;
-    private final AsyncEvent<?> preLoginEvent;
+    private final PreLoginEvent preLoginEvent;
 
+    private final String username;
     private final PendingConnection connection;
 
-    public AsyncPremiumCheck(FastLoginBungee plugin, AsyncEvent<?> preLoginEvent, PendingConnection connection) {
+    public AsyncPremiumCheck(FastLoginBungee plugin, PreLoginEvent preLoginEvent, PendingConnection connection,
+                             String username) {
         super(plugin.getCore(), plugin.getCore().getAuthPluginHook());
 
         this.plugin = plugin;
         this.preLoginEvent = preLoginEvent;
         this.connection = connection;
+        this.username = username;
     }
 
     @Override
     public void run() {
         plugin.getSession().remove(connection);
 
-        InitialHandler initialHandler = (InitialHandler) connection;
-        String username = initialHandler.getLoginRequest().getData();
         try {
-            super.onLogin(username, new BungeeLoginSource(connection));
+            super.onLogin(username, new BungeeLoginSource(connection, preLoginEvent));
         } finally {
             preLoginEvent.completeIntent(plugin);
         }
     }
 
     @Override
-    public void requestPremiumLogin(BungeeLoginSource source, PlayerProfile profile, String username, boolean registered) {
+    public FastLoginPreLoginEvent callFastLoginPreLoginEvent(String username, BungeeLoginSource source,
+                                                             StoredProfile profile) {
+        return plugin.getProxy().getPluginManager()
+                .callEvent(new BungeeFastLoginPreLoginEvent(username, source, profile));
+    }
+
+    @Override
+    public void requestPremiumLogin(BungeeLoginSource source, StoredProfile profile,
+                                    String username, boolean registered) {
         source.setOnlineMode();
         plugin.getSession().put(source.getConnection(), new BungeeLoginSession(username, registered, profile));
 
@@ -51,7 +61,7 @@ public class AsyncPremiumCheck extends JoinManagement<ProxiedPlayer, CommandSend
     }
 
     @Override
-    public void startCrackedSession(BungeeLoginSource source, PlayerProfile profile, String username) {
+    public void startCrackedSession(BungeeLoginSource source, StoredProfile profile, String username) {
         plugin.getSession().put(source.getConnection(), new BungeeLoginSession(username, false, profile));
     }
 }

bungee/src/main/java/com/github/games647/fastlogin/bungee/task/AsyncToggleMessage.java

@@ -1,9 +1,11 @@
-package com.github.games647.fastlogin.bungee.tasks;
+package com.github.games647.fastlogin.bungee.task;
 
 import com.github.games647.fastlogin.bungee.FastLoginBungee;
-import com.github.games647.fastlogin.core.PlayerProfile;
+import com.github.games647.fastlogin.bungee.event.BungeeFastLoginPremiumToggleEvent;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
 import com.github.games647.fastlogin.core.shared.FastLoginCore;
 
+import com.github.games647.fastlogin.core.shared.event.FastLoginPremiumToggleEvent.PremiumToggleReason;
 import net.md_5.bungee.api.CommandSender;
 import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.chat.TextComponent;
@@ -36,21 +38,25 @@ public class AsyncToggleMessage implements Runnable {
     }
 
     private void turnOffPremium() {
-        PlayerProfile playerProfile = core.getStorage().loadProfile(targetPlayer);
+        StoredProfile playerProfile = core.getStorage().loadProfile(targetPlayer);
         //existing player is already cracked
-        if (playerProfile.getUserId() != -1 && !playerProfile.isPremium()) {
+        if (playerProfile.isSaved() && !playerProfile.isPremium()) {
             sendMessage("not-premium");
             return;
         }
 
         playerProfile.setPremium(false);
-        playerProfile.setUuid(null);
+        playerProfile.setId(null);
         core.getStorage().save(playerProfile);
+        PremiumToggleReason reason = (!isPlayerSender || !sender.getName().equalsIgnoreCase(playerProfile.getName())) ?
+                PremiumToggleReason.COMMAND_OTHER : PremiumToggleReason.COMMAND_SELF;
+        core.getPlugin().getProxy().getPluginManager().callEvent(
+                new BungeeFastLoginPremiumToggleEvent(playerProfile, reason));
         sendMessage("remove-premium");
     }
 
     private void activatePremium() {
-        PlayerProfile playerProfile = core.getStorage().loadProfile(targetPlayer);
+        StoredProfile playerProfile = core.getStorage().loadProfile(targetPlayer);
         if (playerProfile.isPremium()) {
             sendMessage("already-exists");
             return;
@@ -58,6 +64,10 @@ public class AsyncToggleMessage implements Runnable {
 
         playerProfile.setPremium(true);
         core.getStorage().save(playerProfile);
+        PremiumToggleReason reason = (!isPlayerSender || !sender.getName().equalsIgnoreCase(playerProfile.getName())) ?
+                PremiumToggleReason.COMMAND_OTHER : PremiumToggleReason.COMMAND_SELF;
+        core.getPlugin().getProxy().getPluginManager().callEvent(
+                new BungeeFastLoginPremiumToggleEvent(playerProfile, reason));
         sendMessage("add-premium");
     }
 

bungee/src/main/java/com/github/games647/fastlogin/bungee/task/ForceLoginTask.java

@@ -0,0 +1,96 @@
+package com.github.games647.fastlogin.bungee.task;
+
+import com.github.games647.fastlogin.bungee.BungeeLoginSession;
+import com.github.games647.fastlogin.bungee.FastLoginBungee;
+import com.github.games647.fastlogin.bungee.event.BungeeFastLoginAutoLoginEvent;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.message.ChannelMessage;
+import com.github.games647.fastlogin.core.message.LoginActionMessage;
+import com.github.games647.fastlogin.core.message.LoginActionMessage.Type;
+import com.github.games647.fastlogin.core.shared.FastLoginCore;
+import com.github.games647.fastlogin.core.auth.ForceLoginManagement;
+import com.github.games647.fastlogin.core.auth.LoginSession;
+import com.github.games647.fastlogin.core.shared.event.FastLoginAutoLoginEvent;
+
+import java.util.UUID;
+
+import net.md_5.bungee.api.CommandSender;
+import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
+import net.md_5.bungee.api.connection.Server;
+
+public class ForceLoginTask
+        extends ForceLoginManagement<ProxiedPlayer, CommandSender, BungeeLoginSession, FastLoginBungee> {
+
+    private final Server server;
+
+    public ForceLoginTask(FastLoginCore<ProxiedPlayer, CommandSender, FastLoginBungee> core,
+                          ProxiedPlayer player, Server server, BungeeLoginSession session) {
+        super(core, player, session);
+
+        this.server = server;
+    }
+
+    @Override
+    public void run() {
+        if (session == null) {
+            return;
+        }
+
+        super.run();
+
+        if (!isOnlineMode()) {
+            session.setAlreadySaved(true);
+        }
+    }
+
+    @Override
+    public boolean forceLogin(ProxiedPlayer player) {
+        if (session.isAlreadyLogged()) {
+            return true;
+        }
+
+        session.setAlreadyLogged(true);
+        return super.forceLogin(player);
+    }
+
+    @Override
+    public FastLoginAutoLoginEvent callFastLoginAutoLoginEvent(LoginSession session, StoredProfile profile) {
+        return core.getPlugin().getProxy().getPluginManager()
+                .callEvent(new BungeeFastLoginAutoLoginEvent(session, profile));
+    }
+
+    @Override
+    public boolean forceRegister(ProxiedPlayer player) {
+        return session.isAlreadyLogged() || super.forceRegister(player);
+    }
+
+    @Override
+    public void onForceActionSuccess(LoginSession session) {
+        //sub channel name
+        Type type = Type.LOGIN;
+        if (session.needsRegistration()) {
+            type = Type.REGISTER;
+        }
+
+        UUID proxyId = UUID.fromString(ProxyServer.getInstance().getConfig().getUuid());
+        ChannelMessage loginMessage = new LoginActionMessage(type, player.getName(), proxyId);
+
+        core.getPlugin().sendPluginMessage(server, loginMessage);
+    }
+
+    @Override
+    public String getName(ProxiedPlayer player) {
+        return player.getName();
+    }
+
+    @Override
+    public boolean isOnline(ProxiedPlayer player) {
+        return player.isConnected();
+    }
+
+    @Override
+    public boolean isOnlineMode() {
+        return player.getPendingConnection().isOnlineMode();
+    }
+}

bungee/src/main/java/com/github/games647/fastlogin/bungee/tasks/ForceLoginTask.java

@@ -1,101 +0,0 @@
-package com.github.games647.fastlogin.bungee.tasks;
-
-import com.github.games647.fastlogin.bungee.BungeeLoginSession;
-import com.github.games647.fastlogin.bungee.FastLoginBungee;
-import com.github.games647.fastlogin.core.shared.FastLoginCore;
-import com.github.games647.fastlogin.core.shared.ForceLoginManagement;
-import com.github.games647.fastlogin.core.shared.LoginSession;
-import com.google.common.io.ByteArrayDataOutput;
-import com.google.common.io.ByteStreams;
-
-import java.util.UUID;
-
-import net.md_5.bungee.api.CommandSender;
-import net.md_5.bungee.api.connection.PendingConnection;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.connection.Server;
-
-public class ForceLoginTask extends ForceLoginManagement<ProxiedPlayer, CommandSender, BungeeLoginSession, FastLoginBungee> {
-
-    private final Server server;
-
-    public ForceLoginTask(FastLoginCore<ProxiedPlayer, CommandSender, FastLoginBungee> core,
-             ProxiedPlayer player, Server server) {
-        super(core, player);
-
-        this.server = server;
-    }
-
-    @Override
-    public void run() {
-        PendingConnection pendingConnection = player.getPendingConnection();
-        session = core.getPlugin().getSession().get(pendingConnection);
-
-        if (session == null) {
-            return;
-        }
-
-        super.run();
-
-        if (!isOnlineMode()) {
-            session.setAlreadySaved(true);
-        }
-    }
-
-    @Override
-    public boolean forceLogin(ProxiedPlayer player) {
-        if (session.isAlreadyLogged()) {
-            return true;
-        }
-
-        session.setAlreadyLogged(true);
-        return super.forceLogin(player);
-    }
-
-    @Override
-    public boolean forceRegister(ProxiedPlayer player) {
-        if (session.isAlreadyLogged()) {
-            return true;
-        }
-
-        return super.forceRegister(player);
-    }
-
-    @Override
-    public void onForceActionSuccess(LoginSession session) {
-        ByteArrayDataOutput dataOutput = ByteStreams.newDataOutput();
-        //sub channel name
-        if (session.needsRegistration()) {
-            dataOutput.writeUTF("AUTO_REGISTER");
-        } else {
-            dataOutput.writeUTF("AUTO_LOGIN");
-        }
-
-        //Data is sent through a random player. We have to tell the Bukkit version of this plugin the target
-        dataOutput.writeUTF(player.getName());
-
-        //proxy identifier to check if it's a acceptable proxy
-        UUID proxyId = UUID.fromString(core.getPlugin().getProxy().getConfig().getUuid());
-        dataOutput.writeLong(proxyId.getMostSignificantBits());
-        dataOutput.writeLong(proxyId.getLeastSignificantBits());
-
-        if (server != null) {
-            server.sendData(core.getPlugin().getName(), dataOutput.toByteArray());
-        }
-    }
-
-    @Override
-    public String getName(ProxiedPlayer player) {
-        return player.getName();
-    }
-
-    @Override
-    public boolean isOnline(ProxiedPlayer player) {
-        return player.isConnected();
-    }
-
-    @Override
-    public boolean isOnlineMode() {
-        return player.getPendingConnection().isOnlineMode();
-    }
-}

bungee/src/main/resources/bungee.yml

@@ -5,12 +5,13 @@ name: ${project.parent.name}
 # ${-} will be automatically replaced by Maven
 main: ${project.groupId}.${project.artifactId}.${project.name}
 
-version: ${project.version}-git${git.commit.id}
-author: games647, http://github.com/games647/FastLogin/graphs/contributors
+version: ${project.version}-${git.commit.id.abbrev}
+author: games647, https://github.com/games647/FastLogin/graphs/contributors
 
 softDepends:
     # BungeeCord auth plugins
     - BungeeAuth
+    - BungeeCordAuthenticatorBungee
 
 description: |
     ${project.description}

core/pom.xml

@@ -1,11 +1,11 @@
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <parent>
         <groupId>com.github.games647</groupId>
         <artifactId>fastlogin</artifactId>
-        <version>1.10</version>
+        <version>1.11-SNAPSHOT</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 
@@ -14,26 +14,69 @@
 
     <name>FastLoginCore</name>
 
+    <repositories>
+        <repository>
+            <id>luck-repo</id>
+            <url>https://ci.lucko.me/plugin/repository/everything</url>
+            <snapshots>
+                <enabled>false</enabled>
+            </snapshots>
+        </repository>
+        <repository>
+            <id>codemc-repo</id>
+            <url>https://repo.codemc.io/repository/maven-public/</url>
+        </repository>
+    </repositories>
+
     <dependencies>
+        <!-- Libraries that we shade into the project -->
+
         <!--Database pooling-->
         <dependency>
             <groupId>com.zaxxer</groupId>
             <artifactId>HikariCP</artifactId>
-            <version>2.6.3</version>
+            <version>4.0.1</version>
         </dependency>
 
         <!--Logging framework implements slf4j which is required by hikari-->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-jdk14</artifactId>
-            <version>1.7.22</version>
+            <version>1.7.30</version>
         </dependency>
 
+        <!-- snakeyaml is present in Bungee, Spigot, Cauldron and so we could use this independent implementation -->
+        <dependency>
+            <groupId>net.md-5</groupId>
+            <artifactId>bungeecord-config</artifactId>
+            <version>1.12-SNAPSHOT</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>*</groupId>
+                    <artifactId>*</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+        <!--Common component for contacting the Mojang API-->
+        <dependency>
+            <groupId>com.github.games647</groupId>
+            <artifactId>craftapi</artifactId>
+            <version>0.4</version>
+        </dependency>
+
+        <!-- APIs we can use because they are available in all platforms (Spigot, Bungee) -->
         <dependency>
             <groupId>com.google.guava</groupId>
             <artifactId>guava</artifactId>
-            <version>10.0.1</version>
+            <version>17.0</version>
             <scope>provided</scope>
         </dependency>
+
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.2.4</version>
+        </dependency>
     </dependencies>
 </project>

core/src/main/java/com/github/games647/fastlogin/core/AsyncScheduler.java

@@ -0,0 +1,69 @@
+package com.github.games647.fastlogin.core;
+
+import com.google.common.util.concurrent.MoreExecutors;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import org.slf4j.Logger;
+
+/**
+ * This limits the number of threads that are used at maximum. Thread creation can be very heavy for the CPU and
+ * context switching between threads too. However we need many threads for blocking HTTP and database calls.
+ * Nevertheless this number can be further limited, because the number of actually working database threads
+ * is limited by the size of our database pool. The goal is to separate concerns into processing and blocking only
+ * threads.
+ */
+public class AsyncScheduler {
+
+    private static final int MAX_CAPACITY = 1024;
+
+    //todo: single thread for delaying and scheduling tasks
+    private final Logger logger;
+
+    // 30 threads are still too many - the optimal solution is to separate into processing and blocking threads
+    // where processing threads could only be max number of cores while blocking threads could be minimized using
+    // non-blocking I/O and a single event executor
+    private final ExecutorService processingPool;
+
+    /*
+    private final ExecutorService databaseExecutor = new ThreadPoolExecutor(1, 10,
+            0L, TimeUnit.MILLISECONDS,
+            new LinkedBlockingQueue<>(MAX_CAPACITY));
+     */
+
+    public AsyncScheduler(Logger logger, ThreadFactory threadFactory) {
+        this.logger = logger;
+        processingPool = new ThreadPoolExecutor(6, 32,
+                60L, TimeUnit.SECONDS,
+                new LinkedBlockingQueue<>(MAX_CAPACITY), threadFactory);
+    }
+
+    /*
+    public <R> CompletableFuture<R> runDatabaseTask(Supplier<R> databaseTask) {
+        return CompletableFuture.supplyAsync(databaseTask, databaseExecutor)
+                .exceptionally(error -> {
+                    logger.warn("Error occurred on thread pool", error);
+                    return null;
+                })
+                // change context to the processing pool
+                .thenApplyAsync(r -> r, processingPool);
+    }
+     */
+
+    public CompletableFuture<Void> runAsync(Runnable task) {
+        return CompletableFuture.runAsync(task, processingPool).exceptionally(error -> {
+            logger.warn("Error occurred on thread pool", error);
+            return null;
+        });
+    }
+
+    public void shutdown() {
+        MoreExecutors.shutdownAndAwaitTermination(processingPool, 1, TimeUnit.MINUTES);
+        //MoreExecutors.shutdownAndAwaitTermination(databaseExecutor, 1, TimeUnit.MINUTES);
+    }
+}

core/src/main/java/com/github/games647/fastlogin/core/AuthStorage.java

@@ -1,265 +0,0 @@
-package com.github.games647.fastlogin.core;
-
-import com.github.games647.fastlogin.core.shared.FastLoginCore;
-import com.google.common.util.concurrent.ThreadFactoryBuilder;
-import com.zaxxer.hikari.HikariConfig;
-import com.zaxxer.hikari.HikariDataSource;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.util.Properties;
-import java.util.UUID;
-import java.util.concurrent.ThreadFactory;
-import java.util.logging.Level;
-
-import javax.sql.DataSource;
-
-public class AuthStorage {
-
-    private static final String PREMIUM_TABLE = "premium";
-
-    private final FastLoginCore<?, ?, ?> core;
-    private final HikariDataSource dataSource;
-
-    public AuthStorage(FastLoginCore<?, ?, ?> core, String driver, String host, int port, String databasePath
-            , String user, String pass, boolean useSSL) {
-        this.core = core;
-
-        HikariConfig config = new HikariConfig();
-        config.setUsername(user);
-        config.setPassword(pass);
-        config.setDriverClassName(driver);
-
-        //a try to fix https://www.spigotmc.org/threads/fastlogin.101192/page-26#post-1874647
-        Properties properties = new Properties();
-        properties.setProperty("date_string_format", "yyyy-MM-dd HH:mm:ss");
-        properties.setProperty("useSSL", String.valueOf(useSSL));
-        config.setDataSourceProperties(properties);
-
-        ThreadFactory platformThreadFactory = core.getPlugin().getThreadFactory();
-        if (platformThreadFactory != null) {
-            config.setThreadFactory(new ThreadFactoryBuilder()
-                    .setNameFormat(core.getPlugin().getName() + " Database Pool Thread #%1$d")
-                    //Hikari create daemons by default
-                    .setDaemon(true)
-                    .setThreadFactory(platformThreadFactory)
-                    .build());
-        }
-
-        databasePath = databasePath.replace("{pluginDir}", core.getPlugin().getDataFolder().getAbsolutePath());
-
-        String jdbcUrl = "jdbc:";
-        if (driver.contains("sqlite")) {
-            jdbcUrl += "sqlite" + "://" + databasePath;
-            config.setConnectionTestQuery("SELECT 1");
-        } else {
-            jdbcUrl += "mysql" + "://" + host + ':' + port + '/' + databasePath;
-        }
-
-        config.setJdbcUrl(jdbcUrl);
-        this.dataSource = new HikariDataSource(config);
-    }
-
-    public DataSource getDataSource() {
-        return dataSource;
-    }
-
-    public void createTables() throws SQLException {
-        Connection con = null;
-        Statement createStmt = null;
-        try {
-            con = dataSource.getConnection();
-            createStmt = con.createStatement();
-
-            String createDataStmt = "CREATE TABLE IF NOT EXISTS " + PREMIUM_TABLE + " ("
-                    + "UserID INTEGER PRIMARY KEY AUTO_INCREMENT, "
-                    + "UUID CHAR(36), "
-                    + "Name VARCHAR(16) NOT NULL, "
-                    + "Premium BOOLEAN NOT NULL, "
-                    + "LastIp VARCHAR(255) NOT NULL, "
-                    + "LastLogin TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP, "
-                    //the premium shouldn't steal the cracked account by changing the name
-                    + "UNIQUE (Name) "
-                    + ')';
-
-            if (dataSource.getJdbcUrl().contains("sqlite")) {
-                createDataStmt = createDataStmt.replace("AUTO_INCREMENT", "AUTOINCREMENT");
-            }
-
-            createStmt.executeUpdate(createDataStmt);
-
-            //drop the old unique uuid index
-            try {
-                if (dataSource.getJdbcUrl().contains("sqlite")) {
-                    String tempTableCreate = createDataStmt.replace(PREMIUM_TABLE, PREMIUM_TABLE + "_TEMP")
-                            //if we already imported the table fail here
-                            .replace("IF NOT EXISTS", "");
-                    //create a temp table insert it there and then back
-                    createStmt.executeUpdate(tempTableCreate);
-                    createStmt.executeUpdate("INSERT INTO " + PREMIUM_TABLE + "_TEMP SELECT * FROM " + PREMIUM_TABLE);
-
-                    createStmt.executeUpdate("DROP TABLE " + PREMIUM_TABLE);
-                    createStmt.executeUpdate(createDataStmt);
-
-                    //insert it back into the new table
-                    createStmt.executeUpdate("INSERT INTO " + PREMIUM_TABLE + " SELECT * FROM " + PREMIUM_TABLE + "_TEMP");
-                } else {
-                    createStmt.executeUpdate("ALTER TABLE premium DROP INDEX UUID");
-                }
-            } catch (SQLException sqlEx) {
-                //silent - we already migrated
-            }
-
-            try {
-                createStmt.executeUpdate("CREATE INDEX uuid_idx on premium (UUID)");
-            } catch (SQLException sqlEx) {
-                //silent - we already migrated
-            }
-        } finally {
-            closeQuietly(con);
-            closeQuietly(createStmt);
-        }
-    }
-
-    public PlayerProfile loadProfile(String name) {
-        Connection con = null;
-        PreparedStatement loadStmt = null;
-        ResultSet resultSet = null;
-        try {
-            con = dataSource.getConnection();
-            loadStmt = con.prepareStatement("SELECT * FROM " + PREMIUM_TABLE + " WHERE Name=? LIMIT 1");
-            loadStmt.setString(1, name);
-
-            resultSet = loadStmt.executeQuery();
-            if (resultSet.next()) {
-                long userId = resultSet.getInt(1);
-
-                UUID uuid = FastLoginCore.parseId(resultSet.getString(2));
-
-                boolean premium = resultSet.getBoolean(4);
-                String lastIp = resultSet.getString(5);
-                long lastLogin = resultSet.getTimestamp(6).getTime();
-                return new PlayerProfile(userId, uuid, name, premium, lastIp, lastLogin);
-            } else {
-                return new PlayerProfile(null, name, false, "");
-            }
-        } catch (SQLException sqlEx) {
-            core.getPlugin().getLogger().log(Level.SEVERE, "Failed to query profile", sqlEx);
-        } finally {
-            closeQuietly(con);
-            closeQuietly(loadStmt);
-            closeQuietly(resultSet);
-        }
-
-        return null;
-    }
-
-    public PlayerProfile loadProfile(UUID uuid) {
-        Connection con = null;
-        PreparedStatement loadStmt = null;
-        ResultSet resultSet = null;
-        try {
-            con = dataSource.getConnection();
-            loadStmt = con.prepareStatement("SELECT * FROM " + PREMIUM_TABLE + " WHERE UUID=? LIMIT 1");
-            loadStmt.setString(1, uuid.toString().replace("-", ""));
-
-            resultSet = loadStmt.executeQuery();
-            if (resultSet.next()) {
-                long userId = resultSet.getInt(1);
-
-                String name = resultSet.getString(3);
-                boolean premium = resultSet.getBoolean(4);
-                String lastIp = resultSet.getString(5);
-                long lastLogin = resultSet.getTimestamp(6).getTime();
-                return new PlayerProfile(userId, uuid, name, premium, lastIp, lastLogin);
-            }
-        } catch (SQLException sqlEx) {
-            core.getPlugin().getLogger().log(Level.SEVERE, "Failed to query profile", sqlEx);
-        } finally {
-            closeQuietly(con);
-            closeQuietly(loadStmt);
-            closeQuietly(resultSet);
-        }
-
-        return null;
-    }
-
-    public boolean save(PlayerProfile playerProfile) {
-        Connection con = null;
-        PreparedStatement updateStmt = null;
-        PreparedStatement saveStmt = null;
-
-        ResultSet generatedKeys = null;
-        try {
-            con = dataSource.getConnection();
-
-            UUID uuid = playerProfile.getUuid();
-            
-            if (playerProfile.getUserId() == -1) {
-                saveStmt = con.prepareStatement("INSERT INTO " + PREMIUM_TABLE
-                        + " (UUID, Name, Premium, LastIp) VALUES (?, ?, ?, ?) ", Statement.RETURN_GENERATED_KEYS);
-
-                if (uuid == null) {
-                    saveStmt.setString(1, null);
-                } else {
-                    saveStmt.setString(1, uuid.toString().replace("-", ""));
-                }
-
-                saveStmt.setString(2, playerProfile.getPlayerName());
-                saveStmt.setBoolean(3, playerProfile.isPremium());
-                saveStmt.setString(4, playerProfile.getLastIp());
-
-                saveStmt.execute();
-
-                generatedKeys = saveStmt.getGeneratedKeys();
-                if (generatedKeys != null && generatedKeys.next()) {
-                    playerProfile.setUserId(generatedKeys.getInt(1));
-                }
-            } else {
-                saveStmt = con.prepareStatement("UPDATE " + PREMIUM_TABLE
-                        + " SET UUID=?, Name=?, Premium=?, LastIp=?, LastLogin=CURRENT_TIMESTAMP WHERE UserID=?");
-
-                if (uuid == null) {
-                    saveStmt.setString(1, null);
-                } else {
-                    saveStmt.setString(1, uuid.toString().replace("-", ""));
-                }
-
-                saveStmt.setString(2, playerProfile.getPlayerName());
-                saveStmt.setBoolean(3, playerProfile.isPremium());
-                saveStmt.setString(4, playerProfile.getLastIp());
-
-                saveStmt.setLong(5, playerProfile.getUserId());
-                saveStmt.execute();
-            }
-
-            return true;
-        } catch (SQLException ex) {
-            core.getPlugin().getLogger().log(Level.SEVERE, "Failed to save playerProfile", ex);
-        } finally {
-            closeQuietly(con);
-            closeQuietly(updateStmt);
-            closeQuietly(saveStmt);
-            closeQuietly(generatedKeys);
-        }
-
-        return false;
-    }
-
-    public void close() {
-        dataSource.close();
-    }
-
-    private void closeQuietly(AutoCloseable closeable) {
-        if (closeable != null) {
-            try {
-                closeable.close();
-            } catch (Exception closeEx) {
-                core.getPlugin().getLogger().log(Level.SEVERE, "Failed to close connection", closeEx);
-            }
-        }
-    }
-}

core/src/main/java/com/github/games647/fastlogin/core/BalancedSSLFactory.java

@@ -1,69 +0,0 @@
-package com.github.games647.fastlogin.core;
-
-import com.google.common.collect.ImmutableList;
-
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.Socket;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import javax.net.ssl.SSLSocketFactory;
-
-public class BalancedSSLFactory extends SSLSocketFactory {
-
-    private final SSLSocketFactory oldFactory;
-
-    //in order to be thread-safe
-    private final List<InetAddress> localAddresses;
-
-    private AtomicInteger id;
-
-    public BalancedSSLFactory(SSLSocketFactory oldFactory, Iterable<InetAddress> localAddresses) {
-        this.oldFactory = oldFactory;
-        this.localAddresses = ImmutableList.copyOf(localAddresses);
-    }
-
-    @Override
-    public String[] getDefaultCipherSuites() {
-        return oldFactory.getDefaultCipherSuites();
-    }
-
-    @Override
-    public String[] getSupportedCipherSuites() {
-        return oldFactory.getSupportedCipherSuites();
-    }
-
-    @Override
-    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException {
-        return oldFactory.createSocket(host, port, getNextLocalAddress(), 0);
-    }
-
-    @Override
-    public Socket createSocket(String host, int port) throws IOException {
-        return oldFactory.createSocket(host, port, getNextLocalAddress(), 0);
-    }
-
-    @Override
-    public Socket createSocket(String host, int port, InetAddress localAddress, int localPort)
-            throws IOException {
-        //default
-        return oldFactory.createSocket(host, port, localAddress, localPort);
-    }
-
-    @Override
-    public Socket createSocket(InetAddress host, int port) throws IOException {
-        return oldFactory.createSocket(host, port, getNextLocalAddress(), 0);
-    }
-
-    @Override
-    public Socket createSocket(InetAddress host, int port, InetAddress local, int localPort) throws IOException {
-        //Default
-        return oldFactory.createSocket(host, port, local, localPort);
-    }
-
-    private InetAddress getNextLocalAddress() {
-        int index = id.incrementAndGet() % localAddresses.size();
-        return localAddresses.get(index);
-    }
-}

core/src/main/java/com/github/games647/fastlogin/core/CommonUtil.java

@@ -0,0 +1,66 @@
+package com.github.games647.fastlogin.core;
+
+import com.github.games647.craftapi.cache.SafeCacheBuilder;
+import com.google.common.cache.CacheLoader;
+
+import java.lang.reflect.Constructor;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.slf4j.impl.JDK14LoggerAdapter;
+
+public class CommonUtil {
+
+    private static final char COLOR_CHAR = '&';
+    private static final char TRANSLATED_CHAR = '§';
+
+    public static <K, V> ConcurrentMap<K, V> buildCache(int expireAfterWrite, int maxSize) {
+        SafeCacheBuilder<Object, Object> builder = SafeCacheBuilder.newBuilder();
+
+        if (expireAfterWrite > 0) {
+            builder.expireAfterWrite(expireAfterWrite, TimeUnit.MINUTES);
+        }
+
+        if (maxSize > 0) {
+            builder.maximumSize(maxSize);
+        }
+
+        return builder.build(CacheLoader.from(() -> {
+            throw new UnsupportedOperationException();
+        }));
+    }
+
+    public static String translateColorCodes(String rawMessage) {
+        char[] chars = rawMessage.toCharArray();
+        for (int i = 0; i < chars.length - 1; i++) {
+            if (chars[i] == COLOR_CHAR && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(chars[i + 1]) > -1) {
+                chars[i] = TRANSLATED_CHAR;
+                chars[i + 1] = Character.toLowerCase(chars[i + 1]);
+            }
+        }
+
+        return new String(chars);
+    }
+
+    public static Logger createLoggerFromJDK(java.util.logging.Logger parent) {
+        try {
+            parent.setLevel(Level.ALL);
+
+            Class<JDK14LoggerAdapter> adapterClass = JDK14LoggerAdapter.class;
+            Constructor<JDK14LoggerAdapter> cons = adapterClass.getDeclaredConstructor(java.util.logging.Logger.class);
+            cons.setAccessible(true);
+            return cons.newInstance(parent);
+        } catch (ReflectiveOperationException reflectEx) {
+            parent.log(Level.WARNING, "Cannot create slf4j logging adapter", reflectEx);
+            parent.log(Level.WARNING, "Creating logger instance manually...");
+            return LoggerFactory.getLogger(parent.getName());
+        }
+    }
+
+    private CommonUtil() {
+        //Utility class
+    }
+}

core/src/main/java/com/github/games647/fastlogin/core/CompatibleCacheBuilder.java

@@ -1,321 +0,0 @@
-package com.github.games647.fastlogin.core;
-
-import com.google.common.base.Ticker;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.CacheLoader;
-import com.google.common.cache.RemovalListener;
-
-import java.lang.reflect.Method;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Represents a Guava CacheBuilder that is compatible with both Guava 10 (Minecraft 1.7.X) and 13
- */
-public class CompatibleCacheBuilder<K, V> {
-
-    private static Method BUILD_METHOD;
-    private static Method AS_MAP_METHOD;
-
-    /**
-     * Construct a new safe cache builder.
-     *
-     * @param <K> Key type
-     * @param <V> Value type
-     *
-     * @return A new cache builder.
-     */
-    public static <K, V> CompatibleCacheBuilder<K, V> newBuilder() {
-        return new CompatibleCacheBuilder<>();
-    }
-
-    private final CacheBuilder<K, V> builder;
-    
-    @SuppressWarnings("unchecked")
-    private CompatibleCacheBuilder() {
-        builder = (CacheBuilder<K, V>) CacheBuilder.newBuilder();
-    }
-
-    /**
-     * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The table is
-     * internally partitioned to try to permit the indicated number of concurrent updates without contention. Because
-     * assignment of entries to these partitions is not necessarily uniform, the actual concurrency observed may vary.
-     * Ideally, you should choose a value to accommodate as many threads as will ever concurrently modify the table.
-     * Using a significantly higher value than you need can waste space and time, and a significantly lower value can
-     * lead to thread contention. But overestimates and underestimates within an order of magnitude do not usually have
-     * much noticeable impact. A value of one permits only one thread to modify the cache at a time, but since read
-     * operations can proceed concurrently, this still yields higher concurrency than full synchronization. Defaults to
-     * 4.
-     *
-     * <p>
-     * <b>Note:</b>The default may change in the future. If you care about this value, you should always choose it
-     * explicitly.
-     *
-     * @param concurrencyLevel New concurrency level
-     * @return This for chaining
-     *
-     * @throws IllegalArgumentException if {@code concurrencyLevel} is non-positive
-     * @throws IllegalStateException if a concurrency level was already set
-     */
-    public CompatibleCacheBuilder<K, V> concurrencyLevel(int concurrencyLevel) {
-        builder.concurrencyLevel(concurrencyLevel);
-        return this;
-    }
-
-    /**
-     * Specifies that each entry should be automatically removed from the cache once a fixed duration has elapsed after
-     * the entry's creation, or last access. Access time is reset by
-     * {@link com.google.common.cache.Cache#get Cache.get()}, but not by operations on the view returned by
-     * {@link com.google.common.cache.Cache#asMap() Cache.asMap()}.
-     *
-     * <p>
-     * When {@code duration} is zero, elements will be evicted immediately after being loaded into the cache. This has
-     * the same effect as invoking {@link #maximumSize maximumSize}{@code (0)}. It can be useful in testing, or to
-     * disable caching temporarily without a code change.
-     *
-     * <p>
-     * Expired entries may be counted by {@link com.google.common.cache.Cache#size Cache.size()}, but will never be
-     * visible to read or write operations. Expired entries are currently cleaned up during write operations, or during
-     * occasional read operations in the absence of writes; though this behavior may change in the future.
-     *
-     * @param duration the length of time after an entry is last accessed that it should be automatically removed
-     * @param unit the unit that {@code duration} is expressed in
-     * @return This for chaining
-     *
-     * @throws IllegalArgumentException if {@code duration} is negative
-     * @throws IllegalStateException if the time to idle or time to live was already set
-     */
-    public CompatibleCacheBuilder<K, V> expireAfterAccess(long duration, TimeUnit unit) {
-        builder.expireAfterAccess(duration, unit);
-        return this;
-    }
-
-    /**
-     * Specifies that each entry should be automatically removed from the cache once a fixed duration has elapsed after
-     * the entry's creation, or the most recent replacement of its value.
-     *
-     * <p>
-     * When {@code duration} is zero, elements will be evicted immediately after being loaded into the cache. This has
-     * the same effect as invoking {@link #maximumSize maximumSize}{@code (0)}. It can be useful in testing, or to
-     * disable caching temporarily without a code change.
-     *
-     * <p>
-     * Expired entries may be counted by {@link com.google.common.cache.Cache#size Cache.size()}, but will never be
-     * visible to read or write operations. Expired entries are currently cleaned up during write operations, or during
-     * occasional read operations in the absence of writes; though this behavior may change in the future.
-     *
-     * @param duration the length of time after an entry is created that it should be automatically removed
-     * @param unit the unit that {@code duration} is expressed in
-     * @return This for chaining
-     *
-     * @throws IllegalArgumentException if {@code duration} is negative
-     * @throws IllegalStateException if the time to live or time to idle was already set
-     */
-    public CompatibleCacheBuilder<K, V> expireAfterWrite(long duration, TimeUnit unit) {
-        builder.expireAfterWrite(duration, unit);
-        return this;
-    }
-
-    /**
-     * Sets the minimum total size for the internal hash tables. For example, if the initial capacity is {@code 60}, and
-     * the concurrency level is {@code 8}, then eight segments are created, each having a hash table of size eight.
-     * Providing a large enough estimate at construction time avoids the need for expensive resizing operations later,
-     * but setting this value unnecessarily high wastes memory.
-     *
-     * @param initialCapacity - initial capacity
-     * @return This for chaining
-     *
-     * @throws IllegalArgumentException if {@code initialCapacity} is negative
-     * @throws IllegalStateException if an initial capacity was already set
-     */
-    public CompatibleCacheBuilder<K, V> initialCapacity(int initialCapacity) {
-        builder.initialCapacity(initialCapacity);
-        return this;
-    }
-
-    /**
-     * Specifies the maximum number of entries the cache may contain. Note that the cache <b>may evict an entry before
-     * this limit is exceeded</b>. As the cache size grows close to the maximum, the cache evicts entries that are less
-     * likely to be used again. For example, the cache may evict an entry because it hasn't been used recently or very
-     * often.
-     *
-     * <p>
-     * When {@code size} is zero, elements will be evicted immediately after being loaded into the cache. This has the
-     * same effect as invoking {@link #expireAfterWrite expireAfterWrite}{@code (0, unit)} or      {@link #expireAfterAccess expireAfterAccess}{@code (0,
-	 * unit)}. It can be useful in testing, or to disable caching temporarily without a code change.
-     *
-     * @param size the maximum size of the cache
-     * @return This for chaining
-     *
-     * @throws IllegalArgumentException if {@code size} is negative
-     * @throws IllegalStateException if a maximum size was already set
-     */
-    public CompatibleCacheBuilder<K, V> maximumSize(int size) {
-        builder.maximumSize(size);
-        return this;
-    }
-
-    /**
-     * Specifies a listener instance, which all caches built using this {@code CacheBuilder} will notify each time an
-     * entry is removed from the cache by any means.
-     *
-     * <p>
-     * Each cache built by this {@code CacheBuilder} after this method is called invokes the supplied listener after
-     * removing an element for any reason (see removal causes in
-     * {@link com.google.common.cache.RemovalCause RemovalCause}). It will invoke the listener during invocations of any
-     * of that cache's public methods (even read-only methods).
-     *
-     * <p>
-     * <b>Important note:</b> Instead of returning <em>this</em> as a {@code CacheBuilder} instance, this method returns
-     * {@code CacheBuilder<K1, V1>}. From this point on, either the original reference or the returned reference may be
-     * used to complete configuration and build the cache, but only the "generic" one is type-safe. That is, it will
-     * properly prevent you from building caches whose key or value types are incompatible with the types accepted by
-     * the listener already provided; the {@code CacheBuilder} type cannot do this. For best results, simply use the
-     * standard method-chaining idiom, as illustrated in the documentation at top, configuring a {@code CacheBuilder}
-     * and building your {@link com.google.common.cache.Cache Cache} all in a single statement.
-     *
-     * <p>
-     * <b>Warning:</b> if you ignore the above advice, and use this {@code CacheBuilder} to build a cache whose key or
-     * value type is incompatible with the listener, you will likely experience a {@link ClassCastException} at some
-     * <i>undefined</i> point in the future.
-     *
-     * @param <K1> Key type
-     * @param <V1> Value type
-     * @param listener - removal listener
-     * @return This for chaining
-     *
-     * @throws IllegalStateException if a removal listener was already set
-     */
-    @SuppressWarnings("unchecked")
-    public <K1 extends K, V1 extends V> CompatibleCacheBuilder<K1, V1> removalListener(RemovalListener<? super K1, ? super V1> listener) {
-        builder.removalListener(listener);
-        return (CompatibleCacheBuilder<K1, V1>) this;
-    }
-
-    /**
-     * Specifies a nanosecond-precision time source for use in determining when entries should be expired. By default,
-     * {@link System#nanoTime} is used.
-     *
-     * <p>
-     * The primary intent of this method is to facilitate testing of caches which have been configured with
-     * {@link #expireAfterWrite} or {@link #expireAfterAccess}.
-     *
-     * @param ticker - ticker
-     * @return This for chaining
-     *
-     * @throws IllegalStateException if a ticker was already set
-     */
-    public CompatibleCacheBuilder<K, V> ticker(Ticker ticker) {
-        builder.ticker(ticker);
-        return this;
-    }
-
-    /**
-     * Specifies that each value (not key) stored in the cache should be wrapped in a
-     * {@link java.lang.ref.SoftReference SoftReference} (by default, strong references are used). Softly-referenced
-     * objects will be garbage-collected in a <i>globally</i>
-     * least-recently-used manner, in response to memory demand.
-     *
-     * <p>
-     * <b>Warning:</b> in most circumstances it is better to set a per-cache {@linkplain #maximumSize maximum size}
-     * instead of using soft references. You should only use this method if you are well familiar with the practical
-     * consequences of soft references.
-     *
-     * <p>
-     * <b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==}) comparison to determine
-     * equality of values.
-     *
-     * @return This for chaining
-     *
-     * @throws IllegalStateException if the value strength was already set
-     */
-    public CompatibleCacheBuilder<K, V> softValues() {
-        builder.softValues();
-        return this;
-    }
-
-    /**
-     * Specifies that each key (not value) stored in the cache should be wrapped in a
-     * {@link java.lang.ref.WeakReference WeakReference} (by default, strong references are used).
-     *
-     * <p>
-     * <b>Warning:</b> when this method is used, the resulting cache will use identity ({@code ==}) comparison to
-     * determine equality of keys.
-     *
-     * @return This for chaining
-     *
-     * @throws IllegalStateException if the key strength was already set
-     */
-    public CompatibleCacheBuilder<K, V> weakKeys() {
-        builder.weakKeys();
-        return this;
-    }
-
-    /**
-     * Specifies that each value (not key) stored in the cache should be wrapped in a
-     * {@link java.lang.ref.WeakReference WeakReference} (by default, strong references are used).
-     *
-     * <p>
-     * Weak values will be garbage collected once they are weakly reachable. This makes them a poor candidate for
-     * caching; consider {@link #softValues} instead.
-     *
-     * <p>
-     * <b>Note:</b> when this method is used, the resulting cache will use identity ({@code ==}) comparison to determine
-     * equality of values.
-     *
-     * @return This for chaining
-     *
-     * @throws IllegalStateException if the value strength was already set
-     */
-    public CompatibleCacheBuilder<K, V> weakValues() {
-        builder.weakValues();
-        return this;
-    }
-
-    /**
-     * Returns the cache wrapped as a ConcurrentMap.
-     * <p>
-     * We can't return the direct Cache instance as it changed in Guava 13.
-     *
-     * @param <K1> Key type
-     * @param <V1> Value type
-     * @param loader - cache loader
-     * @return The cache as a a map.
-     */
-    @SuppressWarnings("unchecked")
-    public <K1 extends K, V1 extends V> ConcurrentMap<K1, V1> build(CacheLoader<? super K1, V1> loader) {
-        Object cache;
-
-        if (BUILD_METHOD == null) {
-            try {
-                BUILD_METHOD = builder.getClass().getDeclaredMethod("build", CacheLoader.class);
-                BUILD_METHOD.setAccessible(true);
-            } catch (Exception e) {
-                throw new IllegalStateException("Unable to find CacheBuilder.build(CacheLoader)", e);
-            }
-        }
-
-        // Attempt to build the Cache
-        try {
-            cache = BUILD_METHOD.invoke(builder, loader);
-        } catch (Exception e) {
-            throw new IllegalStateException("Unable to invoke " + BUILD_METHOD + " on " + builder, e);
-        }
-
-        if (AS_MAP_METHOD == null) {
-            try {
-                AS_MAP_METHOD = cache.getClass().getMethod("asMap");
-                AS_MAP_METHOD.setAccessible(true);
-            } catch (Exception e) {
-                throw new IllegalStateException("Unable to find Cache.asMap() in " + cache, e);
-            }
-        }
-
-        // Retrieve it as a map
-        try {
-            return (ConcurrentMap<K1, V1>) AS_MAP_METHOD.invoke(cache);
-        } catch (Exception e) {
-            throw new IllegalStateException("Unable to invoke " + AS_MAP_METHOD + " on " + cache, e);
-        }
-    }
-}

core/src/main/java/com/github/games647/fastlogin/core/PlayerProfile.java

@@ -1,76 +0,0 @@
-package com.github.games647.fastlogin.core;
-
-import java.util.UUID;
-
-public class PlayerProfile {
-
-    private String playerName;
-
-    private long userId;
-
-    private UUID uuid;
-    private boolean premium;
-    private String lastIp;
-    private long lastLogin;
-
-    public PlayerProfile(long userId, UUID uuid, String playerName, boolean premium, String lastIp, long lastLogin) {
-        this.userId = userId;
-        this.uuid = uuid;
-        this.playerName = playerName;
-        this.premium = premium;
-        this.lastIp = lastIp;
-        this.lastLogin = lastLogin;
-    }
-
-    public PlayerProfile(UUID uuid, String playerName, boolean premium, String lastIp) {
-        this(-1, uuid, playerName, premium, lastIp, System.currentTimeMillis());
-    }
-
-    public synchronized String getPlayerName() {
-        return playerName;
-    }
-
-    public synchronized void setPlayerName(String playerName) {
-        this.playerName = playerName;
-    }
-
-    public synchronized long getUserId() {
-        return userId;
-    }
-
-    public synchronized void setUserId(long generatedId) {
-        this.userId = generatedId;
-    }
-
-    public synchronized UUID getUuid() {
-        return uuid;
-    }
-
-    public synchronized void setUuid(UUID uuid) {
-        this.uuid = uuid;
-    }
-
-    public synchronized boolean isPremium() {
-        return premium;
-    }
-
-    public synchronized void setPremium(boolean premium) {
-        this.premium = premium;
-    }
-
-    public synchronized String getLastIp() {
-        return lastIp;
-    }
-
-    public synchronized void setLastIp(String lastIp) {
-        this.lastIp = lastIp;
-    }
-
-    public synchronized long getLastLogin() {
-        return lastLogin;
-    }
-
-    public synchronized void setLastLogin(long lastLogin) {
-        this.lastLogin = lastLogin;
-    }
-}

core/src/main/java/com/github/games647/fastlogin/core/PremiumStatus.java

@@ -0,0 +1,20 @@
+package com.github.games647.fastlogin.core;
+
+public enum PremiumStatus {
+
+    PREMIUM("Premium"),
+
+    CRACKED("Cracked"),
+
+    UNKNOWN("Unknown");
+
+    private final String readableName;
+
+    PremiumStatus(String readableName) {
+        this.readableName = readableName;
+    }
+
+    public String getReadableName() {
+        return readableName;
+    }
+}

core/src/main/java/com/github/games647/fastlogin/core/SessionManager.java

@@ -0,0 +1,62 @@
+package com.github.games647.fastlogin.core;
+
+import com.github.games647.fastlogin.core.auth.LoginSession;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.google.common.collect.MapMaker;
+
+import java.util.UUID;
+import java.util.concurrent.ConcurrentMap;
+
+/**
+ * Manages player connection sessions. Login sessions that are only valid through the login process and play
+ * sessions that hold the stored profile object after the login process is finished and until the player leaves the
+ * server (Spigot) or proxy (BungeeCord).
+ *
+ * @param <C> connection object
+ * @param <S> platform dependent login session
+ */
+public abstract class SessionManager<E, C, S extends LoginSession> {
+
+    // 1 minutes should be enough as a timeout for bad internet connection (Server, Client and Mojang)
+    // these login sessions are only meant for during the login process not be used after
+    private final ConcurrentMap<C, S> loginSessions =  CommonUtil.buildCache(1, 0);
+    private final ConcurrentMap<UUID, StoredProfile> playSessions = new MapMaker().makeMap();
+
+    public void startLoginSession(C connectionId, S session) {
+        loginSessions.put(connectionId, session);
+    }
+
+    public S getLoginSession(C connectionId) {
+        return loginSessions.get(connectionId);
+    }
+
+    public void endLoginSession(C connectionId) {
+        loginSessions.remove(connectionId);
+    }
+
+    public ConcurrentMap<C, S> getLoginSessions() {
+        return loginSessions;
+    }
+
+    public S promoteSession(C connectionId, UUID playerId) {
+        S loginSession = loginSessions.remove(connectionId);
+        StoredProfile profile = loginSession.getProfile();
+        playSessions.put(playerId, profile);
+        return loginSession;
+    }
+
+    public StoredProfile getPlaySession(UUID playerId) {
+        return playSessions.get(playerId);
+    }
+
+    public void endPlaySession(UUID playerId) {
+        playSessions.remove(playerId);
+    }
+
+    public abstract void onPlayQuit(E quitEvent);
+
+    public void clear() {
+        loginSessions.clear();
+        playSessions.clear();
+    }
+}

core/src/main/java/com/github/games647/fastlogin/core/SharedConfig.java

@@ -1,31 +0,0 @@
-package com.github.games647.fastlogin.core;
-
-import java.util.Map;
-
-public class SharedConfig {
-
-    private final Map<String, Object> configValues;
-
-    public SharedConfig(Map<String, Object> configValues) {
-        this.configValues = configValues;
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T> T get(String path, T def) {
-        Object val = configValues.get(path);
-
-        if (def instanceof String) {
-            return (T) String.valueOf(val);
-        }
-
-        return ( val != null ) ? (T) val : def;
-    }
-
-    public <T> T get(String path) {
-        return get(path, null);
-    }
-
-    public Map<String, Object> getConfigValues() {
-        return configValues;
-    }
-}

core/src/main/java/com/github/games647/fastlogin/core/auth/ForceLoginManagement.java

@@ -1,33 +1,39 @@
-package com.github.games647.fastlogin.core.shared;
+package com.github.games647.fastlogin.core.auth;
 
-import com.github.games647.fastlogin.core.AuthStorage;
-import com.github.games647.fastlogin.core.PlayerProfile;
+import com.github.games647.fastlogin.core.shared.FastLoginCore;
+import com.github.games647.fastlogin.core.shared.PlatformPlugin;
+import com.github.games647.fastlogin.core.storage.AuthStorage;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
 import com.github.games647.fastlogin.core.hooks.AuthPlugin;
-
-import java.util.logging.Level;
+import com.github.games647.fastlogin.core.shared.event.FastLoginAutoLoginEvent;
 
 public abstract class ForceLoginManagement<P extends C, C, L extends LoginSession, T extends PlatformPlugin<C>>
         implements Runnable {
 
     protected final FastLoginCore<P, C, T> core;
     protected final P player;
+    protected final L session;
 
-    protected L session;
-
-    public ForceLoginManagement(FastLoginCore<P, C, T> core, P player) {
+    public ForceLoginManagement(FastLoginCore<P, C, T> core, P player, L session) {
         this.core = core;
         this.player = player;
+        this.session = session;
     }
 
     @Override
     public void run() {
-        if (!isOnline(player) || session == null) {
+        if (!isOnline(player)) {
+            core.getPlugin().getLog().info("Player {} disconnected", player);
+            return;
+        }
+
+        if (session == null) {
+            core.getPlugin().getLog().info("No valid session found for {}", player);
             return;
         }
 
         AuthStorage storage = core.getStorage();
-
-        PlayerProfile playerProfile = session.getProfile();
+        StoredProfile playerProfile = session.getProfile();
         try {
             if (isOnlineMode()) {
                 //premium player
@@ -43,7 +49,7 @@ public abstract class ForceLoginManagement<P extends C, C, L extends LoginSessio
                                 || (core.getConfig().get("auto-register-unknown", false)
                                 && !authPlugin.isRegistered(playerName))) {
                             success = forceRegister(player);
-                        } else {
+                        } else if (!callFastLoginAutoLoginEvent(session, playerProfile).isCancelled()) {
                             success = forceLogin(player);
                         }
                     }
@@ -51,7 +57,7 @@ public abstract class ForceLoginManagement<P extends C, C, L extends LoginSessio
                     if (success) {
                         //update only on success to prevent corrupt data
                         if (playerProfile != null) {
-                            playerProfile.setUuid(session.getUuid());
+                            playerProfile.setId(session.getUuid());
                             playerProfile.setPremium(true);
                             storage.save(playerProfile);
                         }
@@ -61,17 +67,17 @@ public abstract class ForceLoginManagement<P extends C, C, L extends LoginSessio
                 }
             } else if (playerProfile != null) {
                 //cracked player
-                playerProfile.setUuid(null);
+                playerProfile.setId(null);
                 playerProfile.setPremium(false);
                 storage.save(playerProfile);
             }
         } catch (Exception ex) {
-            core.getPlugin().getLogger().log(Level.WARNING, "ERROR ON FORCE LOGIN", ex);
+            core.getPlugin().getLog().warn("ERROR ON FORCE LOGIN of {}", getName(player), ex);
         }
     }
 
     public boolean forceRegister(P player) {
-        core.getPlugin().getLogger().log(Level.INFO, "Register player {0}", getName(player));
+        core.getPlugin().getLog().info("Register player {}", getName(player));
 
         String generatedPassword = core.getPasswordGenerator().getRandomPassword(player);
         boolean success = core.getAuthPluginHook().forceRegister(player, generatedPassword);
@@ -86,9 +92,9 @@ public abstract class ForceLoginManagement<P extends C, C, L extends LoginSessio
     }
 
     public boolean forceLogin(P player) {
-        core.getPlugin().getLogger().log(Level.INFO, "Logging player {0} in", getName(player));
-        boolean success = core.getAuthPluginHook().forceLogin(player);
+        core.getPlugin().getLog().info("Logging player {} in", getName(player));
 
+        boolean success = core.getAuthPluginHook().forceLogin(player);
         if (success) {
             core.sendLocaleMessage("auto-login", player);
         }
@@ -96,6 +102,8 @@ public abstract class ForceLoginManagement<P extends C, C, L extends LoginSessio
         return success;
     }
 
+    public abstract FastLoginAutoLoginEvent callFastLoginAutoLoginEvent(LoginSession session, StoredProfile profile);
+
     public abstract void onForceActionSuccess(LoginSession session);
 
     public abstract String getName(P player);

core/src/main/java/com/github/games647/fastlogin/core/auth/JoinManagement.java

@@ -0,0 +1,115 @@
+package com.github.games647.fastlogin.core.auth;
+
+import com.github.games647.craftapi.model.Profile;
+import com.github.games647.craftapi.resolver.RateLimitException;
+import com.github.games647.fastlogin.core.shared.FastLoginCore;
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.github.games647.fastlogin.core.hooks.AuthPlugin;
+import com.github.games647.fastlogin.core.shared.event.FastLoginPreLoginEvent;
+
+import java.util.Optional;
+
+import net.md_5.bungee.config.Configuration;
+
+public abstract class JoinManagement<P extends C, C, S extends LoginSource> {
+
+    protected final FastLoginCore<P, C, ?> core;
+    protected final AuthPlugin<P> authHook;
+
+    public JoinManagement(FastLoginCore<P, C, ?> core, AuthPlugin<P> authHook) {
+        this.core = core;
+        this.authHook = authHook;
+    }
+
+    public void onLogin(String username, S source) {
+        core.getPlugin().getLog().info("Handling player {}", username);
+        StoredProfile profile = core.getStorage().loadProfile(username);
+        if (profile == null) {
+            return;
+        }
+
+        callFastLoginPreLoginEvent(username, source, profile);
+
+        Configuration config = core.getConfig();
+
+        String ip = source.getAddress().getAddress().getHostAddress();
+        profile.setLastIp(ip);
+        try {
+            if (profile.isSaved()) {
+                if (profile.isPremium()) {
+                    core.getPlugin().getLog().info("Requesting premium login for registered player: {}", username);
+                    requestPremiumLogin(source, profile, username, true);
+                } else {
+                    startCrackedSession(source, profile, username);
+                }
+            } else {
+                if (core.getPendingLogin().remove(ip + username) != null && config.get("secondAttemptCracked", false)) {
+                    core.getPlugin().getLog().info("Second attempt login -> cracked {}", username);
+
+                    //first login request failed so make a cracked session
+                    startCrackedSession(source, profile, username);
+                    return;
+                }
+
+                Optional<Profile> premiumUUID = Optional.empty();
+                if (config.get("nameChangeCheck", false) || config.get("autoRegister", false)) {
+                    premiumUUID = core.getResolver().findProfile(username);
+                }
+
+                if (!premiumUUID.isPresent()
+                        || (!checkNameChange(source, username, premiumUUID.get())
+                        && !checkPremiumName(source, username, profile))) {
+                    //nothing detected the player as premium -> start a cracked session
+                    if (core.getConfig().get("switchMode", false)) {
+                        source.kick(core.getMessage("switch-kick-message"));
+                        return;
+                    }
+
+                    startCrackedSession(source, profile, username);
+                }
+            }
+        } catch (RateLimitException rateLimitEx) {
+            core.getPlugin().getLog().error("Mojang's rate limit reached for {}. The public IPv4 address of this" +
+                    " server issued more than 600 Name -> UUID requests within 10 minutes. After those 10" +
+                    " minutes we can make requests again.", username);
+        } catch (Exception ex) {
+            core.getPlugin().getLog().error("Failed to check premium state for {}", username, ex);
+            core.getPlugin().getLog().error("Failed to check premium state of {}", username, ex);
+        }
+    }
+
+    private boolean checkPremiumName(S source, String username, StoredProfile profile) throws Exception {
+        core.getPlugin().getLog().info("GameProfile {} uses a premium username", username);
+        if (core.getConfig().get("autoRegister", false) && (authHook == null || !authHook.isRegistered(username))) {
+            requestPremiumLogin(source, profile, username, false);
+            return true;
+        }
+
+        return false;
+    }
+
+    private boolean checkNameChange(S source, String username, Profile profile) {
+        //user not exists in the db
+        if (core.getConfig().get("nameChangeCheck", false)) {
+            StoredProfile storedProfile = core.getStorage().loadProfile(profile.getId());
+            if (storedProfile != null) {
+                //uuid exists in the database
+                core.getPlugin().getLog().info("GameProfile {} changed it's username", profile);
+
+                //update the username to the new one in the database
+                storedProfile.setPlayerName(username);
+
+                requestPremiumLogin(source, storedProfile, username, false);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public abstract FastLoginPreLoginEvent callFastLoginPreLoginEvent(String username, S source, StoredProfile profile);
+
+    public abstract void requestPremiumLogin(S source, StoredProfile profile, String username, boolean registered);
+
+    public abstract void startCrackedSession(S source, StoredProfile profile, String username);
+}

core/src/main/java/com/github/games647/fastlogin/core/auth/LoginSession.java

@@ -0,0 +1,77 @@
+package com.github.games647.fastlogin.core.auth;
+
+import com.github.games647.fastlogin.core.storage.StoredProfile;
+import com.google.common.base.Objects;
+
+import java.util.UUID;
+
+public abstract class LoginSession {
+
+    private final StoredProfile profile;
+
+    private String requestUsername;
+    private String username;
+    private UUID uuid;
+
+    protected boolean registered;
+
+    public LoginSession(String requestUsername, boolean registered, StoredProfile profile) {
+        this.requestUsername = requestUsername;
+        this.username = requestUsername;
+
+        this.registered = registered;
+        this.profile = profile;
+    }
+
+    public String getRequestUsername() {
+        return requestUsername;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public synchronized void setVerifiedUsername(String username) {
+        this.username = username;
+    }
+
+    /**
+     * @return This value is always false if we authenticate the player with a cracked authentication
+     */
+    public synchronized boolean needsRegistration() {
+        return !registered;
+    }
+
+    public StoredProfile getProfile() {
+        return profile;
+    }
+
+    /**
+     * Get the premium UUID of this player
+     *
+     * @return the premium UUID or null if not fetched
+     */
+    public synchronized UUID getUuid() {
+        return uuid;
+    }
+
+    /**
+     * Set the online UUID if it's fetched
+     *
+     * @param uuid premium UUID
+     */
+    public synchronized void setUuid(UUID uuid) {
+        this.uuid = uuid;
+    }
+
+    @Override
+    public synchronized String toString() {
+        return Objects.toStringHelper(this)
+                .add("profile", profile)
+                .add("requestUsername", requestUsername)
+                .add("username", username)
+                .add("uuid", uuid)
+                .add("registered", registered)
+                .toString();
+    }
+}

core/src/main/java/com/github/games647/fastlogin/core/auth/LoginSource.java

@@ -1,4 +1,4 @@
-package com.github.games647.fastlogin.core.shared;
+package com.github.games647.fastlogin.core.auth;
 
 import java.net.InetSocketAddress;
 

core/src/main/java/com/github/games647/fastlogin/core/auth/RateLimiter.java

@@ -0,0 +1,41 @@
+package com.github.games647.fastlogin.core.auth;
+
+/**
+ * Limit the number of requests with a maximum size. Each requests expires after the specified time making it available
+ * for another request.
+ */
+public class RateLimiter {
+
+    private final long[] requests;
+    private final long expireTime;
+    private int position;
+
+    public RateLimiter(int maxLimit, long expireTime) {
+        this.requests = new long[maxLimit];
+        this.expireTime = expireTime;
+    }
+
+    /**
+     * Ask if access is allowed. If so register the request.
+     *
+     * @return true if allowed - false otherwise without any side effects
+     */
+    public boolean tryAcquire() {
+        // current time millis is not monotonic - it can jump back depending on user choice or NTP
+        long now = System.nanoTime() / 1_000_000;
+
+        // after this the request should be expired
+        long toBeExpired = now - expireTime;
+        synchronized (this) {
+            // having synchronized will limit the amount of concurrency a lot
+            long oldest = requests[position];
+            if (oldest < toBeExpired) {
+                requests[position] = now;
+                position = (position + 1) % requests.length;
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

core/src/main/java/com/github/games647/fastlogin/core/hooks/AuthPlugin.java

@@ -3,10 +3,13 @@ package com.github.games647.fastlogin.core.hooks;
 /**
  * Represents a supporting authentication plugin in BungeeCord and Bukkit/Spigot/... servers
  *
- * @param <P> either org.bukkit.entity.Player for Bukkit or net.md_5.bungee.api.connection.ProxiedPlayer for BungeeCord
+ * @param <P> either {@link org.bukkit.entity.Player} for Bukkit or {@link net.md_5.bungee.api.connection.ProxiedPlayer}
+ *           for BungeeCord
  */
 public interface AuthPlugin<P> {
 
+    String ALREADY_AUTHENTICATED = "Player {} is already authenticated. Cancelling force login.";
+
     /**
      * Login the premium (paid account) player after the player joined successfully the server.
      *

core/src/main/java/com/github/games647/fastlogin/core/hooks/DefaultPasswordGenerator.java

@@ -1,19 +1,24 @@
 package com.github.games647.fastlogin.core.hooks;
 
+import java.security.SecureRandom;
 import java.util.Random;
+import java.util.stream.IntStream;
 
 public class DefaultPasswordGenerator<P> implements PasswordGenerator<P> {
 
+    private static final int PASSWORD_LENGTH = 8;
     private static final char[] PASSWORD_CHARACTERS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
             .toCharArray();
-    private final Random random = new Random();
+
+    private final Random random = new SecureRandom();
 
     @Override
     public String getRandomPassword(P player) {
         StringBuilder generatedPassword = new StringBuilder(8);
-        for (int i = 1; i <= 8; i++) {
-            generatedPassword.append(PASSWORD_CHARACTERS[random.nextInt(PASSWORD_CHARACTERS.length - 1)]);
-        }
+        IntStream.rangeClosed(1, PASSWORD_LENGTH)
+                .map(i -> random.nextInt(PASSWORD_CHARACTERS.length - 1))
+                .mapToObj(pos -> PASSWORD_CHARACTERS[pos])
+                .forEach(generatedPassword::append);
 
         return generatedPassword.toString();
     }