Mega PR; Slash Commands, Rate limits, Code Clean up and more!

annotations/src/main/java/com/javadiscord/jdi/core/CommandOptionType.java

@@ -0,0 +1,26 @@
+package com.javadiscord.jdi.core;
+
+public enum CommandOptionType {
+    SUB_COMMAND(1),
+    SUB_COMMAND_GROUP(2),
+    STRING(3),
+    INTEGER(4),
+    BOOLEAN(5),
+    USER(6),
+    CHANNEL(7),
+    ROLE(8),
+    MENTIONABLE(9),
+    NUMBER(10),
+    ATTACHMENT(11),
+    ;
+
+    private final int value;
+
+    CommandOptionType(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/CommandOption.java

@@ -0,0 +1,21 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import com.javadiscord.jdi.core.CommandOptionType;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({})
+public @interface CommandOption {
+    String name();
+
+    String description();
+
+    CommandOptionType type();
+
+    CommandOptionChoice[] choices() default {};
+
+    boolean required() default true;
+}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/CommandOptionChoice.java

@@ -0,0 +1,13 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({})
+public @interface CommandOptionChoice {
+    String name();
+
+    String value();
+}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/Component.java

@@ -0,0 +1,10 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface Component {}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/Inject.java

@@ -0,0 +1,10 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface Inject {}

annotations/src/main/java/com/javadiscord/jdi/core/annotations/SlashCommand.java

@@ -0,0 +1,16 @@
+package com.javadiscord.jdi.core.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface SlashCommand {
+    String name();
+
+    String description();
+
+    CommandOption[] options() default {};
+}

annotations/src/main/java/com/javadiscord/jdi/internal/exceptions/ComponentInjectionException.java

@@ -0,0 +1,13 @@
+package com.javadiscord.jdi.internal.exceptions;
+
+public class ComponentInjectionException extends RuntimeException {
+
+    public ComponentInjectionException() {
+        super();
+    }
+
+    public ComponentInjectionException(String message) {
+        super(message);
+    }
+
+}

annotations/src/main/java/com/javadiscord/jdi/internal/exceptions/NoZeroArgConstructorException.java

@@ -0,0 +1,13 @@
+package com.javadiscord.jdi.internal.exceptions;
+
+public class NoZeroArgConstructorException extends RuntimeException {
+
+    public NoZeroArgConstructorException() {
+        super();
+    }
+
+    public NoZeroArgConstructorException(String message) {
+        super(message);
+    }
+
+}

annotations/src/main/java/com/javadiscord/jdi/internal/exceptions/ValidationException.java

@@ -0,0 +1,12 @@
+package com.javadiscord.jdi.internal.exceptions;
+
+public class ValidationException extends RuntimeException {
+
+    public ValidationException() {
+        super();
+    }
+
+    public ValidationException(String message) {
+        super(message);
+    }
+}

annotations/src/main/java/com/javadiscord/jdi/core/processor/ClassFileUtil.java → annotations/src/main/java/com/javadiscord/jdi/internal/processor/ClassFileUtil.java

@@ -1,63 +1,75 @@
-package com.javadiscord.jdi.core.processor;
+package com.javadiscord.jdi.internal.processor;
 
 import java.io.DataInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 import javassist.bytecode.ClassFile;
 
 public class ClassFileUtil {
+    private static final List<File> classesInPath = new ArrayList<>();
+    private static boolean loadedParentJar = false;
 
-    private ClassFileUtil() {}
+    private ClassFileUtil() {
+        throw new UnsupportedOperationException("Utility class");
+    }
 
     public static List<File> getClassesInClassPath() {
-        List<File> classes = new ArrayList<>();
-        String classpath = System.getProperty("java.class.path");
-        String[] classpathEntries = classpath.split(File.pathSeparator);
-        for (String entry : classpathEntries) {
-            File file = new File(entry);
-            try {
-                classes.addAll(getClasses(file));
-            } catch (IOException ignore) {
-                /* Ignore */
+        if (classesInPath.isEmpty()) {
+            String classpath = System.getProperty("java.class.path");
+            String[] classpathEntries = classpath.split(File.pathSeparator);
+
+            for (String entry : classpathEntries) {
+                File file = new File(entry);
+                try {
+                    classesInPath.addAll(getClasses(file));
+                } catch (IOException ignore) {
+                    /* Ignore */
+                }
             }
         }
-        return classes;
+        return classesInPath;
     }
 
     public static String getClassName(File file) throws IOException {
-        String className = null;
         try (
             FileInputStream fis = new FileInputStream(file);
             DataInputStream dis = new DataInputStream(fis)
         ) {
             if (isJarFile(file)) {
-                try (ZipInputStream zip = new ZipInputStream(fis)) {
-                    ZipEntry entry;
-                    while ((entry = zip.getNextEntry()) != null) {
-                        if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
-                            className = extractClassName(zip);
-                            break;
-                        }
-                    }
-                }
+                return getClassNameFromJar(fis);
             } else {
-                className = extractClassName(dis);
+                return extractClassName(dis);
+            }
+        }
+    }
+
+    private static String getClassNameFromJar(FileInputStream fis) throws IOException {
+        try (ZipInputStream zip = ZipSecurity.createSecureInputStream(new ZipInputStream(fis))) {
+            ZipEntry entry;
+            while ((entry = zip.getNextEntry()) != null) {
+                if (!entry.isDirectory() && entry.getName().endsWith(".class")) {
+                    return extractClassName(zip);
+                }
             }
         }
-        return className;
+        return null;
     }
 
     private static List<File> getClasses(File file) throws IOException {
         List<File> classFiles = new ArrayList<>();
         if (file.isDirectory()) {
             classFiles.addAll(getClassesFromDirectory(file));
-        } else if (isJarFile(file)) {
+        } else if (isJarFile(file) && !loadedParentJar) {
+            loadedParentJar = true;
             classFiles.addAll(getClassesFromJar(file));
         } else if (file.getName().endsWith(".class")) {
             classFiles.add(file);
@@ -80,7 +92,7 @@ private static List<File> getClassesFromJar(File jarFile) throws IOException {
         List<File> classFiles = new ArrayList<>();
         try (
             FileInputStream fis = new FileInputStream(jarFile);
-            ZipInputStream zip = new ZipInputStream(fis)
+            ZipInputStream zip = ZipSecurity.createSecureInputStream(new ZipInputStream(fis))
         ) {
             ZipEntry entry;
             while ((entry = zip.getNextEntry()) != null) {
@@ -109,7 +121,7 @@ private static File extractClassFileFromJar(
         ZipInputStream zip,
         String entryName
     ) throws IOException {
-        File tempFile = File.createTempFile(entryName.replace('/', '_'), ".class");
+        File tempFile = safeTempFile(entryName).toFile();
         tempFile.deleteOnExit();
         try (FileOutputStream fos = new FileOutputStream(tempFile)) {
             byte[] buffer = new byte[1024];
@@ -120,4 +132,10 @@ private static File extractClassFileFromJar(
         }
         return tempFile;
     }
+
+    private static Path safeTempFile(String entryName) throws IOException {
+        String sanitizedEntryName = entryName.replace('/', '_');
+        Path secureTempDir = Paths.get(System.getProperty("java.io.tmpdir"));
+        return Files.createTempFile(secureTempDir, sanitizedEntryName, ".class");
+    }
 }

annotations/src/main/java/com/javadiscord/jdi/internal/processor/SlashCommandClassMethod.java

@@ -0,0 +1,5 @@
+package com.javadiscord.jdi.internal.processor;
+
+import java.lang.reflect.Method;
+
+public record SlashCommandClassMethod(Class<?> clazz, Method method) {}

annotations/src/main/java/com/javadiscord/jdi/internal/processor/ZipSecurity.java

@@ -0,0 +1,68 @@
+package com.javadiscord.jdi.internal.processor;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+public class ZipSecurity {
+
+    public static ZipInputStream createSecureInputStream(InputStream stream) {
+        return new SecureZipInputStream(stream);
+    }
+
+    private static class SecureZipInputStream extends ZipInputStream {
+
+        public SecureZipInputStream(InputStream in) {
+            super(in);
+        }
+
+        @Override
+        public ZipEntry getNextEntry() throws IOException {
+            ZipEntry entry = super.getNextEntry();
+            if (entry == null) {
+                return null;
+            }
+            String entryName = entry.getName();
+            if (!entryName.trim().isEmpty()) {
+                if (isAbsolutePath(entryName)) {
+                    throw new SecurityException(
+                        "Encountered zip file with absolute path: " + entryName
+                    );
+                }
+                if (containsPathTraversal(entryName)) {
+                    throw new SecurityException(
+                        "Path contains traversal to sensitive locations: " + entryName
+                    );
+                }
+            }
+            return entry;
+        }
+
+        private boolean containsPathTraversal(String entryName) {
+            if (entryName.contains("../") || entryName.contains("..\\")) {
+                try {
+                    if (isPathOutsideCurrentDirectory(entryName)) {
+                        return true;
+                    }
+                } catch (IOException ignore) {
+                    /* Ignore */
+                }
+            }
+            return false;
+        }
+
+        private boolean isPathOutsideCurrentDirectory(String entryName) throws IOException {
+            File currentDirectory = new File("").getCanonicalFile();
+            File untrustedFile = new File(currentDirectory, entryName);
+            Path untrustedPath = untrustedFile.getCanonicalFile().toPath();
+            return !untrustedPath.startsWith(currentDirectory.toPath());
+        }
+
+        private boolean isAbsolutePath(String entryName) {
+            return entryName.startsWith("/");
+        }
+    }
+}