From f255626098544492e7ffa11461555005f63c0bd2 Mon Sep 17 00:00:00 2001 From: terribleplan Date: Tue, 25 Jun 2013 10:15:25 -0500 Subject: [PATCH] Initial commit --- build/EvilBotX-0.1.0-final.jar | Bin 0 -> 30435 bytes src/be/xrg/evilbotx/BotPair.java | 13 ++ src/be/xrg/evilbotx/EvilBotX.java | 49 ++++ src/be/xrg/evilbotx/Network.java | 86 +++++++ src/be/xrg/evilbotx/Storage.java | 133 +++++++++++ src/be/xrg/evilbotx/Utilities.java | 182 +++++++++++++++ src/be/xrg/evilbotx/XListener.java | 52 +++++ .../components/ChannelStatsWatcher.java | 84 +++++++ .../evilbotx/components/CountdownCommand.java | 32 +++ .../xrg/evilbotx/components/HackCommand.java | 220 ++++++++++++++++++ .../components/HelloWorldCommand.java | 35 +++ .../evilbotx/components/InsultCommand.java | 68 ++++++ .../xrg/evilbotx/components/SeenCommand.java | 195 ++++++++++++++++ .../xrg/evilbotx/components/SlapCommand.java | 50 ++++ .../evilbotx/components/YoutubeParser.java | 60 +++++ src/be/xrg/evilbotx/parents/EBXComponent.java | 48 ++++ .../xrg/evilbotx/special/CountdownThread.java | 30 +++ 17 files changed, 1337 insertions(+) create mode 100644 build/EvilBotX-0.1.0-final.jar create mode 100644 src/be/xrg/evilbotx/BotPair.java create mode 100644 src/be/xrg/evilbotx/EvilBotX.java create mode 100644 src/be/xrg/evilbotx/Network.java create mode 100644 src/be/xrg/evilbotx/Storage.java create mode 100644 src/be/xrg/evilbotx/Utilities.java create mode 100644 src/be/xrg/evilbotx/XListener.java create mode 100644 src/be/xrg/evilbotx/components/ChannelStatsWatcher.java create mode 100644 src/be/xrg/evilbotx/components/CountdownCommand.java create mode 100644 src/be/xrg/evilbotx/components/HackCommand.java create mode 100644 src/be/xrg/evilbotx/components/HelloWorldCommand.java create mode 100644 src/be/xrg/evilbotx/components/InsultCommand.java create mode 100644 src/be/xrg/evilbotx/components/SeenCommand.java create mode 100644 src/be/xrg/evilbotx/components/SlapCommand.java create mode 100644 src/be/xrg/evilbotx/components/YoutubeParser.java create mode 100644 src/be/xrg/evilbotx/parents/EBXComponent.java create mode 100644 src/be/xrg/evilbotx/special/CountdownThread.java diff --git a/build/EvilBotX-0.1.0-final.jar b/build/EvilBotX-0.1.0-final.jar new file mode 100644 index 0000000000000000000000000000000000000000..a9bb10952ff93a3df1bd60edc97b1e06df1f5ece GIT binary patch literal 30435 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 NLV11HVEgvz{{cFTYOnwR literal 0 HcmV?d00001 diff --git a/src/be/xrg/evilbotx/BotPair.java b/src/be/xrg/evilbotx/BotPair.java new file mode 100644 index 0000000..0cdb016 --- /dev/null +++ b/src/be/xrg/evilbotx/BotPair.java @@ -0,0 +1,13 @@ +package be.xrg.evilbotx; + +import org.pircbotx.PircBotX; + +public class BotPair { + public Network a; + public PircBotX b; + + public BotPair(Network a, PircBotX b) { + this.a = a; + this.b = b; + } +} diff --git a/src/be/xrg/evilbotx/EvilBotX.java b/src/be/xrg/evilbotx/EvilBotX.java new file mode 100644 index 0000000..db2f945 --- /dev/null +++ b/src/be/xrg/evilbotx/EvilBotX.java @@ -0,0 +1,49 @@ +package be.xrg.evilbotx; + +import java.util.ArrayList; + +import org.pircbotx.PircBotX; + +public class EvilBotX { + public static String VERSION = "EvilBotX v0.1.0"; + + private ArrayList b = new ArrayList(); + + public EvilBotX(ArrayList nets, XListener shared) { + for (Network a : nets) { + PircBotX bot = new PircBotX(); + bot.setLogin(a.getLogin()); + bot.setName(a.getNick()); + bot.setVerbose(a.useVerbose()); + bot.setAutoNickChange(a.useAutoNick()); + bot.getListenerManager().addListener(shared); + if (a.useCustomListener()) { + bot.getListenerManager().addListener(a.getListener()); + } + this.b.add(new BotPair(a, bot)); + } + } + + public void go() { + for (BotPair c : this.b) { + try { + if (c.a.useSSL()) { + c.b.connect(c.a.getAddress(), c.a.getPort(), c.a.getPass(), + new org.pircbotx.UtilSSLSocketFactory() + .trustAllCertificates()); + } else { + c.b.connect(c.a.getAddress(), c.a.getPort(), c.a.getPass()); + } + for (String a : c.a.getChannels()) { + c.b.joinChannel(a); + } + } catch (Exception e) { + e.printStackTrace(); + } + } + } + + public static void main(String[] args) { + System.out.println("You need to create your own runner class to use EvilBotX. Please check the documentation for details."); + } +} diff --git a/src/be/xrg/evilbotx/Network.java b/src/be/xrg/evilbotx/Network.java new file mode 100644 index 0000000..44fc944 --- /dev/null +++ b/src/be/xrg/evilbotx/Network.java @@ -0,0 +1,86 @@ +package be.xrg.evilbotx; + +import java.util.ArrayList; + +public class Network { + private XListener privateListener; + + private String name; + private String nick; + private String address; + private String pass; + + private ArrayList channels; + + private int port; + + private boolean autoNickChange = true; + private boolean customListener = false; + private boolean verbose = false; + private boolean ssl = true; + + public Network(String login, String nick, String address, String pass, int port) { + this.address = address; + this.channels = new ArrayList(); + this.name = login; + this.nick = nick; + this.pass = pass; + this.port = port; + } + + public void addChannel(String channel) { + this.channels.add(channel); + } + + public void setSSL(boolean ssl) { + this.ssl = ssl; + } + + public void setCustomListener(XListener listen) { + this.privateListener = listen; + this.customListener = true; + } + + public String getAddress() { + return this.address; + } + + public XListener getListener() { + return this.privateListener; + } + + public String getLogin() { + return this.name; + } + + public String getNick() { + return this.nick; + } + public String getPass() { + return this.pass; + } + public int getPort() { + return this.port; + } + + public boolean useAutoNick() { + return this.autoNickChange; + } + + public boolean useCustomListener() { + return this.customListener; + } + + public boolean useSSL() { + return this.ssl; + } + + public boolean useVerbose() { + return this.verbose; + } + + public ArrayList getChannels() { + return this.channels; + } + +} diff --git a/src/be/xrg/evilbotx/Storage.java b/src/be/xrg/evilbotx/Storage.java new file mode 100644 index 0000000..5daf078 --- /dev/null +++ b/src/be/xrg/evilbotx/Storage.java @@ -0,0 +1,133 @@ +package be.xrg.evilbotx; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.io.Serializable; +import java.util.HashMap; +import java.util.Map; + +public class Storage { + static String fileName = "data.ebx"; + static String dfName = "dsssseRs"; + private Map data; + private boolean loaded = false; + private final String location; + + public Storage() { + this(System.getProperty("user.dir") + "/"); + } + + public Storage(String location) { + this.location = location; + this.read(); + if (!this.loaded) { + this.init(); + } + } + + @SuppressWarnings("unchecked") + private void read() { + File f = new File(this.location); + File ff = new File(f, Storage.fileName); + if (ff.exists()) { + try { + FileInputStream fi = new FileInputStream(ff); + byte[] b = new byte[(int) f.length()]; + fi.read(b); + fi.close(); + ObjectInputStream is = new ObjectInputStream( + new ByteArrayInputStream(b)); + this.data = (HashMap) is.readObject(); + this.loaded = true; + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } + } + } + + private void write() { + try { + FileOutputStream f = new FileOutputStream(this.location + + Storage.fileName); + f.write(Storage.toByteArr((Serializable) this.data)); + f.close(); + } catch (IOException e) { + e.printStackTrace(); + } + } + + private void init() { + boolean fail = false; + File f = new File(this.location); + File ff = new File(f, Storage.fileName); + if (!f.exists()) { + if (!f.mkdirs()) { + fail = true; + } + } + if (ff.exists()) { + try { + if (!(ff.delete() && ff.createNewFile())) { + fail = true; + } + } catch (IOException e) { + e.printStackTrace(); + fail = true; + } + } else { + try { + if (!ff.createNewFile()) { + fail = true; + } + } catch (IOException e) { + e.printStackTrace(); + fail = true; + } + } + this.data = new HashMap(); + if (!fail) { + loaded = true; + } else { + System.exit(-2); + } + this.putData(385639, "FakeDataToPopulate", Storage.toByteArr("lolol")); + } + + public boolean hasData(int ID, String appName) { + return this.data.containsKey(this.getUID(ID, appName)); + } + + public void putData(int ID, String appName, byte[] data) { + String uid = this.getUID(ID, appName); + this.data.put(uid, data); + this.write(); + } + + public byte[] getData(int ID, String appName) { + return this.data.get(this.getUID(ID, appName)); + } + + private String getUID(int ID, String appName) { + return Utilities.crc32(appName + ID); + } + + public static byte[] toByteArr(Serializable o) { + byte[] b = null; + try { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ObjectOutputStream objOut = new ObjectOutputStream(out); + objOut.writeObject(o); + b = out.toByteArray(); + objOut.close(); + } catch (IOException e) { + e.printStackTrace(); + } + return b; + } +} diff --git a/src/be/xrg/evilbotx/Utilities.java b/src/be/xrg/evilbotx/Utilities.java new file mode 100644 index 0000000..27c0e2a --- /dev/null +++ b/src/be/xrg/evilbotx/Utilities.java @@ -0,0 +1,182 @@ +package be.xrg.evilbotx; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.io.UnsupportedEncodingException; +import java.net.HttpURLConnection; +import java.net.URL; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.ArrayList; +import java.util.zip.CRC32; + +import org.apache.commons.lang3.StringEscapeUtils; + +public class Utilities { + public static final String strEnc = "UTF-8"; + public static boolean compat = false; + + public static String[] getHTMLPage(String url) { + URL loc; + HttpURLConnection conn; + BufferedReader rd; + String line; + String[] ret = { "", "" }; + try { + loc = new URL(url); + conn = (HttpURLConnection) loc.openConnection(); + conn.setRequestMethod("GET"); + rd = new BufferedReader( + new InputStreamReader(conn.getInputStream())); + ret[0] += conn.getResponseCode(); + while ((line = rd.readLine()) != null) { + ret[1] += line; + } + rd.close(); + } catch (Exception e) { + e.printStackTrace(); + ret[0] += "-1"; + } + return ret; + } + public static String decodeHTMLEntities(String encoded) { + return StringEscapeUtils.unescapeHtml4(encoded); + } + public static String getPageTitle(String html) { + int[] f = new int[2]; + f[0] = html.indexOf("") + 7; + f[1] = html.indexOf(""); + return "" + html.substring(f[0], f[1]); + } + + public static String intToTimeString(int seconds) { + boolean started = false; + String ret = ""; + int amount = 86400; + if (seconds > amount) { + ret += (seconds / amount) + " day"; + if (seconds/amount > 1) { + ret += "s"; + } + ret += ", "; + seconds -= (seconds / amount) * amount; + started = true; + } + amount = 3600; + if (seconds > amount || started) { + ret += (seconds / amount) + " hour"; + if (seconds/amount > 1) { + ret += "s"; + } + ret += ", "; + seconds -= (seconds / amount) * amount; + started = true; + } + amount = 60; + if (seconds > amount || started) { + ret += (seconds / amount) + " minute"; + if (seconds/amount > 1) { + ret += "s"; + } + ret += ", "; + seconds -= (seconds / amount) * amount; + started = true; + } + ret += seconds + " second"; + if (seconds > 1) { + ret += "s"; + } + return ret; + } + + public static void saveData(byte[] data, String modName, int modID) { + + } + + public static boolean hasData(String modName, int modID) { + return false; + } + + public static byte[] loadData(String modName, int modID) { + return null; + } + + public static String[] formatString(String[] a, int lineLength) { + String nextln = null; + boolean done = false; + ArrayList r = new ArrayList(); + nextln = "╔"; + for (int i = 0; i < lineLength; i++) { + nextln += "═"; + } + nextln += "╗"; + r.add(nextln); + while (!done) { + for (String s : a) { + nextln = "║"; + int curl = 0; + String[] words = s.split(" "); + for (String w : words) { + if (curl + w.length() > lineLength) { + nextln += w; + } else { + nextln = Utilities.padString(nextln, lineLength + 1); + nextln += "║"; + r.add(nextln); + nextln = "║"; + } + } + nextln = Utilities.padString(nextln, lineLength + 1); + nextln += "║"; + r.add(nextln); + } + } + nextln = "╚"; + for (int i = 0; i < lineLength; i++) { + nextln += "═"; + } + nextln += "╝"; + r.add(nextln); + return (String[]) r.toArray(); + } + + public static String md5(String input) throws NoSuchAlgorithmException, + UnsupportedEncodingException { + MessageDigest md5 = MessageDigest.getInstance("MD5"); + if (input != null) + input = bToStr(md5.digest(input.getBytes(Utilities.strEnc))); + return input; + } + + public static String crc32(String input) { + CRC32 crc32 = new CRC32(); + if (input != null) { + crc32.update(input.getBytes()); + input = Utilities.padOut(Long.toHexString(crc32.getValue()), 8); + } + return input; + } + + public static String bToStr(byte[] in) { + char[] hexArray = "0123456789abcdef".toCharArray(); + char[] hexChars = new char[in.length * 2]; + int v; + for (int j = 0; j < in.length; j++) { + v = in[j] & 0xFF; + hexChars[j * 2] = hexArray[v / 16]; + hexChars[j * 2 + 1] = hexArray[v % 16]; + } + return new String(hexChars); + } + + private static String padString(String ln, int lineLength) { + for (int i = ln.length(); i < lineLength; i++) { + ln += " "; + } + return ln; + } + + private static String padOut(String input, int nChar) { + return String.format("%" + nChar + "s", input).replace(' ', '0'); + } +} diff --git a/src/be/xrg/evilbotx/XListener.java b/src/be/xrg/evilbotx/XListener.java new file mode 100644 index 0000000..ad03e2d --- /dev/null +++ b/src/be/xrg/evilbotx/XListener.java @@ -0,0 +1,52 @@ +package be.xrg.evilbotx; + +import java.util.Iterator; +import java.util.Map.Entry; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.Listener; +import org.pircbotx.hooks.ListenerAdapter; + +import be.xrg.evilbotx.parents.EBXComponent; + +//This is meant to deal with raw types +@SuppressWarnings({ "unchecked", "rawtypes" }) +public class XListener extends ListenerAdapter implements Listener { + private java.util.Map com = new java.util.HashMap(); + + public void onEvent(Event e) throws Exception { + super.onEvent(e); + Iterator> i = this.com.entrySet() + .iterator(); + while (i.hasNext()) { + Entry z = i.next(); + EBXComponent t = z.getValue(); + String k = z.getKey(); + if (t.wantEvent(e)) { + System.out.println(k); + t.handleEvent(e); + } + } + + } + + public void addComponent(EBXComponent c) { + String u = this.makeUniqueName(c); + System.out.println("AddComponent-" + u + " " + c.getComponentName()); + if (!this.com.containsKey(u)) { + this.com.put(u, c); + } + } + + public void removeComponent(EBXComponent c) { + String u = this.makeUniqueName(c); + if (!this.com.containsKey(u)) { + this.com.remove(u); + } + } + + private String makeUniqueName(EBXComponent c) { + return Utilities.crc32(c.getClass().getName() + c.getComponentName() + + c.getComponentID() + "some needless salt"); + } +} diff --git a/src/be/xrg/evilbotx/components/ChannelStatsWatcher.java b/src/be/xrg/evilbotx/components/ChannelStatsWatcher.java new file mode 100644 index 0000000..26214dd --- /dev/null +++ b/src/be/xrg/evilbotx/components/ChannelStatsWatcher.java @@ -0,0 +1,84 @@ +package be.xrg.evilbotx.components; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.ActionEvent; +import org.pircbotx.hooks.events.HalfOpEvent; +import org.pircbotx.hooks.events.JoinEvent; +import org.pircbotx.hooks.events.KickEvent; +import org.pircbotx.hooks.events.MessageEvent; +import org.pircbotx.hooks.events.OpEvent; +import org.pircbotx.hooks.events.PartEvent; +import org.pircbotx.hooks.events.RemoveChannelBanEvent; +import org.pircbotx.hooks.events.SetChannelBanEvent; +import org.pircbotx.hooks.events.SuperOpEvent; +import org.pircbotx.hooks.events.TopicEvent; +import org.pircbotx.hooks.events.VoiceEvent; + +import be.xrg.evilbotx.Storage; +import be.xrg.evilbotx.Utilities; +import be.xrg.evilbotx.parents.EBXComponent; + +@SuppressWarnings("rawtypes") +public class ChannelStatsWatcher extends EBXComponent { + static Class[] q = { ActionEvent.class, HalfOpEvent.class, JoinEvent.class, + KickEvent.class, MessageEvent.class, OpEvent.class, + PartEvent.class, RemoveChannelBanEvent.class, + SetChannelBanEvent.class, SuperOpEvent.class, TopicEvent.class, + VoiceEvent.class }; + + public ChannelStatsWatcher(Storage s) { + super(s, q); + + // TODO Auto-generated constructor stub + } + + @Override + public void handleEvent(Event e) { + String j = Utilities.crc32(e.getBot().getLogin()); + if (e instanceof MessageEvent) { + MessageEvent t = (MessageEvent) e; + this.inc(j, 0); + String b = t.getMessage(); + if (b.equals("!stats")) { + + } + } else if (e instanceof ActionEvent) { + // ActionEvent + } else if (e instanceof HalfOpEvent) { + // HalfOpEvent + } else if (e instanceof JoinEvent) { + // JoinEvent + } else if (e instanceof KickEvent) { + // KickEvent + } else if (e instanceof OpEvent) { + // OpEvent + } else if (e instanceof PartEvent) { + // PartEvent + } else if (e instanceof RemoveChannelBanEvent) { + // RemoveChannelBanEvent + } else if (e instanceof SetChannelBanEvent) { + // SetChannelBanEvent + } else if (e instanceof SuperOpEvent) { + // SuperOpEvent + } else if (e instanceof TopicEvent) { + // TopicEvent + } else if (e instanceof VoiceEvent) { + // VoiceEvent + } + } + + private void inc(String p, int place) { + + } + + @Override + public String getComponentName() { + return "ChannelStats"; + } + + @Override + public int getComponentID() { + return 9001938; + } + +} diff --git a/src/be/xrg/evilbotx/components/CountdownCommand.java b/src/be/xrg/evilbotx/components/CountdownCommand.java new file mode 100644 index 0000000..0835595 --- /dev/null +++ b/src/be/xrg/evilbotx/components/CountdownCommand.java @@ -0,0 +1,32 @@ +package be.xrg.evilbotx.components; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.MessageEvent; + +@SuppressWarnings("rawtypes") +public class CountdownCommand extends be.xrg.evilbotx.parents.EBXComponent { + + public CountdownCommand(be.xrg.evilbotx.Storage s) { + super(s, MessageEvent.class); + } + + public void handleEvent(Event e) { + new be.xrg.evilbotx.special.CountdownThread((MessageEvent) e).run(); + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent) { + MessageEvent a = (MessageEvent) e; + return a.getMessage().equals("!countdown"); + } + return false; + } + + public String getComponentName() { + return "CountdownCommand"; + } + + public int getComponentID() { + return 98763235; + } +} diff --git a/src/be/xrg/evilbotx/components/HackCommand.java b/src/be/xrg/evilbotx/components/HackCommand.java new file mode 100644 index 0000000..6778e68 --- /dev/null +++ b/src/be/xrg/evilbotx/components/HackCommand.java @@ -0,0 +1,220 @@ +package be.xrg.evilbotx.components; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.text.DateFormat; +import java.text.SimpleDateFormat; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.MessageEvent; + +import be.xrg.evilbotx.EvilBotX; +import be.xrg.evilbotx.Utilities; + +@SuppressWarnings("rawtypes") +public class HackCommand extends be.xrg.evilbotx.parents.EBXComponent { + private Map d; + private boolean l = false; + + private String q; + private boolean r = false; + + public HackCommand(be.xrg.evilbotx.Storage s) { + super(s, MessageEvent.class); + } + + @Override + public void handleEvent(Event e) { + MessageEvent a = (MessageEvent) e; + String b = a.getMessage(); + if (b.equals("!hack")) { + hack(a); + } else if (b.equals("!hackstats")) { + hackStats(a); + } else if (b.equals("!hackcount")) { + hackCount(a); + } + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent) { + return ((MessageEvent) e).getMessage().startsWith("!hack"); + } + return false; + } + + private void hack(MessageEvent e) { + this.ensureLoad(); + int INTERVAL = 3600; + int ct = (int) (System.currentTimeMillis() / 1000); + String who = e.getUser().getNick().toLowerCase(); + int i = (int) (Math.random() * 50 - 10); + if (!this.d.containsKey(who)) { + int[] t = new int[2]; + t[0] = 0; + t[1] = ct - INTERVAL; + this.d.put(who, t); + } + int[] ud = this.d.get(who); + int tt = ud[0] + i; + String ms; + if (ud[1] + INTERVAL <= ct) { + if (tt < 0) { + tt = 0; + } + if (i <= 0 && ud[0] == 0) { + ms = "You were unable to hack anything. You still have 0 computers in your botnet."; + return; + } else if (i < -50) { + ms = "Looks like the IT department woke up. " + (i * -1) + + " hosts lost. You now have " + tt + + " computers in your botnet."; + } else if (i < -8) { + ms = "" + (-1 * i) + + " of your compromised hosts were lost. You now have " + + tt + " computers in your botnet."; + } else if (i < 0) { + ms = "" + (-1 * i) + + " of your bots were cleaned. You now have " + tt + + " computers in your botnet."; + } else if (i == 0) { + ms = who + + ": You weren't able to hack any machines. You still have " + + tt + " computers in your botnet."; + } else if (i > 30) { + ms = "You are a hacking god and owned " + i + + " boxes. You now have " + tt + + " computers in your botnet."; + } else if (i > 1) { + ms = "You hacked " + i + " d00dz. You now have " + tt + + " computers in your botnet."; + } else { + ms = "You hacked " + i + " box. MUST HACK MORE."; + } + ud[0] = tt; + ud[1] = ct; + this.d.put(who, ud); + e.respond(ms); + this.r = false; + this.save(); + } else { + int t = (ud[1] + INTERVAL) - ct; + e.respond("You're too tired to hack anything. Chill for " + + Utilities.intToTimeString(t) + "."); + } + } + + private void hackCount(MessageEvent e) { + this.ensureLoad(); + String who = e.getUser().getNick(); + String sta = "You have "; + if (this.d.containsKey(who)) { + int[] ud = this.d.get(who); + DateFormat df = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); + sta += ud[0] + + " computers in your botnet, and your last hack occured at " + + df.format(ud[1] * (long) 1000) + "."; + } else { + sta += "not done any hacking."; + } + e.respond(sta); + } + + private void hackStats(MessageEvent e) { + this.ensureLoad(); + if (!this.r) { + int users = 0, boxes = 0, latest = 0, time = (int) (System + .currentTimeMillis() / 1000), leader = 0; + String recentName = "", leaderName = ""; + Date dtime = new Date(System.currentTimeMillis()); + DateFormat df = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); + for (Entry entry : d.entrySet()) { + int[] ud = entry.getValue(); + String key = entry.getKey(); + users++; + boxes += ud[0]; + if (leader < ud[0]) { + leader = ud[0]; + leaderName = key; + } + if (latest < ud[1]) { + latest = ud[1]; + recentName = key; + } + } + dtime = new Date(latest * (long) 1000); + this.q = "Currently tracking " + users + " users with " + boxes + + " zombie PCs. Current leader is " + leaderName + " with " + + leader + " machines. The most recent hack happened on " + + df.format(dtime) + " and was done by " + recentName + + ". (" + EvilBotX.VERSION + ", " + time + ")"; + this.r = true; + } + e.respond(this.q); + } + + private void ensureLoad() { + if (!this.l) { + this.load(); + } + } + + @Override + public String getComponentName() { + return "HackCommand"; + } + + @Override + public int getComponentID() { + return 2400062; + } + + @SuppressWarnings("unchecked") + private void load() { + byte[] a = null; + try { + if (this.s.hasData(this.getComponentID(), this.getComponentName())) { + a = this.s.getData(this.getComponentID(), + this.getComponentName()); + if (a != null) { + ObjectInputStream is = new ObjectInputStream( + new ByteArrayInputStream(a)); + this.d = (HashMap) is.readObject(); + this.l = true; + } + } + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } + if (!this.l) { + this.init(); + } + } + + private void init() { + this.d = new HashMap(); + this.l = true; + } + + private void save() { + byte[] a = null; + try { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ObjectOutputStream objOut = new ObjectOutputStream(out); + objOut.writeObject(this.d); + a = out.toByteArray(); + objOut.close(); + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + this.s.putData(this.getComponentID(), this.getComponentName(), a); + } +} diff --git a/src/be/xrg/evilbotx/components/HelloWorldCommand.java b/src/be/xrg/evilbotx/components/HelloWorldCommand.java new file mode 100644 index 0000000..620cbda --- /dev/null +++ b/src/be/xrg/evilbotx/components/HelloWorldCommand.java @@ -0,0 +1,35 @@ +package be.xrg.evilbotx.components; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.MessageEvent; + +@SuppressWarnings("rawtypes") +public class HelloWorldCommand extends be.xrg.evilbotx.parents.EBXComponent { + + public HelloWorldCommand(be.xrg.evilbotx.Storage s) { + super(s, MessageEvent.class); + } + + public void handleEvent(Event e) { + MessageEvent t = (MessageEvent) e; + if (t.getMessage().startsWith("!hello")) { + t.getBot().sendMessage(t.getChannel(), "Hello world"); + } + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent) { + return ((MessageEvent) e).getMessage().equals("!hello"); + } + return false; + } + + public String getComponentName() { + return "HelloWorldCommand"; + } + + public int getComponentID() { + return 68752; + } + +} diff --git a/src/be/xrg/evilbotx/components/InsultCommand.java b/src/be/xrg/evilbotx/components/InsultCommand.java new file mode 100644 index 0000000..d0782bd --- /dev/null +++ b/src/be/xrg/evilbotx/components/InsultCommand.java @@ -0,0 +1,68 @@ +package be.xrg.evilbotx.components; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.MessageEvent; + +@SuppressWarnings("rawtypes") +public class InsultCommand extends be.xrg.evilbotx.parents.EBXComponent { + public static String[] i = { "Nobody likes you.", "Poq Gai", + "I do not like your look, I promise thee", "Die in a fire", + "I desire that we be better strangers", + "If ignorance is bliss, you must be overjoyed", "GTFO", + "Besame el culo", "La reputisima madre que te remil pario", + "Jy pis my af", "Lay da yuen fay gay mm sai sou", + "Degenerate and base art thou", "Blde fotze", + "You will live a long pathetic life", "Kusu o taberu na", + "You will get hit by a car later on", + "You are not worth another word, else I'd call you knave", + "Your face is as a book, where men may read strange matters", + "Everything you believe in is an illusion" }; + + public InsultCommand(be.xrg.evilbotx.Storage s) { + super(s, MessageEvent.class); + } + + @Override + public void handleEvent(Event e) { + MessageEvent t = (MessageEvent) e; + String b = t.getMessage(); + if (b.startsWith("!insult")) { + String a = ""; + if (b.contains(" ")) { + String[] c = b.split(" "); + if (c.length >= 1) { + a += c[1]; + } else { + a += t.getUser().getNick(); + } + } else { + a += t.getUser().getNick(); + } + t.getBot().sendMessage(t.getChannel(), + a + ": " + InsultCommand.randInsult()); + } + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent) { + return ((MessageEvent) e).getMessage().startsWith("!insult"); + } + return false; + } + + @Override + public String getComponentName() { + // TODO Auto-generated method stub + return "InsultCommand"; + } + + @Override + public int getComponentID() { + // TODO Auto-generated method stub + return 0; + } + + static String randInsult() { + return InsultCommand.i[(int) (Math.random() * InsultCommand.i.length)]; + } +} diff --git a/src/be/xrg/evilbotx/components/SeenCommand.java b/src/be/xrg/evilbotx/components/SeenCommand.java new file mode 100644 index 0000000..599f5b0 --- /dev/null +++ b/src/be/xrg/evilbotx/components/SeenCommand.java @@ -0,0 +1,195 @@ +package be.xrg.evilbotx.components; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.JoinEvent; +import org.pircbotx.hooks.events.KickEvent; +import org.pircbotx.hooks.events.MessageEvent; +import org.pircbotx.hooks.events.NickChangeEvent; +import org.pircbotx.hooks.events.PartEvent; +import org.pircbotx.hooks.events.QuitEvent; + +import be.xrg.evilbotx.Storage; +import be.xrg.evilbotx.Utilities; + +/* + * 0 = first seen + * 1 = recently seen + */ +@SuppressWarnings("rawtypes") +public class SeenCommand extends be.xrg.evilbotx.parents.EBXComponent { + static Class[] q = { JoinEvent.class, KickEvent.class, MessageEvent.class, + NickChangeEvent.class, PartEvent.class, QuitEvent.class }; + private Map d; + private boolean l = false; + + public SeenCommand(Storage s) { + super(s, SeenCommand.q); + } + + public String getComponentName() { + return "SeenCommand"; + } + + public int getComponentID() { + return 83463; + } + + public void handleEvent(Event e) { + String j = Utilities.crc32(e.getBot().getLogin()); + if (e instanceof MessageEvent) { + MessageEvent t = (MessageEvent) e; + this.seen(j, t.getUser().getNick(), true); + String b = t.getMessage(); + if (b.startsWith("!seen")) { + if (b.equalsIgnoreCase("!seenstats")) { + t.respond(this.seenStats()); + } else if (b.length() > 6) { + String[] c = b.split(" "); + if (c.length >= 2) { + t.respond(this.checkSeen(j, c[1])); + } + } + } + } else if (e instanceof JoinEvent) { + this.seen(j, ((JoinEvent) e).getUser().getNick(), true); + } else if (e instanceof PartEvent) { + this.seenOff(j, ((PartEvent) e).getUser().getNick()); + } else if (e instanceof QuitEvent) { + this.seenOff(j, ((QuitEvent) e).getUser().getNick()); + } else if (e instanceof KickEvent) { + this.seenOff(j, ((KickEvent) e).getRecipient().getNick()); + } else if (e instanceof NickChangeEvent) { + this.seenOff(j, ((NickChangeEvent) e).getOldNick()); + this.seen(j, ((NickChangeEvent) e).getNewNick(), true); + } + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent || e instanceof JoinEvent + || e instanceof PartEvent || e instanceof QuitEvent + || e instanceof KickEvent || e instanceof NickChangeEvent) { + return true; + } + return false; + } + + private void seen(String prefix, String user, boolean s) { + user = prefix + user.toLowerCase(); + int a = (int) (System.currentTimeMillis() / 1000); + this.ensureLoad(); + int[] b; + if (this.d.containsKey(user)) { + b = this.d.get(user); + } else { + b = new int[3]; + b[0] = a; + } + b[1] = a; + b[2] = 1; + this.d.put(user, b); + if (s) { + this.save(); + } + } + + private void seenOff(String prefix, String user) { + user = user.toLowerCase(); + this.seen(prefix, user, false); + int[] b = this.d.get(user); + b[2] = 0; + this.d.put(prefix + user.toLowerCase(), b); + this.save(); + } + + private String checkSeen(String p, String w) { + String a = p+ w.toLowerCase(); + String seen = ""; + int h = (int) (System.currentTimeMillis() / 1000); + if (this.d.containsKey(a)) { + int[] b = this.d.get(a); + if (b[2] == 0) { + seen += "I last saw " + w + " " + + Utilities.intToTimeString(h - b[1]) + " ago."; + } else { + seen += w + " is currently online."; + } + seen += " I first saw " + w + " " + + Utilities.intToTimeString(h - b[0]) + " ago."; + } else { + seen += "I have not seen " + w + "."; + } + return seen; + } + + private String seenStats() { + int users = 0, online = 0, time = (int) (System.currentTimeMillis() / 1000); + for (Entry entry : d.entrySet()) { + users++; + int[] v = entry.getValue(); + if (v[2] != 0) { + online++; + } + } + return "I am currently tracking " + users + " nicks, " + online + + " of whom are currently online. (AwesomeBot " + + be.xrg.evilbotx.EvilBotX.VERSION + ", " + time + ")"; + // return null; + } + + private void ensureLoad() { + if (!l) { + this.load(); + } + } + + @SuppressWarnings("unchecked") + private void load() { + byte[] a = null; + try { + if (this.s.hasData(this.getComponentID(), this.getComponentName())) { + a = this.s.getData(this.getComponentID(), + this.getComponentName()); + if (a != null) { + ObjectInputStream is = new ObjectInputStream( + new ByteArrayInputStream(a)); + this.d = (HashMap) is.readObject(); + this.l = true; + } + } + } catch (IOException | ClassNotFoundException e) { + e.printStackTrace(); + } + if (!this.l) { + this.init(); + } + } + + private void init() { + this.d = new HashMap(); + this.l = true; + } + + private void save() { + byte[] a = null; + try { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + ObjectOutputStream objOut = new ObjectOutputStream(out); + objOut.writeObject(this.d); + a = out.toByteArray(); + objOut.close(); + out.close(); + } catch (IOException e) { + e.printStackTrace(); + } + this.s.putData(this.getComponentID(), this.getComponentName(), a); + } +} diff --git a/src/be/xrg/evilbotx/components/SlapCommand.java b/src/be/xrg/evilbotx/components/SlapCommand.java new file mode 100644 index 0000000..3f01cf5 --- /dev/null +++ b/src/be/xrg/evilbotx/components/SlapCommand.java @@ -0,0 +1,50 @@ +package be.xrg.evilbotx.components; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.MessageEvent; + +@SuppressWarnings("rawtypes") +public class SlapCommand extends be.xrg.evilbotx.parents.EBXComponent { + + public SlapCommand(be.xrg.evilbotx.Storage s) { + super(s, MessageEvent.class); + } + + public void handleEvent(Event e) { + if (e instanceof MessageEvent) { + MessageEvent t = (MessageEvent) e; + String b = t.getMessage(); + if (b.startsWith("!slap")) { + String a = "slaps "; + if (b.contains(" ")) { + String[] c = b.split(" "); + if (c.length >= 1) { + a += c[1]; + } else { + a += t.getUser().getNick(); + } + } else { + a += t.getUser().getNick(); + } + t.getBot().sendAction(t.getChannel(), a); + } + } + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent) { + return ((MessageEvent) e).getMessage().startsWith("!slap"); + } + return false; + } + + @Override + public String getComponentName() { + return "SlapCommand"; + } + + @Override + public int getComponentID() { + return 462963; + } +} diff --git a/src/be/xrg/evilbotx/components/YoutubeParser.java b/src/be/xrg/evilbotx/components/YoutubeParser.java new file mode 100644 index 0000000..fe3e317 --- /dev/null +++ b/src/be/xrg/evilbotx/components/YoutubeParser.java @@ -0,0 +1,60 @@ +package be.xrg.evilbotx.components; + +import org.pircbotx.hooks.Event; +import org.pircbotx.hooks.events.MessageEvent; + +import be.xrg.evilbotx.Utilities; + +@SuppressWarnings("rawtypes") +public class YoutubeParser extends be.xrg.evilbotx.parents.EBXComponent { + + public static String yt = "1,16[You4,16Tube1,16] "; + + public YoutubeParser(be.xrg.evilbotx.Storage s) { + super(s, MessageEvent.class); + } + + @Override + public void handleEvent(Event e) { + MessageEvent a = (MessageEvent) e; + String[] b = a.getMessage().split(" "); + for (String c : b) { + if (this.isYTLink(c)) { + String[] d = Utilities.getHTMLPage(c); + if (d[0].equals("200")) { + String f = Utilities.decodeHTMLEntities(Utilities + .getPageTitle(d[1])); + f = f.substring(0, f.length() - 10); + a.getBot() + .sendMessage(a.getChannel(), YoutubeParser.yt + f); + } + } + } + } + + @Override + public String getComponentName() { + // TODO Auto-generated method stub + return "YoutubeParser"; + } + + @Override + public int getComponentID() { + return 438329; + } + + protected boolean wantEventM(Event e) { + if (e instanceof MessageEvent) { + MessageEvent a = (MessageEvent) e; + return a.getMessage().contains("youtu"); + } + return false; + } + + private boolean isYTLink(String p) { + return ((p.startsWith("http://") || p.startsWith("https://")) && (p + .contains("://youtu.be/") || ((p + .contains("://youtube.com/watch?") || p + .contains("://www.youtube.com/watch?")) && p.contains("v=")))); + } +} diff --git a/src/be/xrg/evilbotx/parents/EBXComponent.java b/src/be/xrg/evilbotx/parents/EBXComponent.java new file mode 100644 index 0000000..e792ba1 --- /dev/null +++ b/src/be/xrg/evilbotx/parents/EBXComponent.java @@ -0,0 +1,48 @@ +package be.xrg.evilbotx.parents; + +import java.util.ArrayList; +import java.util.Arrays; + +import org.pircbotx.hooks.Event; + +import be.xrg.evilbotx.Storage; + +@SuppressWarnings("rawtypes") +public abstract class EBXComponent { + protected Storage s; + private ArrayList c; + + private EBXComponent(Storage s) { + this.c = new ArrayList(); + this.s = s; + } + + public EBXComponent(Storage s, Class a) { + this(s); + this.c.add(a); + } + + public EBXComponent(Storage s, Class[] a) { + this(s); + this.c.addAll(Arrays.asList(a)); + } + + public boolean wantEvent(Event e) { + for (Class a : this.c) { + if (a.isInstance(e)) { + return (true && this.wantEventM(e)); + } + } + return false; + } + + protected boolean wantEventM(Event e) { + return false; + } + + public abstract void handleEvent(Event e); + + public abstract String getComponentName(); + + public abstract int getComponentID(); +} diff --git a/src/be/xrg/evilbotx/special/CountdownThread.java b/src/be/xrg/evilbotx/special/CountdownThread.java new file mode 100644 index 0000000..69820de --- /dev/null +++ b/src/be/xrg/evilbotx/special/CountdownThread.java @@ -0,0 +1,30 @@ +package be.xrg.evilbotx.special; + +import org.pircbotx.hooks.events.MessageEvent; + +public class CountdownThread extends Thread { + public static final boolean load = true; + public static String[] countdown = { "5!", "4!", "3!", "2!", "1!", + "Smoke!!!!!! 8D--~~~~~~~~~~~~" }; + @SuppressWarnings("rawtypes") + private MessageEvent e; + + @SuppressWarnings("rawtypes") + public CountdownThread(MessageEvent e) { + System.out.println("Started new special.Countdown"); + this.e = e; + } + + public void run() { + System.out.println("Running special.Countdown"); + for (int i = 0; i < CountdownThread.countdown.length; i++) { + e.getBot().sendMessage(e.getChannel(), + "3,14" + CountdownThread.countdown[i]); + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + } + } +}