Authentication implementation.

NachoSpigot-API/pom.xml

@@ -51,18 +51,18 @@
             <version>17.0</version>
             <scope>compile</scope>
         </dependency>
-<!--        &lt;!&ndash; https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine &ndash;&gt;-->
-<!--        <dependency>-->
-<!--            <groupId>com.github.ben-manes.caffeine</groupId>-->
-<!--            <artifactId>caffeine</artifactId>-->
-<!--            <version>2.8.5</version>-->
-<!--        </dependency>-->
+        <!--        &lt;!&ndash; https://mvnrepository.com/artifact/com.github.ben-manes.caffeine/caffeine &ndash;&gt;-->
+        <!--        <dependency>-->
+        <!--            <groupId>com.github.ben-manes.caffeine</groupId>-->
+        <!--            <artifactId>caffeine</artifactId>-->
+        <!--            <version>2.8.5</version>-->
+        <!--        </dependency>-->
 
         <!-- bundled with Minecraft, should be kept in sync -->
         <dependency>
             <groupId>com.google.code.gson</groupId>
             <artifactId>gson</artifactId>
-          <version>2.2.4</version>
+            <version>2.2.4</version>
         </dependency>
         <dependency>
             <groupId>org.avaje</groupId>
@@ -146,4 +146,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
+</project>

NachoSpigot-Server/pom.xml

@@ -101,7 +101,7 @@
             <version>2.17.1</version>
             <scope>compile</scope>
         </dependency>
-	<dependency>
+        <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-api</artifactId>
             <version>2.17.1</version>
@@ -328,4 +328,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
+</project>

NachoSpigot-Server/src/main/java/com/github/sadcenter/auth/NachoAuthenticationService.java

