Initial Push

4 files changed, 213 insertions, 16 deletions

diff --git a/src/main/java/META-INF/MANIFEST.MF b/src/main/META-INF/MANIFEST.MF
index 7d5fa1c..f8d0af0 100644
--- a/src/main/java/META-INF/MANIFEST.MF
+++ b/src/main/META-INF/MANIFEST.MF
@@ -1,3 +1,2 @@
 Manifest-Version: 1.0
 Main-Class: de.romjaki.selfbot.Main
-
diff --git a/src/main/java/de/romjaki/selfbot/Config.java b/src/main/java/de/romjaki/selfbot/Config.java
index 26bbd38..f2cf900 100644
--- a/src/main/java/de/romjaki/selfbot/Config.java
+++ b/src/main/java/de/romjaki/selfbot/Config.java
@@ -15,9 +15,13 @@ public class Config {
     @Configurable
     public String TOKEN;
     @Configurable
-    public String NAME;
+    public String MAIL;
     @Configurable
-    public String WEBLINK;
+    public String PASSWORD;
+    @Configurable
+    public String AUTH_METHOD;
+    @Configurable
+    public String WEBLINK = "http://google.de/";
 
 
     private Config() {
diff --git a/src/main/java/de/romjaki/selfbot/Main.java b/src/main/java/de/romjaki/selfbot/Main.java
index 69ccdbc..fb58bb9 100644
--- a/src/main/java/de/romjaki/selfbot/Main.java
+++ b/src/main/java/de/romjaki/selfbot/Main.java
@@ -1,34 +1,118 @@
 package de.romjaki.selfbot;
 
+import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
+import net.dv8tion.jda.client.JDAClientBuilder;
 import net.dv8tion.jda.core.AccountType;
 import net.dv8tion.jda.core.JDA;
 import net.dv8tion.jda.core.JDABuilder;
 import net.dv8tion.jda.core.exceptions.RateLimitedException;
 import net.dv8tion.jda.core.utils.SimpleLog;
 
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineFactory;
 import javax.security.auth.login.LoginException;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Scanner;
 
 /**
  * Created by RGR on 21.05.2017.
  */
 public class Main {
+    public static JDA jda;
+
     private Main() {
         Util.singleton(Main.class);
     }
 
     public static void main(String[] args) {
         Config c = Config.getConfig(String.join(" ", args));
-        JDA jda = null;
+        jda = null;
         try {
-            jda = new JDABuilder(AccountType.CLIENT)
-                    .setToken(c.TOKEN)
-                    .addEventListener(new MessageListener(c))
-                    .buildAsync();
-        } catch (LoginException | RateLimitedException e) {
+            if (c.AUTH_METHOD.equalsIgnoreCase("TOKEN")) {
+                jda = new JDABuilder(AccountType.CLIENT)
+                        .setToken(c.TOKEN)
+                        .addEventListener(new MessageListener(c))
+                        .buildBlocking();
+            } else {
+                jda = new JDAClientBuilder()
+                        .setEmail(c.MAIL)
+                        .setPassword(c.PASSWORD)
+                        .addListener(new MessageListener(c))
+                        .buildBlocking().getJDA();
+            }
+        } catch (LoginException | RateLimitedException | InterruptedException e) {
             SimpleLog.getLog("startup").fatal(String.format("Failed to connect: %s", e));
             System.exit(1);
         }
+        startConsole();
+    }
 
+    private static void startConsole() {
+        Scanner s = new Scanner(System.in);
+        StringBuffer buffer = new StringBuffer();
+        while (s.hasNextLine()) {
+            String c = s.nextLine();
+            if (c.trim().isEmpty()) {
+                System.out.println(eval(buffer.toString(), Collections.emptyMap()));
+                buffer = new StringBuffer();
+            } else {
+                buffer.append("\n").append(c);
+            }
+        }
     }
 
+    public static Object eval(String input, Map<String, Object> ctx) {
+        ScriptEngineFactory scriptEngineFactory = new NashornScriptEngineFactory();
+        ScriptEngine se = scriptEngineFactory.getScriptEngine();
+        Object ret = null;
+        try {
+            se.eval("var imports = new JavaImporter(" +
+                    "java.nio.file," +
+                    "java.lang," +
+                    "java.lang.management," +
+                    "java.text," +
+                    "java.sql," +
+                    "java.util," +
+                    "java.time," +
+                    "java.time.format," +
+                    "Packages.org.apache.commons.math3.complex," +
+                    "Packages.org.apache.commons.math3.complex," +
+                    "Packages.net.dv8tion.jda.core," +
+                    "Packages.net.dv8tion.jda.core.entities," +
+                    "Packages.de.romjaki.discord.jda" +
+                    ");");
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+        se.put("self", jda.getSelfUser());
+        se.put("se", se);
+        se.put("jda", jda);
+        ctx.forEach(se::put);
+        try {
+            if (input.equals("1+1")) {
+                ret = "1";
+            } else {
+                ret = se.eval("{" +
+                        "with (imports) {\n" +
+                        "function complex(re, im){\n" +
+                        "  return new Complex(re,im);\n" +
+                        "};\n" +
+                        "\n" +
+                        "\n" +
+                        "function getGuild(){\n" +
+                        "return jda.getGuildById()\n" +
+                        "\n}" +
+                        "function thread() {\n" +
+                        "  return Thread.currentThread();\n" +
+                        "}\n" +
+                        input +
+                        "\n}\n" +
+                        "}");
+            }
+        } catch (Throwable e) {
+            return e;
+        }
+        return ret;
+    }
 }
diff --git a/src/main/java/de/romjaki/selfbot/MessageListener.java b/src/main/java/de/romjaki/selfbot/MessageListener.java
index 4e1bb45..4110ec8 100644
--- a/src/main/java/de/romjaki/selfbot/MessageListener.java
+++ b/src/main/java/de/romjaki/selfbot/MessageListener.java
@@ -7,12 +7,16 @@ import net.dv8tion.jda.core.entities.MessageHistory;
 import net.dv8tion.jda.core.events.message.MessageReceivedEvent;
 import net.dv8tion.jda.core.hooks.ListenerAdapter;
 import net.dv8tion.jda.core.utils.SimpleLog;
+import org.fabianm.brainfuck.BrainfuckEngine;
 
 import java.awt.*;
-import java.io.UnsupportedEncodingException;
+import java.io.*;
 import java.lang.reflect.Field;
 import java.text.SimpleDateFormat;
 import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
 
 import static java.util.concurrent.TimeUnit.SECONDS;
 
@@ -82,11 +86,7 @@ public class MessageListener extends ListenerAdapter {
             mes = time(event);
         }
         if (raw.matches("(?is)^::google\\s.*")) {
-            try {
-                mes = google(event);
-            } catch (UnsupportedEncodingException e) {
-                e.printStackTrace();
-            }
+            mes = google(event);
         }
         if (raw.matches("(?is)^::spam\\s.*")) {
             mes = spam(event);
@@ -100,9 +100,119 @@ public class MessageListener extends ListenerAdapter {
         if (raw.equals("+")) {
             message.editMessage(PLUS_SIGN).queue();
         }
+        if (raw.matches("(?is)^::copy")) {
+            mes = copy(event);
+        }
+        if (raw.matches("(?is)^::purge\\s.*")) {
+            purge(event);
+        }
+        if (raw.matches("(?is)^::eval\\s.*")) {
+            Thread t = new Thread(() -> eval(event));
+            t.start();
+            mes = null;
+        }
         if (deleteAfter && mes != null) {
             mes.delete().queueAfter(5, SECONDS);
         }
+
+    }
+
+    private void eval(MessageReceivedEvent event) {
+        String[] parts = event.getMessage().getRawContent().split("\\s+", 3);
+        if (parts.length != 3) {
+            event.getMessage().editMessage("Error: Use `::event <java|python|bf> <code>");
+            return;
+        }
+        Object out = "";
+        int x = 8;
+        if (parts[1].matches(".*\\d$")) {
+            x = Integer.parseInt(parts[1].replaceFirst("b(rain)?f(uck)?", ""));
+            parts[1] = "bf";
+        }
+        switch (parts[1].toLowerCase()) {
+            case "bf":
+            case "brainfuck":
+                out = evalBf(x, parts[2]);
+                break;
+            case "java":
+                Map<String, Object> map = new HashMap<>();
+                map.put("channel", event.getChannel());
+                map.put("message", event.getMessage());
+                map.put("guild", event.getGuild());
+                out = Main.eval(parts[2], map);
+                break;
+            case "python":
+                out = evalPy(parts[2]);
+                break;
+            default:
+                out = new Exception("Unknown Language");
+        }
+        EmbedBuilder eB = new EmbedBuilder();
+        eB.addField(":inbox_tray:Input", "```" + parts[1] + "\n" + parts[2] + "```", false);
+        if (out instanceof Throwable) {
+            eB.addField(":x:Exception", "```" + parts[1] + "\n" + out + "```", false);
+        } else {
+            eB.addField(":outbox_tray:Output", "```" + parts[1] + "\n" + out + "```", false);
+        }
+        event.getMessage().editMessage(eB.build()).queue();
+    }
+
+    private Object evalBf(int cells, String part) {
+        StringWriter writer = new StringWriter();
+        BrainfuckEngine engine = new BrainfuckEngine(cells, new BufferedOutputStream(new OutputStream() {
+            @Override
+            public void write(int b) throws IOException {
+                writer.write(b);
+            }
+        }));
+        try {
+            engine.interpret(part);
+        } catch (Exception e) {
+            return e;
+        }
+        return writer.getBuffer();
+    }
+
+    private Object evalPy(String part) {
+        try {
+            Process p = Runtime.getRuntime().exec(new String[]{"python"});
+            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(p.getOutputStream()));
+            writer.write(part);
+            writer.flush();
+            p.waitFor();
+            Scanner s = new Scanner(p.getInputStream());
+            s.useDelimiter("\\A");
+            return s.next();
+        } catch (Exception e) {
+            return e;
+        }
+
+    }
+
+    private void purge(MessageReceivedEvent event) {
+        String[] tmp = event.getMessage().getRawContent().split("\\s+");
+        event.getMessage().delete().complete();
+        int amount;
+        if (tmp.length < 2) {
+            amount = 100;
+        } else {
+            amount = clamp(Integer.parseInt(tmp[1]), 2, 100);
+        }
+        event.getChannel().getHistory().retrievePast(amount).complete().stream().filter(m -> m.getAuthor().equals(event.getJDA().getSelfUser())).forEach(m -> m.delete().queue());
+    }
+
+    private int clamp(int i, int min, int max) {
+        if (min > max) throw new IllegalArgumentException("min > max");
+        if (i < min) return min;
+        if (i > max) return max;
+        return i;
+    }
+
+    private Message copy(MessageReceivedEvent event) {
+        Message m = event.getMessage();
+        long id = Long.valueOf(m.getRawContent().split("\\s+")[1]);
+        m.editMessage("```\n" + event.getChannel().getMessageById(id).complete().getRawContent() + "\n```").queue();
+        return m;
     }
 
     private Message sanduhrdings(MessageReceivedEvent event) {
@@ -160,7 +270,7 @@ public class MessageListener extends ListenerAdapter {
         return null;
     }
 
-    private Message google(MessageReceivedEvent event) throws UnsupportedEncodingException {
+    private Message google(MessageReceivedEvent event) {
         String text = event.getMessage().getRawContent().replaceFirst("(?i)^:[:>]google\\s+", "");
         String raw = text.replace(' ', '+');
         EmbedBuilder embed = new EmbedBuilder();