diff options
Diffstat (limited to 'loader/src/main/java')
15 files changed, 681 insertions, 112 deletions
diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/DungeonsGuideReloadListener.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/DungeonsGuideReloadListener.java index 7252a9db..a96805c1 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/DungeonsGuideReloadListener.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/DungeonsGuideReloadListener.java @@ -19,6 +19,9 @@ package kr.syeyoung.dungeonsguide.launcher; public interface DungeonsGuideReloadListener { + /** + * @implNote This is very important that you GET RID OF referene to DGInterface when this is called, or else dg is gonna crash with ReferenceLeakedException. + */ public void unloadReference(); public void onLoad(DGInterface dgInterface); } diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/Main.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/Main.java index 0ec65780..e8d3e36b 100755 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/Main.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/Main.java @@ -19,7 +19,9 @@ package kr.syeyoung.dungeonsguide.launcher; import kr.syeyoung.dungeonsguide.launcher.auth.AuthManager; +import kr.syeyoung.dungeonsguide.launcher.branch.UpdateRetrieverUtil; import kr.syeyoung.dungeonsguide.launcher.exceptions.NoSuitableLoaderFoundException; +import kr.syeyoung.dungeonsguide.launcher.exceptions.NoVersionFoundException; import kr.syeyoung.dungeonsguide.launcher.exceptions.ReferenceLeakedException; import kr.syeyoung.dungeonsguide.launcher.gui.screen.GuiDisplayer; import kr.syeyoung.dungeonsguide.launcher.gui.screen.GuiLoadingError; @@ -28,6 +30,7 @@ import kr.syeyoung.dungeonsguide.launcher.gui.screen.SpecialGuiScreen; import kr.syeyoung.dungeonsguide.launcher.loader.IDGLoader; import kr.syeyoung.dungeonsguide.launcher.loader.JarLoader; import kr.syeyoung.dungeonsguide.launcher.loader.LocalLoader; +import kr.syeyoung.dungeonsguide.launcher.loader.RemoteLoader; import net.minecraft.client.Minecraft; import net.minecraft.client.resources.IReloadableResourceManager; import net.minecraftforge.common.MinecraftForge; @@ -96,7 +99,7 @@ public class Main } currentLoader = null; } - private void load(IDGLoader newLoader) throws ClassNotFoundException, InstantiationException, IllegalAccessException { + private void load(IDGLoader newLoader) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException { if (dgInterface != null) throw new IllegalStateException("DG is loaded"); dgInterface = newLoader.loadDungeonsGuide(); currentLoader = newLoader; @@ -157,7 +160,19 @@ public class Main return new JarLoader(); } else if (loader.equals("auto") ){ // remote load - throw new UnsupportedOperationException(""); // yet + String branch = System.getProperty("branch") == null ? configuration.get("loader", "remoteBranch", "$default").getString() : System.getProperty("branch"); + String version = System.getProperty("version") == null ? configuration.get("loader", "remoteVersion", "latest").getString() : System.getProperty("version"); + try { + UpdateRetrieverUtil.VersionInfo versionInfo = UpdateRetrieverUtil.getIds( + branch, + version + ); + if (versionInfo == null) throw new NoVersionFoundException(branch, version); + + return new RemoteLoader(versionInfo.getFriendlyBranchName(), versionInfo.getBranchId(), versionInfo.getUpdateId()); + } catch (IOException e) { + throw new NoVersionFoundException(branch, version, e); + } } else { throw new NoSuitableLoaderFoundException(System.getProperty("dg.loader"), configuration.get("loader", "modsource", "auto").getString()); } diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/AuthManager.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/AuthManager.java index 1613e687..c3dd747a 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/AuthManager.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/AuthManager.java @@ -3,6 +3,7 @@ package kr.syeyoung.dungeonsguide.launcher.auth; import com.google.common.base.Throwables; import com.google.common.util.concurrent.ThreadFactoryBuilder; import com.mojang.authlib.exceptions.AuthenticationException; +import kr.syeyoung.dungeonsguide.launcher.Main; import kr.syeyoung.dungeonsguide.launcher.auth.token.*; import kr.syeyoung.dungeonsguide.launcher.events.AuthChangedEvent; import kr.syeyoung.dungeonsguide.launcher.exceptions.AuthFailedExeption; @@ -34,10 +35,6 @@ public class AuthManager { if(INSTANCE == null) INSTANCE = new AuthManager(); return INSTANCE; } - - @Setter - private String baseserverurl = "https://dungeons.guide"; - private AuthToken currentToken = new NullToken(); public AuthToken getToken() { @@ -98,9 +95,9 @@ public class AuthManager { reauthLock = true; try { - String token = DgAuthUtil.requestAuth(baseserverurl); + String token = DgAuthUtil.requestAuth(); byte[] encSecret = DgAuthUtil.checkSessionAuthenticityAndReturnEncryptedSecret(token); - currentToken = DgAuthUtil.verifyAuth(token, encSecret, baseserverurl); + currentToken = DgAuthUtil.verifyAuth(token, encSecret); MinecraftForge.EVENT_BUS.post(new AuthChangedEvent(currentToken)); if (currentToken instanceof PrivacyPolicyRequiredToken) { @@ -130,7 +127,7 @@ public class AuthManager { if (currentToken instanceof PrivacyPolicyRequiredToken) { reauthLock = true; try { - currentToken = DgAuthUtil.acceptNewPrivacyPolicy(currentToken.getToken(), baseserverurl); + currentToken = DgAuthUtil.acceptNewPrivacyPolicy(currentToken.getToken()); if (currentToken instanceof PrivacyPolicyRequiredToken) throw new PrivacyPolicyRequiredException(); } catch (IOException e) { currentToken = new FailedAuthToken(e); diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/DgAuthUtil.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/DgAuthUtil.java index f585ac20..78fc91c9 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/DgAuthUtil.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/auth/DgAuthUtil.java @@ -5,6 +5,7 @@ import com.google.gson.JsonParser; import com.mojang.authlib.GameProfile; import com.mojang.authlib.exceptions.AuthenticationException; import com.mojang.authlib.minecraft.MinecraftSessionService; +import kr.syeyoung.dungeonsguide.launcher.Main; import kr.syeyoung.dungeonsguide.launcher.auth.token.AuthToken; import kr.syeyoung.dungeonsguide.launcher.auth.token.DGAuthToken; import kr.syeyoung.dungeonsguide.launcher.auth.token.PrivacyPolicyRequiredToken; @@ -52,14 +53,16 @@ public class DgAuthUtil { ); } catch (Exception e) { throw new ResponseParsingException(payload, e.getMessage()); + } finally { + toRead.close(); } } - public static String requestAuth(String baseurl) throws IOException { + public static String requestAuth() throws IOException { GameProfile profile = Minecraft.getMinecraft().getSession().getProfile(); - HttpsURLConnection connection = (HttpsURLConnection) new URL(baseurl + "/auth/requestAuth").openConnection(); + HttpsURLConnection connection = (HttpsURLConnection) new URL(Main.DOMAIN + "/auth/requestAuth").openConnection(); connection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); connection.setRequestProperty("Content-Type", "application/json"); connection.setRequestMethod("POST"); @@ -96,8 +99,8 @@ public class DgAuthUtil { return result; } - public static AuthToken verifyAuth(String tempToken, byte[] encSecret, String baseurl) throws IOException { - HttpsURLConnection urlConnection = (HttpsURLConnection) new URL(baseurl + "/auth/authenticate").openConnection(); + public static AuthToken verifyAuth(String tempToken, byte[] encSecret) throws IOException { + HttpsURLConnection urlConnection = (HttpsURLConnection) new URL(Main.DOMAIN + "/auth/authenticate").openConnection(); urlConnection.setRequestMethod("POST"); urlConnection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); urlConnection.setRequestProperty("Content-Type", "application/json"); @@ -120,8 +123,8 @@ public class DgAuthUtil { } } - public static AuthToken acceptNewPrivacyPolicy(String tempToken, String baseurl) throws IOException { - HttpsURLConnection urlConnection = (HttpsURLConnection) new URL(baseurl + "/auth/acceptPrivacyPolicy").openConnection(); + public static AuthToken acceptNewPrivacyPolicy(String tempToken) throws IOException { + HttpsURLConnection urlConnection = (HttpsURLConnection) new URL(Main.DOMAIN + "/auth/acceptPrivacyPolicy").openConnection(); urlConnection.setRequestMethod("POST"); urlConnection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); urlConnection.setRequestProperty("Content-Type", "application/json"); diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/branch/UpdateRetrieverUtil.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/branch/UpdateRetrieverUtil.java new file mode 100644 index 00000000..fe7e54dd --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/branch/UpdateRetrieverUtil.java @@ -0,0 +1,182 @@ +package kr.syeyoung.dungeonsguide.launcher.branch; + +import kr.syeyoung.dungeonsguide.launcher.Main; +import kr.syeyoung.dungeonsguide.launcher.auth.DGResponse; +import kr.syeyoung.dungeonsguide.launcher.exceptions.AssetNotFoundException; +import kr.syeyoung.dungeonsguide.launcher.exceptions.NoVersionFoundException; +import kr.syeyoung.dungeonsguide.launcher.exceptions.ResponseParsingException; +import lombok.Builder; +import lombok.Data; +import org.apache.commons.io.IOUtils; +import org.json.JSONArray; +import org.json.JSONObject; + +import javax.net.ssl.HttpsURLConnection; +import java.io.IOException; +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.ProtocolException; +import java.net.URL; +import java.time.Instant; +import java.util.List; +import java.util.Optional; +import java.util.UUID; +import java.util.stream.Collectors; + +public class UpdateRetrieverUtil { + private static String getResponse(HttpsURLConnection connection) throws IOException { + connection.getResponseCode(); + InputStream toRead = connection.getErrorStream(); + if (toRead == null) + toRead = connection.getInputStream(); + String payload = IOUtils.readLines(toRead).stream().collect(Collectors.joining("\n")); + return payload; + } + + public static List<UpdateBranch> getUpdateBranches() throws IOException { + HttpsURLConnection connection = (HttpsURLConnection) new URL(Main.DOMAIN + "/updates/").openConnection(); + connection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); + connection.setRequestProperty("Content-Type", "application/json"); + connection.setRequestMethod("GET"); + connection.setDoInput(true); + connection.setDoOutput(true); + + JSONArray jsonArray = new JSONArray(getResponse(connection)); + return jsonArray.toList() + .stream() + .map(a -> (JSONObject)a) + .map(a -> { + UpdateBranch updateBranch = new UpdateBranch(); + updateBranch.setId(a.getLong("id")); + updateBranch.setName(a.getString("name")); + updateBranch.setMetadata(a.getJSONObject("metadata")); + return updateBranch; + }).collect(Collectors.toList()); + } + + public static List<Update> getLatestUpdates(long branchId, int page) throws IOException { + HttpsURLConnection connection = (HttpsURLConnection) new URL(Main.DOMAIN + "/updates/"+branchId+"/?page="+page).openConnection(); + connection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); + connection.setRequestMethod("GET"); + connection.setDoInput(true); + connection.setDoOutput(true); + + JSONArray jsonArray = new JSONArray(getResponse(connection)); + return jsonArray.toList() + .stream() + .map(a -> (JSONObject)a) + .map(a -> { + Update update = new Update(); + update.setId(a.getLong("id")); + update.setBranchId(a.getLong("branchId")); + update.setName(a.getString("name")); + update.setUpdateLog(a.getString("updateLog")); + update.setMetadata(a.getJSONObject("metadata")); + update.setAssets(a.getJSONObject("assets").getJSONArray("assets").toList().stream().map(b -> (JSONObject)b) + .map(b -> { + Update.Asset asset = new Update.Asset(); + asset.setName(b.getString("name")); + asset.setAssetId(UUID.fromString(b.getString("assetId"))); + asset.setSize(b.getLong("size")); + asset.setObjectId(b.getString("objectId")); + return asset; + }).collect(Collectors.toList())); + update.setReleaseDate(Instant.parse(a.getString("releaseDate"))); + return update; + }).collect(Collectors.toList()); + } + + public static Update getUpdate(long branchId, long updateId) throws IOException { + HttpsURLConnection connection = (HttpsURLConnection) new URL(Main.DOMAIN + "/updates/"+branchId+"/"+updateId).openConnection(); + connection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); + connection.setRequestMethod("GET"); + connection.setDoInput(true); + connection.setDoOutput(true); + + JSONObject a = new JSONObject(getResponse(connection)); + + Update update = new Update(); + update.setId(a.getLong("id")); + update.setBranchId(a.getLong("branchId")); + update.setName(a.getString("name")); + update.setUpdateLog(a.getString("updateLog")); + update.setMetadata(a.getJSONObject("metadata")); + update.setAssets(a.getJSONObject("assets").getJSONArray("assets").toList().stream().map(b -> (JSONObject)b) + .map(b -> { + Update.Asset asset = new Update.Asset(); + asset.setName(b.getString("name")); + asset.setAssetId(UUID.fromString(b.getString("assetId"))); + asset.setSize(b.getLong("size")); + asset.setObjectId(b.getString("objectId")); + return asset; + }).collect(Collectors.toList())); + update.setReleaseDate(Instant.parse(a.getString("releaseDate"))); + return update; + } + + public static InputStream downloadFile(Update update, String assetName) throws IOException { + Update.Asset asset = update.getAssets().stream().filter(a -> a.getName().equals(assetName)) + .findFirst().orElseThrow(() -> new AssetNotFoundException(update.getBranchId()+"", update.getId()+"("+update.getName()+")", assetName)); + + + HttpsURLConnection connection = (HttpsURLConnection) new URL(Main.DOMAIN + "/updates/"+update.getBranchId()+"/"+update.getId()+"/"+asset.getAssetId()).openConnection(); + connection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); + connection.setRequestMethod("GET"); + connection.setDoInput(true); + connection.setDoOutput(true); + + JSONObject result = new JSONObject(getResponse(connection)); + String url = result.getString("url"); + String method = result.getString("method"); + + connection = (HttpsURLConnection) new URL(url).openConnection(); + connection.setRequestProperty("User-Agent", "DungeonsGuide/1.0"); + connection.setRequestMethod(method); + return connection.getInputStream(); + } + + @Data @Builder + public static class VersionInfo { + String friendlyBranchName = ""; + long branchId; + String friendlyVersionName = ""; + long updateId; + } + public static VersionInfo getIds(String branch, String version) throws IOException { + long branchId = -1, updateId = -1; + UpdateBranch branch1 = null; + for (UpdateBranch updateBranch : UpdateRetrieverUtil.getUpdateBranches()) { + if (updateBranch.getName().equals(branch) || (branch.equals("$default") && + Optional.ofNullable(updateBranch.getMetadata()) + .map(a -> a.getJSONObject("additionalMeta")) + .map(a -> a.getBoolean("defaultMod")).orElse(false))) { + branchId = updateBranch.getId(); + branch1 = updateBranch; + break; + } + } + if (branchId == -1) return null; + + Update target = null; + int page = 0; + while (updateId == -1) { + List<Update> updateList = UpdateRetrieverUtil.getLatestUpdates(branchId, page++); + if (updateList == null || updateList.isEmpty()) return null; + for (Update update : updateList) { + if (update.getName().equals(version) || version.equals("latest")) { // if latest, get the first one. + updateId = update.getId(); + target = update; + break; + } + } + } + + + return VersionInfo.builder() + .branchId(branchId) + .updateId(updateId) + .friendlyBranchName(branch1.getName()) + .friendlyVersionName(target.getName()) + .build(); + } +} diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/AssetNotFoundException.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/AssetNotFoundException.java new file mode 100644 index 00000000..d04608e4 --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/AssetNotFoundException.java @@ -0,0 +1,35 @@ +/* + * Dungeons Guide - The most intelligent Hypixel Skyblock Dungeons Mod + * Copyright (C) 2021 cyoung06 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +package kr.syeyoung.dungeonsguide.launcher.exceptions; + +import lombok.Getter; + +@Getter +public class AssetNotFoundException extends RuntimeException { + private String branch; + private String version; + private String asset; + + public AssetNotFoundException(String branch, String version, String asset) { + super("No asset found: "+branch+" - "+version+" - "+asset); + this.branch = branch; + this.version = version; + this.asset = asset; + } +} diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/InvalidSignatureException.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/InvalidSignatureException.java new file mode 100644 index 00000000..bda43ea4 --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/InvalidSignatureException.java @@ -0,0 +1,37 @@ +/* + * Dungeons Guide - The most intelligent Hypixel Skyblock Dungeons Mod + * Copyright (C) 2021 cyoung06 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +package kr.syeyoung.dungeonsguide.launcher.exceptions; + +import kr.syeyoung.dungeonsguide.launcher.branch.Update; +import lombok.Getter; + +@Getter +public class InvalidSignatureException extends RuntimeException { + private Update update; + + public InvalidSignatureException(Update update, String message) { + super(message); + this.update = update; + } + + public InvalidSignatureException(Update update, Throwable t) { + super(t); + this.update = update; + } +} diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/NoVersionFoundException.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/NoVersionFoundException.java new file mode 100644 index 00000000..b99d12c1 --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/exceptions/NoVersionFoundException.java @@ -0,0 +1,38 @@ +/* + * Dungeons Guide - The most intelligent Hypixel Skyblock Dungeons Mod + * Copyright (C) 2021 cyoung06 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + +package kr.syeyoung.dungeonsguide.launcher.exceptions; + +import lombok.Getter; + +@Getter +public class NoVersionFoundException extends RuntimeException { + private String branch; + private String version; + + public NoVersionFoundException(String branch, String version) { + super("No version found: "+branch+" - "+version); + this.branch = branch; + this.version = version; + } + public NoVersionFoundException(String branch, String version, Throwable e) { + super("No version found: "+branch+" - "+version, e); + this.branch = branch; + this.version = version; + } +} diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/ByteStreamURLHandler.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/ByteStreamURLHandler.java new file mode 100644 index 00000000..d0859076 --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/ByteStreamURLHandler.java @@ -0,0 +1,46 @@ +package kr.syeyoung.dungeonsguide.launcher.loader; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.net.URLConnection; +import java.net.URLStreamHandler; + +public class ByteStreamURLHandler extends URLStreamHandler { + private InputStreamGenerator converter; + public ByteStreamURLHandler(InputStreamGenerator converter) { + this.converter = converter; + } + public interface InputStreamGenerator { + InputStream convert(String name); + } + + public class ByteStreamURLConnection extends URLConnection { + + /** + * Constructs a URL connection to the specified URL. A connection to + * the object referenced by the URL is not created. + * + * @param url the specified URL. + */ + protected ByteStreamURLConnection(URL url) { + super(url); + connected = false; + } + + @Override + public void connect() throws IOException { + connected = true; + } + + @Override + public InputStream getInputStream() throws IOException { + return converter.convert(url.getPath()); + } + } + + @Override + protected URLConnection openConnection(URL u) throws IOException { + return new ByteStreamURLConnection(u); + } +} diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/DGClassLoader.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/DGClassLoader.java new file mode 100644 index 00000000..1fbc39b0 --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/DGClassLoader.java @@ -0,0 +1,81 @@ +package kr.syeyoung.dungeonsguide.launcher.loader; + +import sun.misc.Resource; + +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; + +public abstract class DGClassLoader extends ClassLoader implements ByteStreamURLHandler.InputStreamGenerator{ + public DGClassLoader(ClassLoader parent) { + super(parent); + } + + public Class<?> loadClass(String name, boolean resolve) + throws ClassNotFoundException + { + synchronized (getClassLoadingLock(name)) { + // First, check if the class has already been loaded + Class<?> c = findLoadedClass(name); + if (c == null) { + try { + if (c == null) { + long t0 = System.nanoTime(); + c = findClass(name); + + sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t0); + sun.misc.PerfCounter.getFindClasses().increment(); + } + } catch (ClassNotFoundException e) { + // ClassNotFoundException thrown if class not found + // from the non-null parent class loader + } + if (getParent() != null && c == null) { + long t0 = System.nanoTime(); + c = getParent().loadClass(name); + long t1 = System.nanoTime(); + sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); + } + } + if (resolve) { + resolveClass(c); + } + return c; + } + } + + @Override + protected Class<?> findClass(String name) throws ClassNotFoundException { + byte[] res; + try { + res = getClassBytes(name); + } catch (IOException e) { + throw new ClassNotFoundException(name, e); + } + if (res != null) { + return defineClass(name, res, 0, res.length); + } else { + throw new ClassNotFoundException(name); + } + } + + public abstract byte[] getClassBytes(String name) throws IOException; + + public URL getResource(String name) { + URL url = findResource(name); + if (url == null && getParent() != null ) { + url = getParent().getResource(name); + } + return url; + } + + private ByteStreamURLHandler urlHandler = new ByteStreamURLHandler(this); + @Override + public URL findResource(String name) { + try { + return new URL("dungeonsguide", "",0, name, urlHandler); + } catch (MalformedURLException e) { + throw new RuntimeException(e); + } + } +} diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/IDGLoader.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/IDGLoader.java index f5149f82..a79fdb7e 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/IDGLoader.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/IDGLoader.java @@ -21,8 +21,10 @@ package kr.syeyoung.dungeonsguide.launcher.loader; import kr.syeyoung.dungeonsguide.launcher.DGInterface; import kr.syeyoung.dungeonsguide.launcher.exceptions.ReferenceLeakedException; +import java.io.IOException; + public interface IDGLoader { - DGInterface loadDungeonsGuide() throws InstantiationException, IllegalAccessException, ClassNotFoundException; + DGInterface loadDungeonsGuide() throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException; DGInterface getInstance(); void unloadDungeonsGuide() throws ReferenceLeakedException; diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/JarLoader.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/JarLoader.java index 6baee0f3..fa86054d 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/JarLoader.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/JarLoader.java @@ -21,7 +21,12 @@ package kr.syeyoung.dungeonsguide.launcher.loader; import kr.syeyoung.dungeonsguide.launcher.DGInterface; import kr.syeyoung.dungeonsguide.launcher.Main; import kr.syeyoung.dungeonsguide.launcher.exceptions.ReferenceLeakedException; +import org.apache.commons.io.IOUtils; +import sun.misc.Resource; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; import java.io.InputStream; import java.lang.ref.PhantomReference; import java.lang.ref.Reference; @@ -29,6 +34,9 @@ import java.lang.ref.ReferenceQueue; import java.lang.ref.WeakReference; import java.net.URL; import java.net.URLClassLoader; +import java.util.HashMap; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; public class JarLoader implements IDGLoader { private DGInterface dgInterface; @@ -37,60 +45,40 @@ public class JarLoader implements IDGLoader { private boolean loaded; - public static class JarClassLoader extends URLClassLoader { - public JarClassLoader(URL[] urls, ClassLoader parent) { - super(urls, parent); - } + public static class JarClassLoader extends DGClassLoader { + public JarClassLoader(ClassLoader parent, ZipInputStream zipInputStream) throws IOException { + super(parent); - @Override - protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { - - synchronized (getClassLoadingLock(name)) { - Class<?> c = findLoadedClass(name); - if (c == null) { - - try { - if (c == null) { - long t0 = System.nanoTime(); - c = findClass(name); - - sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t0); - sun.misc.PerfCounter.getFindClasses().increment(); - } - } catch (ClassNotFoundException e) { - // ClassNotFoundException thrown if class not found - // from the non-null parent class loader - } - if (getParent() != null && c == null) { - long t0 = System.nanoTime(); - c = getParent().loadClass(name); - long t1 = System.nanoTime(); - sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); - } - } - if (resolve) { - resolveClass(c); - } - return c; + ZipEntry zipEntry; + while ((zipEntry=zipInputStream.getNextEntry()) != null) { + this.loadedResources.put(zipEntry.getName(), IOUtils.toByteArray(zipInputStream)); } + + zipInputStream.close(); + } + private final HashMap<String, byte[]> loadedResources = new HashMap<String, byte[]>(); + @Override + public byte[] getClassBytes(String name) throws IOException { // . separated. + return this.loadedResources.get(name.replace(".", "/")); } - public Class<?> loadClassResolve(String name, boolean resolve) throws ClassNotFoundException { - return this.loadClass(name, resolve); + @Override + public InputStream convert(String name) { // / separated + if (this.loadedResources.containsKey(name.substring(1))) + return new ByteArrayInputStream(this.loadedResources.get(name.substring(1))); + return null; } } private JarClassLoader classLoader; @Override - public DGInterface loadDungeonsGuide() throws ClassNotFoundException, InstantiationException, IllegalAccessException { + public DGInterface loadDungeonsGuide() throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException { if (dgInterface != null) throw new IllegalStateException("Already loaded"); - classLoader = new JarClassLoader(new URL[] { - Main.class.getResource("/mod.jar") - }, this.getClass().getClassLoader()); + classLoader = new JarClassLoader(this.getClass().getClassLoader(), new ZipInputStream(JarLoader.class.getResourceAsStream("/mod.jar"))); - dgInterface = (DGInterface) classLoader.loadClassResolve("kr.syeyoung.dungeonsguide.DungeonsGuide", true).newInstance(); + dgInterface = (DGInterface) classLoader.loadClass("kr.syeyoung.dungeonsguide.DungeonsGuide", true).newInstance(); phantomReference = new PhantomReference<>(classLoader, refQueue); return dgInterface; } diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/LocalLoader.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/LocalLoader.java index ef9b3e7a..683f77d0 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/LocalLoader.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/LocalLoader.java @@ -20,16 +20,54 @@ package kr.syeyoung.dungeonsguide.launcher.loader; import kr.syeyoung.dungeonsguide.launcher.DGInterface; import kr.syeyoung.dungeonsguide.launcher.exceptions.ReferenceLeakedException; +import org.apache.commons.io.IOUtils; +import java.io.ByteArrayInputStream; +import java.io.IOException; import java.io.InputStream; +import java.lang.ref.PhantomReference; +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.util.HashMap; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; public class LocalLoader implements IDGLoader { private DGInterface dgInterface; + private ReferenceQueue<ClassLoader> refQueue = new ReferenceQueue<>(); + private PhantomReference<ClassLoader> phantomReference; + + private boolean loaded; + + public static class LocalClassLoader extends DGClassLoader { + public LocalClassLoader(ClassLoader parent) throws IOException { + super(parent); + } + @Override + public byte[] getClassBytes(String name) throws IOException { // . separated. + InputStream in = convert("/"+name.replace(".", "/")); + if (in == null) return null; + return IOUtils.toByteArray(in); + } + + @Override + public InputStream convert(String name) { // / separated + return LocalLoader.class.getResourceAsStream(name); + } + } + + private LocalClassLoader classLoader; + @Override - public DGInterface loadDungeonsGuide() throws ClassNotFoundException, InstantiationException, IllegalAccessException { + public DGInterface loadDungeonsGuide() throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException { if (dgInterface != null) throw new IllegalStateException("Already loaded"); - return dgInterface = (DGInterface) Class.forName("kr.syeyoung.dungeonsguide.DungeonsGuide").newInstance(); + + classLoader = new LocalClassLoader(this.getClass().getClassLoader()); + + dgInterface = (DGInterface) classLoader.loadClass("kr.syeyoung.dungeonsguide.DungeonsGuide", true).newInstance(); + phantomReference = new PhantomReference<>(classLoader, refQueue); + return dgInterface; } @Override @@ -39,11 +77,19 @@ public class LocalLoader implements IDGLoader { @Override public void unloadDungeonsGuide() throws ReferenceLeakedException { - throw new UnsupportedOperationException(); + classLoader = null; + dgInterface.unload(); + dgInterface = null; + System.gc();// pls do + Reference<? extends ClassLoader> t = refQueue.poll(); + if (t == null) throw new ReferenceLeakedException(); // Why do you have to be that strict? Well, to tell them to actually listen on DungeonsGuideReloadListener. If it starts causing issues then I will remove check cus it's not really loaded (classes are loaded by child classloader) + t.clear(); + phantomReference = null; } + @Override public boolean isUnloadable() { - return false; + return true; } @Override diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/RemoteLoader.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/RemoteLoader.java index 98155245..719f5cce 100644 --- a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/RemoteLoader.java +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/RemoteLoader.java @@ -1,99 +1,152 @@ +/* + * Dungeons Guide - The most intelligent Hypixel Skyblock Dungeons Mod + * Copyright (C) 2021 cyoung06 + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as published + * by the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see <https://www.gnu.org/licenses/>. + */ + package kr.syeyoung.dungeonsguide.launcher.loader; import kr.syeyoung.dungeonsguide.launcher.DGInterface; +import kr.syeyoung.dungeonsguide.launcher.branch.Update; +import kr.syeyoung.dungeonsguide.launcher.branch.UpdateBranch; +import kr.syeyoung.dungeonsguide.launcher.branch.UpdateRetrieverUtil; +import kr.syeyoung.dungeonsguide.launcher.exceptions.InvalidSignatureException; +import kr.syeyoung.dungeonsguide.launcher.exceptions.NoVersionFoundException; import kr.syeyoung.dungeonsguide.launcher.exceptions.ReferenceLeakedException; +import org.apache.commons.io.IOUtils; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; import java.lang.ref.PhantomReference; +import java.lang.ref.Reference; import java.lang.ref.ReferenceQueue; -import java.net.URL; -import java.net.URLClassLoader; +import java.util.HashMap; +import java.util.List; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; public class RemoteLoader implements IDGLoader { - private String branch; - private String version; - - + private DGInterface dgInterface; private ReferenceQueue<ClassLoader> refQueue = new ReferenceQueue<>(); private PhantomReference<ClassLoader> phantomReference; private boolean loaded; - public static class JarClassLoader extends URLClassLoader { - public JarClassLoader(URL[] urls, ClassLoader parent) { - super(urls, parent); - } + public RemoteLoader(String friendlyBranchName, long branchId, long updateId) { + this.friendlyBranchName = friendlyBranchName; + this.branchId = branchId; + this.updateId = updateId; + } - @Override - protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException { - - synchronized (getClassLoadingLock(name)) { - Class<?> c = findLoadedClass(name); - if (c == null) { - - try { - if (c == null) { - long t0 = System.nanoTime(); - c = findClass(name); - - sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t0); - sun.misc.PerfCounter.getFindClasses().increment(); - } - } catch (ClassNotFoundException e) { - // ClassNotFoundException thrown if class not found - // from the non-null parent class loader - } - if (getParent() != null && c == null) { - long t0 = System.nanoTime(); - c = getParent().loadClass(name); - long t1 = System.nanoTime(); - sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); - } - } - if (resolve) { - resolveClass(c); - } - return c; + + public static class JarClassLoader extends DGClassLoader { + public JarClassLoader(ClassLoader parent, ZipInputStream zipInputStream) throws IOException { + super(parent); + + ZipEntry zipEntry; + while ((zipEntry=zipInputStream.getNextEntry()) != null) { + this.loadedResources.put(zipEntry.getName(), IOUtils.toByteArray(zipInputStream)); } + + zipInputStream.close(); + } + private final HashMap<String, byte[]> loadedResources = new HashMap<String, byte[]>(); + @Override + public byte[] getClassBytes(String name) throws IOException { // . separated. + return this.loadedResources.get(name.replace(".", "/")); } - public Class<?> loadClassResolve(String name, boolean resolve) throws ClassNotFoundException { - return this.loadClass(name, resolve); + @Override + public InputStream convert(String name) { // / separated + if (this.loadedResources.containsKey(name.substring(1))) + return new ByteArrayInputStream(this.loadedResources.get(name.substring(1))); + return null; } } - private JarLoader.JarClassLoader classLoader; + private JarClassLoader classLoader; + + + @Override - public DGInterface loadDungeonsGuide() throws InstantiationException, IllegalAccessException, ClassNotFoundException { - return null; + public DGInterface loadDungeonsGuide() throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException { + if (dgInterface != null) throw new IllegalStateException("Already loaded"); + + Update target = UpdateRetrieverUtil.getUpdate(branchId, updateId); + friendlyVersionName = target.getName(); + + InputStream in; + byte[] mod = IOUtils.toByteArray(in = UpdateRetrieverUtil.downloadFile(target, "mod.jar")); + in.close(); + byte[] signature =IOUtils.toByteArray(in = UpdateRetrieverUtil.downloadFile(target, "signature.asc")); + in.close(); + int version = target.getMetadata().getInt("signatureVersion"); + + if (version == 0) { + SignatureValidator.validateVersion1Signature(target, mod, signature); + } else { + throw new InvalidSignatureException(target, "Invalid Signature Version: "+version); + } + + classLoader = new JarClassLoader(this.getClass().getClassLoader(), new ZipInputStream(new ByteArrayInputStream(mod))); + + dgInterface = (DGInterface) classLoader.loadClass("kr.syeyoung.dungeonsguide.DungeonsGuide", true).newInstance(); + phantomReference = new PhantomReference<>(classLoader, refQueue); + return dgInterface; } @Override public DGInterface getInstance() { - return null; + return dgInterface; } @Override public void unloadDungeonsGuide() throws ReferenceLeakedException { - + classLoader = null; + dgInterface.unload(); + dgInterface = null; + System.gc();// pls do + Reference<? extends ClassLoader> t = refQueue.poll(); + if (t == null) throw new ReferenceLeakedException(); // Why do you have to be that strict? Well, to tell them to actually listen on DungeonsGuideReloadListener. If it starts causing issues then I will remove check cus it's not really loaded (classes are loaded by child classloader) + t.clear(); + phantomReference = null; } @Override public boolean isUnloadable() { - return false; + return true; } @Override public boolean isLoaded() { - return false; + return dgInterface != null; } @Override public String loaderName() { - return branch; + return "remote"; } + private long branchId = -1; // pre-retrieved + private long updateId = -1; // pre-retrieved + + private String friendlyBranchName = ""; + private String friendlyVersionName = ""; @Override public String version() { - return version; + return friendlyBranchName+"("+branchId+")@"+friendlyVersionName+"("+updateId+")"; // maybe read the thing... } } diff --git a/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/SignatureValidator.java b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/SignatureValidator.java new file mode 100644 index 00000000..7a8ce832 --- /dev/null +++ b/loader/src/main/java/kr/syeyoung/dungeonsguide/launcher/loader/SignatureValidator.java @@ -0,0 +1,43 @@ +package kr.syeyoung.dungeonsguide.launcher.loader; + +import kr.syeyoung.dungeonsguide.launcher.branch.Update; +import kr.syeyoung.dungeonsguide.launcher.exceptions.InvalidSignatureException; +import org.apache.commons.codec.binary.Base64; + +import java.security.*; +import java.security.spec.InvalidKeySpecException; +import java.security.spec.X509EncodedKeySpec; + +public class SignatureValidator { + private static PublicKey dgPublicKey; + private static PublicKey getDGPublicKey() throws NoSuchAlgorithmException, InvalidKeySpecException { + if (dgPublicKey != null) return dgPublicKey; + X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decodeBase64("MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxO89qtwG67jNucQ9Y44c" + + "IUs/B+5BeJPs7G+RG2gfs4/2+tzF/c1FLDc33M7yKw8aKk99vsBUY9Oo8gxxiEPB" + + "JitP/qfon2THp94oM77ZTpHlmFoqbZMcKGZVI8yfvEL4laTM8Hw+qh5poQwtpEbK" + + "Xo47AkxygxJasUnykER2+aSTZ6kWU2D4xiNtFA6lzqN+/oA+NaYfPS0amAvyVlHR" + + "n/8IuGkxb5RrlqVssQstFnxsJuv88qdGSEqlcKq2tLeg9hb8eCnl2OFzvXmgbVER" + + "0JaV+4Z02fVG1IlR3Xo1mSit7yIU6++3usRCjx2yfXpnGGJUW5pe6YETjNew3ax+" + + "FAZ4GePWCdmS7FvBnbbABKo5pE06ZTfDUTCjQlAJQiUgoF6ntMJvQAXPu48Vr8q/" + + "mTcuZWVnI6CDgyE7nNq3WNoq3397sBzxRohMxuqzl3T19zkfPKF05iV2Ju1HQMW5" + + "I119bYrmVD240aGESZc20Sx/9g1BFpNzQbM5PGUlWJ0dhLjl2ge4ip2hHciY3OEY" + + "p2Qy2k+xEdenpKdL+WMRimCQoO9gWe2Tp4NmP5dppDXZgPjXqjZpnGs0Uxs+fXqW" + + "cwlg3MbX3rFl9so/fhVf4p9oXZK3ve7z5D6XSSDRYECvsKIa08WAxJ/U6n204E/4" + + "xUF+3ZgFPdzZGn2PU7SsnOsCAwEAAQ==")); + return dgPublicKey = KeyFactory.getInstance("RSA").generatePublic(spec); + } + + public static void validateVersion1Signature(Update update, byte[] payload, byte[] signature) { + try { + Signature sign = Signature.getInstance("SHA512withRSA"); + sign.initVerify(getDGPublicKey()); + sign.update(payload); + boolean truth = sign.verify(signature); + if (!truth) throw new InvalidSignatureException(update, "DG SIGNATURE FORGED"); + }catch (NoSuchAlgorithmException | InvalidKeySpecException | SignatureException | InvalidKeyException e) { + throw new InvalidSignatureException(update, e); + } + } + + +} |