@@ -0,0 +1,221 @@
+package com.github.sadcenter.auth;
+
+import com.github.sadcenter.auth.profile.NachoGameProfileRepository;
+import com.github.sadcenter.auth.serializer.GameProfileSerializer;
+import com.github.sadcenter.auth.serializer.UUIDSerializer;
+import com.github.sadcenter.auth.session.NachoSessionService;
+import com.github.sadcenter.auth.storage.CachedProfile;
+import com.github.sadcenter.auth.storage.ProfileCache;
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.mojang.authlib.*;
+import com.mojang.authlib.minecraft.MinecraftSessionService;
+import com.mojang.authlib.properties.PropertyMap;
+import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
+import com.mojang.util.UUIDTypeAdapter;
+import me.elier.nachospigot.config.NachoConfig;
+import net.minecraft.server.EntityPlayer;
+import net.minecraft.server.MinecraftServer;
+import org.apache.commons.io.Charsets;
+import org.apache.commons.io.IOUtils;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class NachoAuthenticationService implements AuthenticationService {
+
+    public static final Gson GSON = new GsonBuilder()
+            .registerTypeAdapter(GameProfile.class, new GameProfileSerializer())
+            .registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
+            .registerTypeAdapter(UUID.class, new UUIDSerializer())
+            .create();
+    public static final Executor EXECUTOR = Executors.newSingleThreadExecutor(new ThreadFactoryBuilder()
+            .setNameFormat("Authenticator Thread - %1$d")
+            .setUncaughtExceptionHandler((t, e) -> e.printStackTrace())
+            .build());
+    private static final String API = "https://api.ashcon.app/mojang/v2/user/";
+    private static final String BACKUP_API = "https://sessionserver.mojang.com/session/minecraft/profile/";
+    private static final String UUID_API = "https://api.ashcon.app/mojang/v2/uuid/";
+    private static final String BACKUP_UUID_API = "https://api.mojang.com/users/profiles/minecraft/";
+
+    private final LoadingCache<String, CompletableFuture<GameProfile>> gameProfileCache = CacheBuilder.newBuilder()
+            .expireAfterWrite(3, TimeUnit.HOURS)
+            .maximumSize(5000) //idk what's size is the best so you can give some advices
+            .build(new CacheLoader<String, CompletableFuture<GameProfile>>() {
+                @Override
+                public CompletableFuture<GameProfile> load(String key) {
+                    EntityPlayer player = MinecraftServer.getServer().getPlayerList().getPlayer(key);
+                    CachedProfile cachedProfile = profileCache.getCachedProfile(key);
+                    CompletableFuture<GameProfile> gameProfile = player == null ? getProfileFromApi(key) : CompletableFuture.completedFuture(player.getProfile());
+
+                    if (cachedProfile == null) {
+                        gameProfile
+                                .thenAccept(profile -> profileCache.putAndSave(profile.getName(), CachedProfile.fromGameProfile(profile)));
+                    } else {
+                        GameProfile cachedGameProfile = cachedProfile.toGameProfile(key);
+                        gameProfile.thenAccept(profile -> {
+                            if (!profile.equals(cachedGameProfile)) {
+                                profileCache.putAndSave(profile.getName(), CachedProfile.fromGameProfile(profile));
+                                gameProfileCache.put(profile.getName(), gameProfile);
+                            }
+                        });
+
+                        return CompletableFuture.completedFuture(cachedGameProfile);
+                    }
+
+                    return gameProfile;
+                }
+            });
+    private final ProfileCache profileCache = new ProfileCache();
+    private final YggdrasilAuthenticationService yggdrasilAuthenticationService;
+
+    public NachoAuthenticationService(YggdrasilAuthenticationService yggdrasilAuthenticationService) {
+        this.yggdrasilAuthenticationService = yggdrasilAuthenticationService;
+    }
+
+    @Override
+    public GameProfileRepository createProfileRepository() {
+        return new NachoGameProfileRepository(this);
+    }
+
+    @Override
+    public UserAuthentication createUserAuthentication(Agent agent) {
+        return this.yggdrasilAuthenticationService.createUserAuthentication(agent);
+    }
+
+    @Override
+    public MinecraftSessionService createMinecraftSessionService() {
+        return new NachoSessionService(this);
+    }
+
+    public CompletableFuture<GameProfile> getProfile(String name) {
+        try {
+            return this.gameProfileCache.get(name);
+        } catch (ExecutionException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    public GameProfile getPresentProfile(String name) {
+        CompletableFuture<GameProfile> profile = this.gameProfileCache.getIfPresent(name);
+        return profile == null ? null :
+                profile.getNow(null);
+    }
+
+    public CompletableFuture<UUID> getUuid(String name) {
+        return this.getUuidFromApi(name, NachoConfig.alwaysUseMojang).exceptionallyCompose(throwable -> this.getUuidFromApi(name, !NachoConfig.alwaysUseMojang));
+    }
+
+    private CompletableFuture<GameProfile> getProfileFromApi(String name) {
+        return this.getProfileFromApi(name, NachoConfig.alwaysUseMojang)
+                .exceptionallyComposeAsync(throwable -> this.getProfileFromApi(name, !NachoConfig.alwaysUseMojang), EXECUTOR);
+    }
+
+    private CompletableFuture<UUID> getUuidFromApi(String name, boolean mojang) {
+        return mojang ? this.get(BACKUP_UUID_API + name, UUID.class) :
+                this.get(UUID_API + name, UUID.class);
+    }
+
+    private CompletableFuture<GameProfile> getProfileFromApi(String name, boolean mojang) {
+        if (mojang) {
+            CompletableFuture<UUID> uuidFuture = this.getUuidFromApi(name, true);
+            return uuidFuture
+                    .thenCompose(uuid -> this.get(BACKUP_API + UUIDTypeAdapter.fromUUID(uuid), GameProfile.class));
+        } else {
+            return this.get(API + name, GameProfile.class);
+        }
+    }
+
+    public <T> CompletableFuture<T> get(String url, Class<T> type) {
+        return CompletableFuture.supplyAsync(() -> {
+            String result = null;
+            try {
+                result = this.fetchGet(url(url));
+            } catch (Exception exception) {
+                if (!(exception instanceof FileNotFoundException)) {
+                    throw new CompletionException(exception);
+                }
+            }
+            return GSON.fromJson(result, type);
+        }, EXECUTOR);
+    }
+
+    public <T> CompletableFuture<T> post(String url, Object content, Class<T> type) {
+        return CompletableFuture.supplyAsync(() -> {
+            try {
+                return GSON.fromJson(this.fetchPost(url(url), GSON.toJson(content)), type);
+            } catch (IOException exception) {
+                if (!(exception instanceof FileNotFoundException)) {
+                    exception.printStackTrace();
+                }
+            }
+
+            return null;
+        }, EXECUTOR);
+    }
+
+    public String fetchGet(URL url) throws IOException {
+        return IOUtils.toString(url, StandardCharsets.UTF_8);
+    }
+
+    public String fetchPost(URL url, String content) throws IOException {
+        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+
+        connection.setRequestMethod("application/json");
+        connection.setDoOutput(true);
+
+        try (OutputStream outputStream = connection.getOutputStream()) {
+            IOUtils.write(content.getBytes(Charsets.UTF_8), outputStream);
+        }
+
+        try (InputStream inputStream = connection.getInputStream()) {
+            return IOUtils.toString(inputStream);
+        }
+    }
+
+    public void tick() {
+        this.profileCache.setTicked(false);
+    }
+
+    public static URL url(String url) {
+        try {
+            return new URL(url);
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static <T> String json(T source) {
+        return GSON.toJson(source);
+    }
+
+    public static String query(Map<?, ?> map) {
+        StringBuilder builder = new StringBuilder();
+        AtomicBoolean firstPair = new AtomicBoolean(true);
+
+        map.forEach((a, b) -> {
+            builder.append((firstPair.get() ? "?" : "&") + a + "=" + b);
+
+            firstPair.set(false);
+        });
+
+        return builder.toString();
+    }
+}

NachoSpigot-Server/src/main/java/com/github/sadcenter/auth/profile/NachoGameProfileRepository.java

@@ -0,0 +1,34 @@
+package com.github.sadcenter.auth.profile;
+
+import com.github.sadcenter.auth.NachoAuthenticationService;
+import com.mojang.authlib.Agent;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.GameProfileRepository;
+import com.mojang.authlib.ProfileLookupCallback;
+
+public class NachoGameProfileRepository implements GameProfileRepository {
+
+    private final NachoAuthenticationService authenticator;
+
+    public NachoGameProfileRepository(NachoAuthenticationService authenticator) {
+        this.authenticator = authenticator;
+    }
+
+    @Override
+    public void findProfilesByNames(String[] names, Agent agent, ProfileLookupCallback callback) {
+        for (String name : names) {
+            if (name == null || name.isEmpty()) {
+                continue;
+            }
+
+            GameProfile gameProfile = new GameProfile(null, name);
+            this.authenticator.getUuid(name)
+                    .thenApply(uuid -> new GameProfile(uuid, name))
+                    .thenAccept(callback::onProfileLookupSucceeded)
+                    .exceptionally(throwable -> {
+                        callback.onProfileLookupFailed(gameProfile, (Exception) throwable);
+                        return null;
+                    });
+        }
+    }
+}

NachoSpigot-Server/src/main/java/com/github/sadcenter/auth/response/HasJoinedServerResponse.java

@@ -0,0 +1,25 @@
+package com.github.sadcenter.auth.response;
+
+import com.mojang.authlib.properties.PropertyMap;
+import com.mojang.util.UUIDTypeAdapter;
+
+import java.util.UUID;
+
+public class HasJoinedServerResponse {
+
+    private final String id;
+    private final PropertyMap properties;
+
+    public HasJoinedServerResponse(String uuid, PropertyMap propertyMap) {
+        this.id = uuid;
+        this.properties = propertyMap;
+    }
+
+    public UUID getUuid() {
+        return UUIDTypeAdapter.fromString(this.id);
+    }
+
+    public PropertyMap getPropertyMap() {
+        return this.properties;
+    }
+}

NachoSpigot-Server/src/main/java/com/github/sadcenter/auth/serializer/GameProfileSerializer.java

@@ -0,0 +1,35 @@
+package com.github.sadcenter.auth.serializer;
+
+import com.google.gson.*;
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.util.UUIDTypeAdapter;
+
+import java.lang.reflect.Type;
+import java.util.UUID;
+
+public class GameProfileSerializer implements JsonDeserializer<GameProfile> {
+
+    private static final String ASHCON_UUID_FIELD = "uuid";
+    private static final String MOJANG_UUID_FIELD = "id";
+
+    @Override
+    public GameProfile deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
+        JsonObject jsonObject = json.getAsJsonObject();
+        boolean isAshCon = jsonObject.has(ASHCON_UUID_FIELD);
+        String stringId = jsonObject.getAsJsonPrimitive(isAshCon ? ASHCON_UUID_FIELD : MOJANG_UUID_FIELD).getAsString();
+
+        UUID id = isAshCon ? UUID.fromString(stringId) : UUIDTypeAdapter.fromString(stringId);
+        String name = jsonObject.getAsJsonPrimitive(isAshCon ? "username" : "name").getAsString();
+        GameProfile gameProfile = new GameProfile(id, name);
+
+        JsonObject propertyJson = (isAshCon ?
+                jsonObject.get("textures").getAsJsonObject().get("raw") : jsonObject.getAsJsonArray("properties").get(0))
+                .getAsJsonObject();
+
+        Property property = new Property("textures", propertyJson.getAsJsonPrimitive("value").getAsString());
+        gameProfile.getProperties().put("textures", property);
+
+        return gameProfile;
+    }
+}

NachoSpigot-Server/src/main/java/com/github/sadcenter/auth/serializer/UUIDSerializer.java

@@ -0,0 +1,22 @@
+package com.github.sadcenter.auth.serializer;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonParseException;
+import com.mojang.util.UUIDTypeAdapter;
+
+import java.lang.reflect.Type;
+import java.util.UUID;
+
+public class UUIDSerializer implements JsonDeserializer<UUID> {
+
+    @Override
+    public UUID deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+        if (json.isJsonObject()) {
+            return UUIDTypeAdapter.fromString(json.getAsJsonObject().get("id").getAsString());
+        } else {
+            return UUID.fromString(json.getAsString());
+        }
+    }
+}