From 74a731d2e06846413b852f6f1320327e6ee64b8e Mon Sep 17 00:00:00 2001 From: matt123337 Date: Mon, 17 Feb 2014 19:26:58 -0500 Subject: [PATCH 1/5] Low level proxy support added, MAC address spoofing done, basic runtime interception done Signed-off-by: matt123337 --- .gitignore | 6 + .../org/matt123337/proxy/ClassRemapper.java | 24 ++ .../src/org/matt123337/proxy/ProxySocket.java | 276 +++++++++++++ .../src/org/matt123337/proxy/ProxyType.java | 5 + .../matt123337/spoofer/NetworkInterface.java | 51 +++ .../src/org/matt123337/spoofer/Runtime.java | 64 +++ .../asm/commons/LocalVariablesSorter.java | 376 ++++++++++++++++++ .../org/objectweb/asm/commons/Remapper.java | 223 +++++++++++ .../commons/RemappingAnnotationAdapter.java | 79 ++++ .../asm/commons/RemappingClassAdapter.java | 135 +++++++ .../asm/commons/RemappingFieldAdapter.java | 71 ++++ .../asm/commons/RemappingMethodAdapter.java | 195 +++++++++ .../commons/RemappingSignatureAdapter.java | 155 ++++++++ parabotv2/src/org/parabot/Landing.java | 43 +- .../org/parabot/core/classpath/ClassPath.java | 5 +- .../src/org/parabot/core/spoofing/Ip.java | 14 - parabotv2/src/org/parabot/core/ui/BotUI.java | 9 + .../src/org/parabot/core/ui/NetworkUI.java | 268 +++++++++++++ .../src/org/parabot/core/ui/utils/UILog.java | 4 +- 19 files changed, 1980 insertions(+), 23 deletions(-) create mode 100644 parabotv2/src/org/matt123337/proxy/ClassRemapper.java create mode 100644 parabotv2/src/org/matt123337/proxy/ProxySocket.java create mode 100644 parabotv2/src/org/matt123337/proxy/ProxyType.java create mode 100644 parabotv2/src/org/matt123337/spoofer/NetworkInterface.java create mode 100644 parabotv2/src/org/matt123337/spoofer/Runtime.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/LocalVariablesSorter.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/Remapper.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/RemappingAnnotationAdapter.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/RemappingClassAdapter.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/RemappingFieldAdapter.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/RemappingMethodAdapter.java create mode 100644 parabotv2/src/org/objectweb/asm/commons/RemappingSignatureAdapter.java delete mode 100644 parabotv2/src/org/parabot/core/spoofing/Ip.java create mode 100644 parabotv2/src/org/parabot/core/ui/NetworkUI.java diff --git a/.gitignore b/.gitignore index f621bb7..582982c 100644 --- a/.gitignore +++ b/.gitignore @@ -46,3 +46,9 @@ parabotv2/src/META-INF/MANIFEST.MF /bin .idea/uiDesigner.xml + +*.jar + +*.classpath + +*.project \ No newline at end of file diff --git a/parabotv2/src/org/matt123337/proxy/ClassRemapper.java b/parabotv2/src/org/matt123337/proxy/ClassRemapper.java new file mode 100644 index 0000000..61f3a9f --- /dev/null +++ b/parabotv2/src/org/matt123337/proxy/ClassRemapper.java @@ -0,0 +1,24 @@ +package org.matt123337.proxy; + +import java.util.HashMap; + +import org.objectweb.asm.commons.Remapper; + +public class ClassRemapper extends Remapper { + private static HashMap remapNames = new HashMap(); + static { + remapNames.put("java/net/Socket", "org/matt123337/proxy/ProxySocket"); + remapNames.put("java/net/NetworkInterface", "org/matt123337/spoofer/NetworkInterface"); + remapNames.put("java/lang/Runtime", "org/matt123337/spoofer/Runtime"); + } + + @Override + public String map(String str) { + String s = remapNames.get(str); + if (s != null) { + return s; + } else { + return str; + } + } +} \ No newline at end of file diff --git a/parabotv2/src/org/matt123337/proxy/ProxySocket.java b/parabotv2/src/org/matt123337/proxy/ProxySocket.java new file mode 100644 index 0000000..df6f531 --- /dev/null +++ b/parabotv2/src/org/matt123337/proxy/ProxySocket.java @@ -0,0 +1,276 @@ +package org.matt123337.proxy; + +import java.io.BufferedReader; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.net.SocketAddress; +import java.net.UnknownHostException; +import java.nio.channels.SocketChannel; +import java.util.ArrayList; +import java.util.List; + +import javax.swing.JOptionPane; + +import org.parabot.core.ui.components.LogArea; +import org.parabot.core.ui.utils.UILog; + +public class ProxySocket extends Socket { + + private static Listconnections = new ArrayList(); + + private static ProxyType proxyType = ProxyType.HTTP; + + private static int proxyPort = 0; + + private InetAddress addr; + private int port; + + private static InetAddress proxyInetAddress = null; + + private InetSocketAddress cachedAddr; + + public static int closeConnections(){ + int value = 0; + for(ProxySocket socket : connections) + try{ + connections.remove(socket); + if(socket.isClosed()) + continue; + socket.close(); + value++; + }catch(Exception e){ + + } + return value; + } + + public ProxySocket(InetAddress addr, int port) throws IOException { + super(addr, port); + } + + public ProxySocket() { + super(); + } + + public ProxySocket(String host, int port) throws IOException { + super(host, port); + } + + public static void setProxy(ProxyType type,String host, int port) { + try { + proxyInetAddress = InetAddress.getByName(host); + proxyPort = port; + proxyType = type; + } catch (UnknownHostException e) { + throw new RuntimeException(e); + } + } + + public static InetAddress getProxyAddress(){ + return proxyInetAddress; + } + + public static int getProxyPort(){ + return proxyPort; + } + + public static ProxyType getProxyType(){ + return proxyType; + } + + @Override + public void connect(SocketAddress addr) throws IOException { + connections.add(this); + if (addr instanceof InetSocketAddress) { + InetSocketAddress isa = (InetSocketAddress) addr; + this.addr = InetAddress.getByName(isa.getHostString()); + this.port = isa.getPort(); + } + if (proxyInetAddress != null && proxyPort > 0) { + try{ + super.connect(cachedAddr = new InetSocketAddress(proxyInetAddress, + proxyPort)); + initProxy(); + }catch(Exception e){ + UILog.log( + "Proxy Error", + e.getMessage(), + JOptionPane.ERROR_MESSAGE); + } + } else + super.connect(addr); + } + + private void initProxy() throws IOException { + LogArea.log("Proxying:" + addr + ":" + port + + " Over:" + proxyInetAddress + ":" + proxyPort + " Type:" + + proxyType); + switch (proxyType) { + case HTTP: + http_connect(); + break; + case SOCKS4: + socks4_connect(); + break; + case SOCKS5: + socks5_connect(); + break; + default: + throw new IOException("Unsupported proxy type:" + proxyType); + } + } + + private void http_connect() throws IOException { + InputStream in = getInputStream(); + BufferedReader br = new BufferedReader(new InputStreamReader(in)); + OutputStream out = getOutputStream(); + out.write(("CONNECT " + addr.getHostAddress() + ":" + port + "\r\n") + .getBytes()); + // out.write("Connection:keep-alive\r\n".getBytes()); + out.write("\r\n".getBytes()); + String str; + while ((str = br.readLine()) != null) { + if (str.length() == 0) + break; + if (!str.startsWith("HTTP")) + continue; + int code = Integer.parseInt(str.substring(9, 12)); + switch (code) { + case 404: + throw new IOException( + "Proxy seems to think we're connecting to a webpage..."); + case 403: + throw new IOException( + "Proxy doesn't support connecting to port: " + port + "! Try a different proxy."); + } + if (code / 100 != 2) + throw new IOException( + "Unable to connect to proxy server! HTTP Error code:" + code); + } + } + + private void socks4_connect() throws IOException { + DataOutputStream out = new DataOutputStream(getOutputStream()); + DataInputStream in = new DataInputStream(getInputStream()); + + out.write(0x04); + out.write(0x01); // connection type (TCP stream) + out.writeShort(port); + byte[] b = addr.getAddress(); + if (b.length != 4) + throw new IOException("Unsupported IP type for socksv4!"); + out.write(b); + out.write(0); // the userID stuff, 0 means end of string (null + // terminated) + out.flush(); + + if (in.read() != 0x00) // null byte + throw new IOException("Proxy server dun goofed"); + if (in.read() != 0x5a) + throw new IOException( + "Proxy server was unable to connect to server!"); + + in.readShort(); // ignored + in.readFully(b); // ignored + } + + private void socks5_connect() throws IOException { + DataOutputStream out = new DataOutputStream(getOutputStream()); + DataInputStream in = new DataInputStream(getInputStream()); + out.write(0x05); // the version + out.write(1); // number of authentication methods (no auth for now) + out.write(0); // the authentication (none) + out.flush(); + + if (in.read() != 0x05) // remote proxy version + throw new IOException("Proxy server is not supported!"); + if (in.read() != 0x00) // make sure shit is a vaild request + throw new IOException("Proxy server declined request!"); + + // now to write the actual request + out.write(0x05); // again the socks version + out.write(0x01); // the connection type (0x01 = TCP Connection) + out.write(0x00); // the reserve byte, un-used + byte[] b = addr.getAddress(); + out.write(b.length == 4 ? 0x01 : 0x04); // if ipv4 or ipv6 (0x03 = + // domain name, but that's + // unsupported as of yet) + out.write(b); + out.writeShort(port); + out.flush(); + + // now to read the server's reply + if (in.read() != 0x05) // socks version (again) + throw new IOException("Proxy server dun goofed"); + int reply = in.read(); + if (reply == 0x08) + throw new IOException("Bad address sent to proxy server"); + if (reply != 0x00) + throw new IOException("Unable to connect to server!"); + in.read(); // reserve byte + int addrType = in.read(); + b = new byte[4]; + switch (addrType) { + case 0x01: + b = new byte[4]; + break; + case 0x04: + b = new byte[16]; + break; + default: + throw new IOException("Bad address type from proxy server!"); + } + in.readFully(b); + in.readShort(); // the returned port #, ignored + } + + @Override + public int getPort() { + if (super.getInetAddress().equals(proxyInetAddress)) + return port; + return super.getPort(); + } + + @Override + public InetAddress getInetAddress() { + if (super.getInetAddress().equals(proxyInetAddress)) + return addr; + return super.getInetAddress(); + } + + @Override + public SocketAddress getRemoteSocketAddress() { + if (super.getInetAddress().equals(proxyInetAddress)) + return cachedAddr; + return super.getRemoteSocketAddress(); + } + + @Override + public SocketChannel getChannel() { + if (super.getInetAddress().equals(proxyInetAddress)) + return null; + return super.getChannel(); + } + + @Override + public void close() throws IOException{ + connections.remove(this); + super.close(); + } + + public static void setType(ProxyType pt) { + proxyType = pt; + } + + public static int getConnectionCount() { + return connections.size(); + } + +} diff --git a/parabotv2/src/org/matt123337/proxy/ProxyType.java b/parabotv2/src/org/matt123337/proxy/ProxyType.java new file mode 100644 index 0000000..d954f7b --- /dev/null +++ b/parabotv2/src/org/matt123337/proxy/ProxyType.java @@ -0,0 +1,5 @@ +package org.matt123337.proxy; + +public enum ProxyType { + SOCKS5,SOCKS4,HTTP +} diff --git a/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java b/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java new file mode 100644 index 0000000..490ad23 --- /dev/null +++ b/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java @@ -0,0 +1,51 @@ +package org.matt123337.spoofer; + +import java.net.InetAddress; +import java.net.SocketException; +import java.util.Enumeration; + +import org.parabot.core.ui.components.LogArea; + +public class NetworkInterface { + + public static byte[] mac = new byte[] { 11, 11, 11, 11, 11, 11 }; + + private static byte[] realMac; + + private static NetworkInterface cached; + + static { + try { + mac = getRealHardwareAddress(); + } catch (Exception ignored) { + } + } + + public byte[] getHardwareAddress() { + return mac; + } + + public static byte[] getRealHardwareAddress() throws SocketException { + if (realMac != null) + return realMac; + Enumeration nis = java.net.NetworkInterface + .getNetworkInterfaces(); + while (nis.hasMoreElements()) { + try { + byte[] b = nis.nextElement().getHardwareAddress(); + if (b.length == 0) + continue; + return realMac = b; + } catch (Exception e) { + } + } + return mac; + } + + public static NetworkInterface getByInetAddress(InetAddress addr) { + if (cached == null) + cached = new NetworkInterface(); + return cached; + } + +} diff --git a/parabotv2/src/org/matt123337/spoofer/Runtime.java b/parabotv2/src/org/matt123337/spoofer/Runtime.java new file mode 100644 index 0000000..3439042 --- /dev/null +++ b/parabotv2/src/org/matt123337/spoofer/Runtime.java @@ -0,0 +1,64 @@ +package org.matt123337.spoofer; + +import java.io.IOException; + +import org.parabot.core.ui.components.LogArea; + +public class Runtime { + + private java.lang.Runtime rt; + + private static Runtime cached; + + private Runtime(java.lang.Runtime rt){ + this.rt = rt; + } + + + public void addShutdownHook(Thread t){ + rt.addShutdownHook(t); + } + + public int availableProcessors(){ + return rt.availableProcessors(); + } + + public void exit(int i){ + rt.exit(i); + } + + public Process exec(String str) throws IOException{ + LogArea.log("RT:" + str); + System.out.println("RT:" + str); + return rt.exec(str); + } + + public Process exec(String[] cmdarray) throws IOException{ + StringBuffer sb = new StringBuffer(); + for(int i = 0; i < cmdarray.length;i++){ + sb.append(cmdarray[i] + (i < cmdarray.length - 1 ? "," : "")); + } + LogArea.log("RT: {" + sb + "}"); + System.out.println("RT: {" + sb + "}"); + return rt.exec(cmdarray); + } + + public long freeMemory(){ + return rt.freeMemory(); + } + + public void gc(){ + rt.gc(); + } + + public long maxMemory(){ + return rt.maxMemory(); + } + + public static Runtime getRuntime(){ + if(cached == null) + cached = new Runtime(java.lang.Runtime.getRuntime()); + return cached; + } + +} diff --git a/parabotv2/src/org/objectweb/asm/commons/LocalVariablesSorter.java b/parabotv2/src/org/objectweb/asm/commons/LocalVariablesSorter.java new file mode 100644 index 0000000..718e77f --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/LocalVariablesSorter.java @@ -0,0 +1,376 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.objectweb.asm.commons; + +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.Type; +import org.objectweb.asm.TypePath; + +/** + * A {@link MethodVisitor} that renumbers local variables in their order of + * appearance. This adapter allows one to easily add new local variables to a + * method. It may be used by inheriting from this class, but the preferred way + * of using it is via delegation: the next visitor in the chain can indeed add + * new locals when needed by calling {@link #newLocal} on this adapter (this + * requires a reference back to this {@link LocalVariablesSorter}). + * + * @author Chris Nokleberg + * @author Eugene Kuleshov + * @author Eric Bruneton + */ +public class LocalVariablesSorter extends MethodVisitor { + + private static final Type OBJECT_TYPE = Type + .getObjectType("java/lang/Object"); + + /** + * Mapping from old to new local variable indexes. A local variable at index + * i of size 1 is remapped to 'mapping[2*i]', while a local variable at + * index i of size 2 is remapped to 'mapping[2*i+1]'. + */ + private int[] mapping = new int[40]; + + /** + * Array used to store stack map local variable types after remapping. + */ + private Object[] newLocals = new Object[20]; + + /** + * Index of the first local variable, after formal parameters. + */ + protected final int firstLocal; + + /** + * Index of the next local variable to be created by {@link #newLocal}. + */ + protected int nextLocal; + + /** + * Indicates if at least one local variable has moved due to remapping. + */ + private boolean changed; + + /** + * Creates a new {@link LocalVariablesSorter}. Subclasses must not use + * this constructor. Instead, they must use the + * {@link #LocalVariablesSorter(int, int, String, MethodVisitor)} version. + * + * @param access + * access flags of the adapted method. + * @param desc + * the method's descriptor (see {@link Type Type}). + * @param mv + * the method visitor to which this adapter delegates calls. + */ + public LocalVariablesSorter(final int access, final String desc, + final MethodVisitor mv) { + this(Opcodes.ASM5, access, desc, mv); + } + + /** + * Creates a new {@link LocalVariablesSorter}. + * + * @param api + * the ASM API version implemented by this visitor. Must be one + * of {@link Opcodes#ASM4} or {@link Opcodes#ASM5}. + * @param access + * access flags of the adapted method. + * @param desc + * the method's descriptor (see {@link Type Type}). + * @param mv + * the method visitor to which this adapter delegates calls. + */ + protected LocalVariablesSorter(final int api, final int access, + final String desc, final MethodVisitor mv) { + super(api, mv); + Type[] args = Type.getArgumentTypes(desc); + nextLocal = (Opcodes.ACC_STATIC & access) == 0 ? 1 : 0; + for (int i = 0; i < args.length; i++) { + nextLocal += args[i].getSize(); + } + firstLocal = nextLocal; + } + + @Override + public void visitVarInsn(final int opcode, final int var) { + Type type; + switch (opcode) { + case Opcodes.LLOAD: + case Opcodes.LSTORE: + type = Type.LONG_TYPE; + break; + + case Opcodes.DLOAD: + case Opcodes.DSTORE: + type = Type.DOUBLE_TYPE; + break; + + case Opcodes.FLOAD: + case Opcodes.FSTORE: + type = Type.FLOAT_TYPE; + break; + + case Opcodes.ILOAD: + case Opcodes.ISTORE: + type = Type.INT_TYPE; + break; + + default: + // case Opcodes.ALOAD: + // case Opcodes.ASTORE: + // case RET: + type = OBJECT_TYPE; + break; + } + mv.visitVarInsn(opcode, remap(var, type)); + } + + @Override + public void visitIincInsn(final int var, final int increment) { + mv.visitIincInsn(remap(var, Type.INT_TYPE), increment); + } + + @Override + public void visitMaxs(final int maxStack, final int maxLocals) { + mv.visitMaxs(maxStack, nextLocal); + } + + @Override + public void visitLocalVariable(final String name, final String desc, + final String signature, final Label start, final Label end, + final int index) { + int newIndex = remap(index, Type.getType(desc)); + mv.visitLocalVariable(name, desc, signature, start, end, newIndex); + } + + @Override + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + Type t = Type.getType(desc); + int[] newIndex = new int[index.length]; + for (int i = 0; i < newIndex.length; ++i) { + newIndex[i] = remap(index[i], t); + } + return mv.visitLocalVariableAnnotation(typeRef, typePath, start, end, + newIndex, desc, visible); + } + + @Override + public void visitFrame(final int type, final int nLocal, + final Object[] local, final int nStack, final Object[] stack) { + if (type != Opcodes.F_NEW) { // uncompressed frame + throw new IllegalStateException( + "ClassReader.accept() should be called with EXPAND_FRAMES flag"); + } + + if (!changed) { // optimization for the case where mapping = identity + mv.visitFrame(type, nLocal, local, nStack, stack); + return; + } + + // creates a copy of newLocals + Object[] oldLocals = new Object[newLocals.length]; + System.arraycopy(newLocals, 0, oldLocals, 0, oldLocals.length); + + updateNewLocals(newLocals); + + // copies types from 'local' to 'newLocals' + // 'newLocals' already contains the variables added with 'newLocal' + + int index = 0; // old local variable index + int number = 0; // old local variable number + for (; number < nLocal; ++number) { + Object t = local[number]; + int size = t == Opcodes.LONG || t == Opcodes.DOUBLE ? 2 : 1; + if (t != Opcodes.TOP) { + Type typ = OBJECT_TYPE; + if (t == Opcodes.INTEGER) { + typ = Type.INT_TYPE; + } else if (t == Opcodes.FLOAT) { + typ = Type.FLOAT_TYPE; + } else if (t == Opcodes.LONG) { + typ = Type.LONG_TYPE; + } else if (t == Opcodes.DOUBLE) { + typ = Type.DOUBLE_TYPE; + } else if (t instanceof String) { + typ = Type.getObjectType((String) t); + } + setFrameLocal(remap(index, typ), t); + } + index += size; + } + + // removes TOP after long and double types as well as trailing TOPs + + index = 0; + number = 0; + for (int i = 0; index < newLocals.length; ++i) { + Object t = newLocals[index++]; + if (t != null && t != Opcodes.TOP) { + newLocals[i] = t; + number = i + 1; + if (t == Opcodes.LONG || t == Opcodes.DOUBLE) { + index += 1; + } + } else { + newLocals[i] = Opcodes.TOP; + } + } + + // visits remapped frame + mv.visitFrame(type, number, newLocals, nStack, stack); + + // restores original value of 'newLocals' + newLocals = oldLocals; + } + + // ------------- + + /** + * Creates a new local variable of the given type. + * + * @param type + * the type of the local variable to be created. + * @return the identifier of the newly created local variable. + */ + public int newLocal(final Type type) { + Object t; + switch (type.getSort()) { + case Type.BOOLEAN: + case Type.CHAR: + case Type.BYTE: + case Type.SHORT: + case Type.INT: + t = Opcodes.INTEGER; + break; + case Type.FLOAT: + t = Opcodes.FLOAT; + break; + case Type.LONG: + t = Opcodes.LONG; + break; + case Type.DOUBLE: + t = Opcodes.DOUBLE; + break; + case Type.ARRAY: + t = type.getDescriptor(); + break; + // case Type.OBJECT: + default: + t = type.getInternalName(); + break; + } + int local = newLocalMapping(type); + setLocalType(local, type); + setFrameLocal(local, t); + changed = true; + return local; + } + + /** + * Notifies subclasses that a new stack map frame is being visited. The + * array argument contains the stack map frame types corresponding to the + * local variables added with {@link #newLocal}. This method can update + * these types in place for the stack map frame being visited. The default + * implementation of this method does nothing, i.e. a local variable added + * with {@link #newLocal} will have the same type in all stack map frames. + * But this behavior is not always the desired one, for instance if a local + * variable is added in the middle of a try/catch block: the frame for the + * exception handler should have a TOP type for this new local. + * + * @param newLocals + * the stack map frame types corresponding to the local variables + * added with {@link #newLocal} (and null for the others). The + * format of this array is the same as in + * {@link MethodVisitor#visitFrame}, except that long and double + * types use two slots. The types for the current stack map frame + * must be updated in place in this array. + */ + protected void updateNewLocals(Object[] newLocals) { + } + + /** + * Notifies subclasses that a local variable has been added or remapped. The + * default implementation of this method does nothing. + * + * @param local + * a local variable identifier, as returned by {@link #newLocal + * newLocal()}. + * @param type + * the type of the value being stored in the local variable. + */ + protected void setLocalType(final int local, final Type type) { + } + + private void setFrameLocal(final int local, final Object type) { + int l = newLocals.length; + if (local >= l) { + Object[] a = new Object[Math.max(2 * l, local + 1)]; + System.arraycopy(newLocals, 0, a, 0, l); + newLocals = a; + } + newLocals[local] = type; + } + + private int remap(final int var, final Type type) { + if (var + type.getSize() <= firstLocal) { + return var; + } + int key = 2 * var + type.getSize() - 1; + int size = mapping.length; + if (key >= size) { + int[] newMapping = new int[Math.max(2 * size, key + 1)]; + System.arraycopy(mapping, 0, newMapping, 0, size); + mapping = newMapping; + } + int value = mapping[key]; + if (value == 0) { + value = newLocalMapping(type); + setLocalType(value, type); + mapping[key] = value + 1; + } else { + value--; + } + if (value != var) { + changed = true; + } + return value; + } + + protected int newLocalMapping(final Type type) { + int local = nextLocal; + nextLocal += type.getSize(); + return local; + } +} diff --git a/parabotv2/src/org/objectweb/asm/commons/Remapper.java b/parabotv2/src/org/objectweb/asm/commons/Remapper.java new file mode 100644 index 0000000..9c359fb --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/Remapper.java @@ -0,0 +1,223 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.objectweb.asm.commons; + +import org.objectweb.asm.Handle; +import org.objectweb.asm.Type; +import org.objectweb.asm.signature.SignatureReader; +import org.objectweb.asm.signature.SignatureVisitor; +import org.objectweb.asm.signature.SignatureWriter; + +/** + * A class responsible for remapping types and names. Subclasses can override + * the following methods: + * + *
    + *
  • {@link #map(String)} - map type
    • + *
  • {@link #mapFieldName(String, String, String)} - map field name
    • + *
  • {@link #mapMethodName(String, String, String)} - map method name
    • + *
+ * + * @author Eugene Kuleshov + */ +public abstract class Remapper { + + public String mapDesc(String desc) { + Type t = Type.getType(desc); + switch (t.getSort()) { + case Type.ARRAY: + String s = mapDesc(t.getElementType().getDescriptor()); + for (int i = 0; i < t.getDimensions(); ++i) { + s = '[' + s; + } + return s; + case Type.OBJECT: + String newType = map(t.getInternalName()); + if (newType != null) { + return 'L' + newType + ';'; + } + } + return desc; + } + + private Type mapType(Type t) { + switch (t.getSort()) { + case Type.ARRAY: + String s = mapDesc(t.getElementType().getDescriptor()); + for (int i = 0; i < t.getDimensions(); ++i) { + s = '[' + s; + } + return Type.getType(s); + case Type.OBJECT: + s = map(t.getInternalName()); + return s != null ? Type.getObjectType(s) : t; + case Type.METHOD: + return Type.getMethodType(mapMethodDesc(t.getDescriptor())); + } + return t; + } + + public String mapType(String type) { + if (type == null) { + return null; + } + return mapType(Type.getObjectType(type)).getInternalName(); + } + + public String[] mapTypes(String[] types) { + String[] newTypes = null; + boolean needMapping = false; + for (int i = 0; i < types.length; i++) { + String type = types[i]; + String newType = map(type); + if (newType != null && newTypes == null) { + newTypes = new String[types.length]; + if (i > 0) { + System.arraycopy(types, 0, newTypes, 0, i); + } + needMapping = true; + } + if (needMapping) { + newTypes[i] = newType == null ? type : newType; + } + } + return needMapping ? newTypes : types; + } + + public String mapMethodDesc(String desc) { + if ("()V".equals(desc)) { + return desc; + } + + Type[] args = Type.getArgumentTypes(desc); + StringBuffer s = new StringBuffer("("); + for (int i = 0; i < args.length; i++) { + s.append(mapDesc(args[i].getDescriptor())); + } + Type returnType = Type.getReturnType(desc); + if (returnType == Type.VOID_TYPE) { + s.append(")V"); + return s.toString(); + } + s.append(')').append(mapDesc(returnType.getDescriptor())); + return s.toString(); + } + + public Object mapValue(Object value) { + if (value instanceof Type) { + return mapType((Type) value); + } + if (value instanceof Handle) { + Handle h = (Handle) value; + return new Handle(h.getTag(), mapType(h.getOwner()), mapMethodName( + h.getOwner(), h.getName(), h.getDesc()), + mapMethodDesc(h.getDesc())); + } + return value; + } + + /** + * + * @param typeSignature + * true if signature is a FieldTypeSignature, such as the + * signature parameter of the ClassVisitor.visitField or + * MethodVisitor.visitLocalVariable methods + */ + public String mapSignature(String signature, boolean typeSignature) { + if (signature == null) { + return null; + } + SignatureReader r = new SignatureReader(signature); + SignatureWriter w = new SignatureWriter(); + SignatureVisitor a = createRemappingSignatureAdapter(w); + if (typeSignature) { + r.acceptType(a); + } else { + r.accept(a); + } + return w.toString(); + } + + protected SignatureVisitor createRemappingSignatureAdapter( + SignatureVisitor v) { + return new RemappingSignatureAdapter(v, this); + } + + /** + * Map method name to the new name. Subclasses can override. + * + * @param owner + * owner of the method. + * @param name + * name of the method. + * @param desc + * descriptor of the method. + * @return new name of the method + */ + public String mapMethodName(String owner, String name, String desc) { + return name; + } + + /** + * Map invokedynamic method name to the new name. Subclasses can override. + * + * @param name + * name of the invokedynamic. + * @param desc + * descriptor of the invokedynamic. + * @return new invokdynamic name. + */ + public String mapInvokeDynamicMethodName(String name, String desc) { + return name; + } + + /** + * Map field name to the new name. Subclasses can override. + * + * @param owner + * owner of the field. + * @param name + * name of the field + * @param desc + * descriptor of the field + * @return new name of the field. + */ + public String mapFieldName(String owner, String name, String desc) { + return name; + } + + /** + * Map type name to the new name. Subclasses can override. + */ + public String map(String typeName) { + return typeName; + } +} diff --git a/parabotv2/src/org/objectweb/asm/commons/RemappingAnnotationAdapter.java b/parabotv2/src/org/objectweb/asm/commons/RemappingAnnotationAdapter.java new file mode 100644 index 0000000..b9749fc --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/RemappingAnnotationAdapter.java @@ -0,0 +1,79 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.objectweb.asm.commons; + +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.Opcodes; + +/** + * An {@link AnnotationVisitor} adapter for type remapping. + * + * @author Eugene Kuleshov + */ +public class RemappingAnnotationAdapter extends AnnotationVisitor { + + protected final Remapper remapper; + + public RemappingAnnotationAdapter(final AnnotationVisitor av, + final Remapper remapper) { + this(Opcodes.ASM5, av, remapper); + } + + protected RemappingAnnotationAdapter(final int api, + final AnnotationVisitor av, final Remapper remapper) { + super(api, av); + this.remapper = remapper; + } + + @Override + public void visit(String name, Object value) { + av.visit(name, remapper.mapValue(value)); + } + + @Override + public void visitEnum(String name, String desc, String value) { + av.visitEnum(name, remapper.mapDesc(desc), value); + } + + @Override + public AnnotationVisitor visitAnnotation(String name, String desc) { + AnnotationVisitor v = av.visitAnnotation(name, remapper.mapDesc(desc)); + return v == null ? null : (v == av ? this + : new RemappingAnnotationAdapter(v, remapper)); + } + + @Override + public AnnotationVisitor visitArray(String name) { + AnnotationVisitor v = av.visitArray(name); + return v == null ? null : (v == av ? this + : new RemappingAnnotationAdapter(v, remapper)); + } +} diff --git a/parabotv2/src/org/objectweb/asm/commons/RemappingClassAdapter.java b/parabotv2/src/org/objectweb/asm/commons/RemappingClassAdapter.java new file mode 100644 index 0000000..c0b52ca --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/RemappingClassAdapter.java @@ -0,0 +1,135 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.objectweb.asm.commons; + +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.ClassVisitor; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.TypePath; + +/** + * A {@link ClassVisitor} for type remapping. + * + * @author Eugene Kuleshov + */ +public class RemappingClassAdapter extends ClassVisitor { + + protected final Remapper remapper; + + protected String className; + + public RemappingClassAdapter(final ClassVisitor cv, final Remapper remapper) { + this(Opcodes.ASM5, cv, remapper); + } + + protected RemappingClassAdapter(final int api, final ClassVisitor cv, + final Remapper remapper) { + super(api, cv); + this.remapper = remapper; + } + + @Override + public void visit(int version, int access, String name, String signature, + String superName, String[] interfaces) { + this.className = name; + super.visit(version, access, remapper.mapType(name), remapper + .mapSignature(signature, false), remapper.mapType(superName), + interfaces == null ? null : remapper.mapTypes(interfaces)); + } + + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + AnnotationVisitor av = super.visitAnnotation(remapper.mapDesc(desc), + visible); + return av == null ? null : createRemappingAnnotationAdapter(av); + } + + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, + remapper.mapDesc(desc), visible); + return av == null ? null : createRemappingAnnotationAdapter(av); + } + + @Override + public FieldVisitor visitField(int access, String name, String desc, + String signature, Object value) { + FieldVisitor fv = super.visitField(access, + remapper.mapFieldName(className, name, desc), + remapper.mapDesc(desc), remapper.mapSignature(signature, true), + remapper.mapValue(value)); + return fv == null ? null : createRemappingFieldAdapter(fv); + } + + @Override + public MethodVisitor visitMethod(int access, String name, String desc, + String signature, String[] exceptions) { + String newDesc = remapper.mapMethodDesc(desc); + MethodVisitor mv = super.visitMethod(access, remapper.mapMethodName( + className, name, desc), newDesc, remapper.mapSignature( + signature, false), + exceptions == null ? null : remapper.mapTypes(exceptions)); + return mv == null ? null : createRemappingMethodAdapter(access, + newDesc, mv); + } + + @Override + public void visitInnerClass(String name, String outerName, + String innerName, int access) { + // TODO should innerName be changed? + super.visitInnerClass(remapper.mapType(name), outerName == null ? null + : remapper.mapType(outerName), innerName, access); + } + + @Override + public void visitOuterClass(String owner, String name, String desc) { + super.visitOuterClass(remapper.mapType(owner), name == null ? null + : remapper.mapMethodName(owner, name, desc), + desc == null ? null : remapper.mapMethodDesc(desc)); + } + + protected FieldVisitor createRemappingFieldAdapter(FieldVisitor fv) { + return new RemappingFieldAdapter(fv, remapper); + } + + protected MethodVisitor createRemappingMethodAdapter(int access, + String newDesc, MethodVisitor mv) { + return new RemappingMethodAdapter(access, newDesc, mv, remapper); + } + + protected AnnotationVisitor createRemappingAnnotationAdapter( + AnnotationVisitor av) { + return new RemappingAnnotationAdapter(av, remapper); + } +} diff --git a/parabotv2/src/org/objectweb/asm/commons/RemappingFieldAdapter.java b/parabotv2/src/org/objectweb/asm/commons/RemappingFieldAdapter.java new file mode 100644 index 0000000..3179aba --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/RemappingFieldAdapter.java @@ -0,0 +1,71 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.objectweb.asm.commons; + +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.FieldVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.TypePath; + +/** + * A {@link FieldVisitor} adapter for type remapping. + * + * @author Eugene Kuleshov + */ +public class RemappingFieldAdapter extends FieldVisitor { + + private final Remapper remapper; + + public RemappingFieldAdapter(final FieldVisitor fv, final Remapper remapper) { + this(Opcodes.ASM5, fv, remapper); + } + + protected RemappingFieldAdapter(final int api, final FieldVisitor fv, + final Remapper remapper) { + super(api, fv); + this.remapper = remapper; + } + + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + AnnotationVisitor av = fv.visitAnnotation(remapper.mapDesc(desc), + visible); + return av == null ? null : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, + remapper.mapDesc(desc), visible); + return av == null ? null : new RemappingAnnotationAdapter(av, remapper); + } +} diff --git a/parabotv2/src/org/objectweb/asm/commons/RemappingMethodAdapter.java b/parabotv2/src/org/objectweb/asm/commons/RemappingMethodAdapter.java new file mode 100644 index 0000000..edf0665 --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/RemappingMethodAdapter.java @@ -0,0 +1,195 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.objectweb.asm.commons; + +import org.objectweb.asm.AnnotationVisitor; +import org.objectweb.asm.Handle; +import org.objectweb.asm.Label; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.TypePath; + +/** + * A {@link LocalVariablesSorter} for type mapping. + * + * @author Eugene Kuleshov + */ +public class RemappingMethodAdapter extends LocalVariablesSorter { + + protected final Remapper remapper; + + public RemappingMethodAdapter(final int access, final String desc, + final MethodVisitor mv, final Remapper remapper) { + this(Opcodes.ASM5, access, desc, mv, remapper); + } + + protected RemappingMethodAdapter(final int api, final int access, + final String desc, final MethodVisitor mv, final Remapper remapper) { + super(api, access, desc, mv); + this.remapper = remapper; + } + + @Override + public AnnotationVisitor visitAnnotationDefault() { + AnnotationVisitor av = super.visitAnnotationDefault(); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public AnnotationVisitor visitAnnotation(String desc, boolean visible) { + AnnotationVisitor av = super.visitAnnotation(remapper.mapDesc(desc), + visible); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public AnnotationVisitor visitTypeAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + AnnotationVisitor av = super.visitTypeAnnotation(typeRef, typePath, + remapper.mapDesc(desc), visible); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public AnnotationVisitor visitParameterAnnotation(int parameter, + String desc, boolean visible) { + AnnotationVisitor av = super.visitParameterAnnotation(parameter, + remapper.mapDesc(desc), visible); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public void visitFrame(int type, int nLocal, Object[] local, int nStack, + Object[] stack) { + super.visitFrame(type, nLocal, remapEntries(nLocal, local), nStack, + remapEntries(nStack, stack)); + } + + private Object[] remapEntries(int n, Object[] entries) { + for (int i = 0; i < n; i++) { + if (entries[i] instanceof String) { + Object[] newEntries = new Object[n]; + if (i > 0) { + System.arraycopy(entries, 0, newEntries, 0, i); + } + do { + Object t = entries[i]; + newEntries[i++] = t instanceof String ? remapper + .mapType((String) t) : t; + } while (i < n); + return newEntries; + } + } + return entries; + } + + @Override + public void visitFieldInsn(int opcode, String owner, String name, + String desc) { + super.visitFieldInsn(opcode, remapper.mapType(owner), + remapper.mapFieldName(owner, name, desc), + remapper.mapDesc(desc)); + } + + @Override + public void visitMethodInsn(int opcode, String owner, String name, + String desc) { + super.visitMethodInsn(opcode, remapper.mapType(owner), + remapper.mapMethodName(owner, name, desc), + remapper.mapMethodDesc(desc)); + } + + @Override + public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, + Object... bsmArgs) { + for (int i = 0; i < bsmArgs.length; i++) { + bsmArgs[i] = remapper.mapValue(bsmArgs[i]); + } + super.visitInvokeDynamicInsn( + remapper.mapInvokeDynamicMethodName(name, desc), + remapper.mapMethodDesc(desc), (Handle) remapper.mapValue(bsm), + bsmArgs); + } + + @Override + public void visitTypeInsn(int opcode, String type) { + super.visitTypeInsn(opcode, remapper.mapType(type)); + } + + @Override + public void visitLdcInsn(Object cst) { + super.visitLdcInsn(remapper.mapValue(cst)); + } + + @Override + public void visitMultiANewArrayInsn(String desc, int dims) { + super.visitMultiANewArrayInsn(remapper.mapDesc(desc), dims); + } + + @Override + public AnnotationVisitor visitInsnAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + AnnotationVisitor av = super.visitInsnAnnotation(typeRef, typePath, + remapper.mapDesc(desc), visible); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public void visitTryCatchBlock(Label start, Label end, Label handler, + String type) { + super.visitTryCatchBlock(start, end, handler, type == null ? null + : remapper.mapType(type)); + } + + @Override + public AnnotationVisitor visitTryCatchAnnotation(int typeRef, + TypePath typePath, String desc, boolean visible) { + AnnotationVisitor av = super.visitTryCatchAnnotation(typeRef, typePath, + remapper.mapDesc(desc), visible); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } + + @Override + public void visitLocalVariable(String name, String desc, String signature, + Label start, Label end, int index) { + super.visitLocalVariable(name, remapper.mapDesc(desc), + remapper.mapSignature(signature, true), start, end, index); + } + + @Override + public AnnotationVisitor visitLocalVariableAnnotation(int typeRef, + TypePath typePath, Label[] start, Label[] end, int[] index, + String desc, boolean visible) { + AnnotationVisitor av = super.visitLocalVariableAnnotation(typeRef, + typePath, start, end, index, remapper.mapDesc(desc), visible); + return av == null ? av : new RemappingAnnotationAdapter(av, remapper); + } +} diff --git a/parabotv2/src/org/objectweb/asm/commons/RemappingSignatureAdapter.java b/parabotv2/src/org/objectweb/asm/commons/RemappingSignatureAdapter.java new file mode 100644 index 0000000..5728034 --- /dev/null +++ b/parabotv2/src/org/objectweb/asm/commons/RemappingSignatureAdapter.java @@ -0,0 +1,155 @@ +/*** + * ASM: a very small and fast Java bytecode manipulation framework + * Copyright (c) 2000-2011 INRIA, France Telecom + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +package org.objectweb.asm.commons; + +import org.objectweb.asm.Opcodes; +import org.objectweb.asm.signature.SignatureVisitor; + +/** + * A {@link SignatureVisitor} adapter for type mapping. + * + * @author Eugene Kuleshov + */ +public class RemappingSignatureAdapter extends SignatureVisitor { + + private final SignatureVisitor v; + + private final Remapper remapper; + + private String className; + + public RemappingSignatureAdapter(final SignatureVisitor v, + final Remapper remapper) { + this(Opcodes.ASM5, v, remapper); + } + + protected RemappingSignatureAdapter(final int api, + final SignatureVisitor v, final Remapper remapper) { + super(api); + this.v = v; + this.remapper = remapper; + } + + @Override + public void visitClassType(String name) { + className = name; + v.visitClassType(remapper.mapType(name)); + } + + @Override + public void visitInnerClassType(String name) { + String remappedOuter = remapper.mapType(className) + '$'; + className = className + '$' + name; + String remappedName = remapper.mapType(className); + int index = remappedName.startsWith(remappedOuter) ? remappedOuter + .length() : remappedName.lastIndexOf('$') + 1; + v.visitInnerClassType(remappedName.substring(index)); + } + + @Override + public void visitFormalTypeParameter(String name) { + v.visitFormalTypeParameter(name); + } + + @Override + public void visitTypeVariable(String name) { + v.visitTypeVariable(name); + } + + @Override + public SignatureVisitor visitArrayType() { + v.visitArrayType(); + return this; + } + + @Override + public void visitBaseType(char descriptor) { + v.visitBaseType(descriptor); + } + + @Override + public SignatureVisitor visitClassBound() { + v.visitClassBound(); + return this; + } + + @Override + public SignatureVisitor visitExceptionType() { + v.visitExceptionType(); + return this; + } + + @Override + public SignatureVisitor visitInterface() { + v.visitInterface(); + return this; + } + + @Override + public SignatureVisitor visitInterfaceBound() { + v.visitInterfaceBound(); + return this; + } + + @Override + public SignatureVisitor visitParameterType() { + v.visitParameterType(); + return this; + } + + @Override + public SignatureVisitor visitReturnType() { + v.visitReturnType(); + return this; + } + + @Override + public SignatureVisitor visitSuperclass() { + v.visitSuperclass(); + return this; + } + + @Override + public void visitTypeArgument() { + v.visitTypeArgument(); + } + + @Override + public SignatureVisitor visitTypeArgument(char wildcard) { + v.visitTypeArgument(wildcard); + return this; + } + + @Override + public void visitEnd() { + v.visitEnd(); + } +} diff --git a/parabotv2/src/org/parabot/Landing.java b/parabotv2/src/org/parabot/Landing.java index 0b15747..6c26cf9 100644 --- a/parabotv2/src/org/parabot/Landing.java +++ b/parabotv2/src/org/parabot/Landing.java @@ -1,16 +1,19 @@ package org.parabot; +import java.io.IOException; + +import javax.swing.JOptionPane; +import javax.swing.UIManager; + +import org.matt123337.proxy.ProxySocket; +import org.matt123337.proxy.ProxyType; import org.parabot.core.Core; import org.parabot.core.Directories; import org.parabot.core.forum.AccountManager; -import org.parabot.core.spoofing.Ip; import org.parabot.core.ui.LoginUI; import org.parabot.core.ui.ServerSelector; import org.parabot.core.ui.utils.UILog; -import javax.swing.*; -import java.io.IOException; - /** * Parabot v2 * @@ -84,9 +87,14 @@ public final class Landing { username = args[++i]; password = args[++i]; break; - case "-proxy": - Ip.spoofIP(args[++i], args[++i]); - break; + case "-proxy": + String type = args[++i]; + String ip = args[++i]; + String port = args[++i]; + if (!handleProxy(type, ip, port)) { + System.exit(1); + } + break; case "-loadlocal": Core.setLoadLocal(true); break; @@ -94,5 +102,26 @@ public final class Landing { } } + + private static boolean handleProxy(String type, String ip, String port) { + ProxyType proxyType = null; + for (ProxyType pt : ProxyType.values()) { + if (pt.name().equalsIgnoreCase(type)) { + proxyType = pt; + break; + } + } + if (proxyType == null) { + System.err.println("Unknown proxy type:" + type); + return false; + } + try { + int p = Integer.parseInt(port); + ProxySocket.setProxy(proxyType, ip, p); + return true; + } catch (Exception e) { + return false; + } + } } diff --git a/parabotv2/src/org/parabot/core/classpath/ClassPath.java b/parabotv2/src/org/parabot/core/classpath/ClassPath.java index e444eeb..d58cdd4 100644 --- a/parabotv2/src/org/parabot/core/classpath/ClassPath.java +++ b/parabotv2/src/org/parabot/core/classpath/ClassPath.java @@ -18,8 +18,10 @@ import java.util.jar.JarOutputStream; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; +import org.matt123337.proxy.ClassRemapper; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.commons.RemappingClassAdapter; import org.objectweb.asm.tree.ClassNode; import org.parabot.core.Directories; import org.parabot.core.build.BuildPath; @@ -186,7 +188,8 @@ public class ClassPath { protected void loadClass(InputStream in) throws IOException { ClassReader cr = new ClassReader(in); ClassNode cn = new ClassNode(); - cr.accept(cn, 0); + RemappingClassAdapter adapter = new RemappingClassAdapter(cn,new ClassRemapper()); + cr.accept(adapter, ClassReader.EXPAND_FRAMES); classes.put(cn.name, cn); } diff --git a/parabotv2/src/org/parabot/core/spoofing/Ip.java b/parabotv2/src/org/parabot/core/spoofing/Ip.java deleted file mode 100644 index 5eac960..0000000 --- a/parabotv2/src/org/parabot/core/spoofing/Ip.java +++ /dev/null @@ -1,14 +0,0 @@ -package org.parabot.core.spoofing; - -/** - * User: Jeroen - * Date: 27/11/13 - * Time: 16:04 - */ -public class Ip { - public static void spoofIP(String host, String port) { - System.getProperties().setProperty("socksProxySet", "true"); - System.getProperties().setProperty("socksProxyHost", host); - System.getProperties().setProperty("socksProxyPort", port); - } -} \ No newline at end of file diff --git a/parabotv2/src/org/parabot/core/ui/BotUI.java b/parabotv2/src/org/parabot/core/ui/BotUI.java index c4698bc..976d3c6 100644 --- a/parabotv2/src/org/parabot/core/ui/BotUI.java +++ b/parabotv2/src/org/parabot/core/ui/BotUI.java @@ -9,6 +9,7 @@ import org.parabot.core.ui.images.Images; import org.parabot.core.ui.utils.SwingUtil; import javax.swing.*; + import java.awt.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; @@ -49,9 +50,12 @@ public class BotUI extends JFrame implements ActionListener { JMenuBar menubar = new JMenuBar(); JMenu mnuFile = new JMenu("File"); + JMenuItem proxy = new JMenuItem("Network"); JMenuItem exit = new JMenuItem("Exit"); + proxy.addActionListener(this); exit.addActionListener(this); + mnuFile.add(proxy); mnuFile.add(exit); menubar.add(mnuFile); @@ -96,6 +100,11 @@ public class BotUI extends JFrame implements ActionListener { case "Exit": System.exit(0); break; + case "Network": + NetworkUI proxy = NetworkUI.getInstance(); + proxy.setLocationRelativeTo(BotUI.getInstance()); + proxy.setVisible(true); + break; default: System.out.println("Invalid command: "); } diff --git a/parabotv2/src/org/parabot/core/ui/NetworkUI.java b/parabotv2/src/org/parabot/core/ui/NetworkUI.java new file mode 100644 index 0000000..11cc8e7 --- /dev/null +++ b/parabotv2/src/org/parabot/core/ui/NetworkUI.java @@ -0,0 +1,268 @@ +package org.parabot.core.ui; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.KeyEvent; +import java.awt.event.KeyListener; +import java.net.SocketException; + +import javax.swing.Box; +import javax.swing.BoxLayout; +import javax.swing.JButton; +import javax.swing.JComboBox; +import javax.swing.JFrame; +import javax.swing.JLabel; +import javax.swing.JList; +import javax.swing.JPanel; +import javax.swing.JScrollPane; +import javax.swing.JTextField; +import javax.swing.ListSelectionModel; +import javax.swing.border.EmptyBorder; +import javax.swing.event.DocumentEvent; +import javax.swing.event.DocumentListener; +import javax.swing.text.AttributeSet; +import javax.swing.text.BadLocationException; +import javax.swing.text.Document; +import javax.swing.text.PlainDocument; + +import org.matt123337.proxy.ProxySocket; +import org.matt123337.proxy.ProxyType; +import org.matt123337.spoofer.NetworkInterface; +import org.parabot.core.ui.components.LogArea; +import org.parabot.core.ui.utils.UILog; + +public class NetworkUI extends JFrame implements KeyListener, ActionListener, + DocumentListener { + + private static NetworkUI instance; + + private JComboBox proxyType; + private JTextField proxyHost; + private IntTextField proxyPort; + private JButton submitButton; + + JList[] macList; + JScrollPane[] macScrollList; + + private NetworkUI() { + initGUI(); + } + + public static NetworkUI getInstance() { + return instance == null ? instance = new NetworkUI() : instance; + } + + @Override + public void setVisible(boolean b) { + BotUI.getInstance().setEnabled(!b); + if (ProxySocket.getProxyAddress() != null) + proxyHost.setText(ProxySocket.getProxyAddress().getHostName()); + proxyPort.setText("" + ProxySocket.getProxyPort()); + proxyType.setSelectedItem(ProxySocket.getProxyType()); + super.setVisible(b); + } + + private void initGUI() { + proxyType = new JComboBox(ProxyType.values()); + proxyType.setSelectedItem(ProxySocket.getProxyType()); + + proxyHost = new JTextField(); + proxyHost.addKeyListener(this); + + proxyPort = new IntTextField(80, 5); + proxyPort.setColumns(5); + proxyPort.addKeyListener(this); + + submitButton = new JButton("Submit"); + submitButton.addActionListener(this); + + byte[] mac = new byte[6]; + try { + mac = NetworkInterface.getRealHardwareAddress(); + } catch (SocketException e) { + e.printStackTrace(); + } + macList = new JList[mac.length]; + macScrollList = new JScrollPane[mac.length]; + for (int i = 0; i < mac.length; i++) { + int value = mac[i] & 0xFF; + macList[i] = createMacList(); + macList[i].setSelectedIndex(value); + macScrollList[i] = new JScrollPane(macList[i]); + macList[i].ensureIndexIsVisible(value > 0 ? value - 1 : value); + + } + JPanel p = createPanelUI(); + add(p); + setResizable(false); + setDefaultCloseOperation(HIDE_ON_CLOSE); + pack(); + setTitle("Network Settings"); + } + + private JPanel createPanelUI() { + JPanel ret = new JPanel(); + ret.setLayout(new BoxLayout(ret, BoxLayout.LINE_AXIS)); + Box main = Box.createVerticalBox(); + + Box type = Box.createHorizontalBox(); + type.add(new JLabel("Proxy Type: ")); + type.add(proxyType); + + Box host = Box.createHorizontalBox(); + host.add(new JLabel("Proxy Host: ")); + host.add(proxyHost); + + Box port = Box.createHorizontalBox(); + port.add(new JLabel("Proxy Port: ")); + port.add(proxyPort); + + Box macBox = Box.createHorizontalBox(); + macBox.add(new JLabel("MAC:")); + for (int i = 0; i < macList.length; i++) { + macBox.add(new JScrollPane(macList[i])); + macBox.add(Box.createHorizontalStrut(5)); + } + + Box submit = Box.createHorizontalBox(); + submit.add(submitButton); + + main.add(type); + + main.add(Box.createVerticalStrut(5)); + main.add(host); + + main.add(Box.createVerticalStrut(5)); + main.add(port); + + main.add(Box.createVerticalStrut(5)); + main.add(macBox); + + main.add(Box.createVerticalStrut(5)); + main.add(submit); + + ret.add(main); + ret.setBorder(new EmptyBorder(10, 10, 10, 10)); + return ret; + } + + @Override + public void keyPressed(KeyEvent e) { + Object source = e.getSource(); + if (source == proxyPort || source == proxyHost) { + if (e.getKeyCode() == KeyEvent.VK_ENTER) { + actionPerformed(null); + } + } + } + + @Override + public void keyReleased(KeyEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void keyTyped(KeyEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void changedUpdate(DocumentEvent arg0) { + + } + + @Override + public void insertUpdate(DocumentEvent arg0) { + if (proxyPort.isValid()) { + proxyPort.setText("" + proxyPort.getValue()); + } + } + + @Override + public void removeUpdate(DocumentEvent arg0) { + insertUpdate(arg0); + } + + @Override + public void actionPerformed(ActionEvent arg0) { + byte[] mac = new byte[macList.length]; + for (int i = 0; i < mac.length; i++) + mac[i] = (byte) Short.parseShort((String) macList[i].getSelectedValue(), 16); + NetworkInterface.mac = mac; + + try { + if(ProxySocket.getConnectionCount() > 0) { + try { + LogArea.log("Closing Existing Connections..."); + ProxySocket.closeConnections(); + } catch (Exception e) { + + } + } + ProxySocket.setProxy((ProxyType) proxyType.getSelectedItem(), + proxyHost.getText(), proxyPort.getValue()); + UILog.log("Info", "Network settings have been set!"); + } catch (Exception e) { + UILog.log("Error", + "Unable to set proxy info!\n\nReason:" + e.getMessage()); + e.printStackTrace(); + } + setVisible(false); + } + + private JList createMacList() { + String[] hexStrings = new String[256]; + for (int i = 0; i < 256; i++) { + hexStrings[i] = String.format("%02X", i); + } + JList ret = new JList(hexStrings); + ret.setVisibleRowCount(3); + ret.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); + return ret; + } + + class IntTextField extends JTextField { + public IntTextField(int defval, int size) { + super("" + defval, size); + } + + protected Document createDefaultModel() { + return new IntTextDocument(); + } + + public boolean isValid() { + try { + int i = Integer.parseInt(getText()); + return i > 0 && i <= 25565; + } catch (Exception e) { + return false; + } + } + + public int getValue() { + try { + return Integer.parseInt(getText()); + } catch (NumberFormatException e) { + return 0; + } + } + + class IntTextDocument extends PlainDocument { + public void insertString(int offs, String str, AttributeSet a) + throws BadLocationException { + if (str == null) + return; + String oldString = getText(0, getLength()); + String newString = oldString.substring(0, offs) + str + + oldString.substring(offs); + try { + Integer.parseInt(newString.replace("-", "") + "0"); + super.insertString(offs, str, a); + } catch (NumberFormatException e) { + } + } + } + } +} diff --git a/parabotv2/src/org/parabot/core/ui/utils/UILog.java b/parabotv2/src/org/parabot/core/ui/utils/UILog.java index 1a48176..6f541c6 100644 --- a/parabotv2/src/org/parabot/core/ui/utils/UILog.java +++ b/parabotv2/src/org/parabot/core/ui/utils/UILog.java @@ -2,6 +2,8 @@ package org.parabot.core.ui.utils; import javax.swing.JOptionPane; +import org.parabot.core.ui.BotUI; + /** * * Log messages to the log user interface which is attached to the bot user interface @@ -17,7 +19,7 @@ public class UILog { public static void log(final String title, final String message, int messageType) { - JOptionPane.showMessageDialog(null, message, title, + JOptionPane.showMessageDialog(BotUI.getInstance(), message, title, messageType); } From 7b1e0e2094e208421a9fa6c968e104cbf6a49133 Mon Sep 17 00:00:00 2001 From: Clisprail Date: Tue, 18 Feb 2014 01:44:23 +0100 Subject: [PATCH 2/5] Removed useless import --- parabotv2/src/org/matt123337/spoofer/NetworkInterface.java | 2 -- 1 file changed, 2 deletions(-) diff --git a/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java b/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java index 490ad23..e07dac3 100644 --- a/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java +++ b/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java @@ -4,8 +4,6 @@ import java.net.InetAddress; import java.net.SocketException; import java.util.Enumeration; -import org.parabot.core.ui.components.LogArea; - public class NetworkInterface { public static byte[] mac = new byte[] { 11, 11, 11, 11, 11, 11 }; From ef3603cb46f7ee8846ef1ea362e49afd154a3be2 Mon Sep 17 00:00:00 2001 From: Clisprail Date: Tue, 18 Feb 2014 01:45:34 +0100 Subject: [PATCH 3/5] Generics --- .../src/org/parabot/core/ui/NetworkUI.java | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/parabotv2/src/org/parabot/core/ui/NetworkUI.java b/parabotv2/src/org/parabot/core/ui/NetworkUI.java index 11cc8e7..a49da70 100644 --- a/parabotv2/src/org/parabot/core/ui/NetworkUI.java +++ b/parabotv2/src/org/parabot/core/ui/NetworkUI.java @@ -33,6 +33,7 @@ import org.parabot.core.ui.utils.UILog; public class NetworkUI extends JFrame implements KeyListener, ActionListener, DocumentListener { + private static final long serialVersionUID = 1L; private static NetworkUI instance; @@ -41,7 +42,7 @@ public class NetworkUI extends JFrame implements KeyListener, ActionListener, private IntTextField proxyPort; private JButton submitButton; - JList[] macList; + JList[] macList; JScrollPane[] macScrollList; private NetworkUI() { @@ -212,18 +213,23 @@ public class NetworkUI extends JFrame implements KeyListener, ActionListener, setVisible(false); } - private JList createMacList() { + private JList createMacList() { String[] hexStrings = new String[256]; for (int i = 0; i < 256; i++) { hexStrings[i] = String.format("%02X", i); } - JList ret = new JList(hexStrings); + JList ret = new JList(hexStrings); ret.setVisibleRowCount(3); ret.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); return ret; } class IntTextField extends JTextField { + /** + * + */ + private static final long serialVersionUID = 1L; + public IntTextField(int defval, int size) { super("" + defval, size); } @@ -250,6 +256,11 @@ public class NetworkUI extends JFrame implements KeyListener, ActionListener, } class IntTextDocument extends PlainDocument { + /** + * + */ + private static final long serialVersionUID = 1L; + public void insertString(int offs, String str, AttributeSet a) throws BadLocationException { if (str == null) From 03d2cbb7df1a90cef00c8781f7276f9bcb5a8242 Mon Sep 17 00:00:00 2001 From: Clisprail Date: Tue, 18 Feb 2014 01:46:42 +0100 Subject: [PATCH 4/5] correct packaging + other things --- parabotv2/src/org/parabot/Landing.java | 4 ++-- parabotv2/src/org/parabot/core/classpath/ClassPath.java | 2 +- .../{matt123337 => parabot/core}/proxy/ClassRemapper.java | 2 +- .../org/{matt123337 => parabot/core}/proxy/ProxySocket.java | 2 +- .../org/{matt123337 => parabot/core}/proxy/ProxyType.java | 2 +- .../core}/spoofer/NetworkInterface.java | 2 +- .../org/{matt123337 => parabot/core}/spoofer/Runtime.java | 2 +- parabotv2/src/org/parabot/core/ui/NetworkUI.java | 6 +++--- 8 files changed, 11 insertions(+), 11 deletions(-) rename parabotv2/src/org/{matt123337 => parabot/core}/proxy/ClassRemapper.java (94%) rename parabotv2/src/org/{matt123337 => parabot/core}/proxy/ProxySocket.java (99%) rename parabotv2/src/org/{matt123337 => parabot/core}/proxy/ProxyType.java (59%) rename parabotv2/src/org/{matt123337 => parabot/core}/spoofer/NetworkInterface.java (96%) rename parabotv2/src/org/{matt123337 => parabot/core}/spoofer/Runtime.java (97%) diff --git a/parabotv2/src/org/parabot/Landing.java b/parabotv2/src/org/parabot/Landing.java index 6c26cf9..069e0fa 100644 --- a/parabotv2/src/org/parabot/Landing.java +++ b/parabotv2/src/org/parabot/Landing.java @@ -5,11 +5,11 @@ import java.io.IOException; import javax.swing.JOptionPane; import javax.swing.UIManager; -import org.matt123337.proxy.ProxySocket; -import org.matt123337.proxy.ProxyType; import org.parabot.core.Core; import org.parabot.core.Directories; import org.parabot.core.forum.AccountManager; +import org.parabot.core.proxy.ProxySocket; +import org.parabot.core.proxy.ProxyType; import org.parabot.core.ui.LoginUI; import org.parabot.core.ui.ServerSelector; import org.parabot.core.ui.utils.UILog; diff --git a/parabotv2/src/org/parabot/core/classpath/ClassPath.java b/parabotv2/src/org/parabot/core/classpath/ClassPath.java index d58cdd4..6152578 100644 --- a/parabotv2/src/org/parabot/core/classpath/ClassPath.java +++ b/parabotv2/src/org/parabot/core/classpath/ClassPath.java @@ -18,7 +18,6 @@ import java.util.jar.JarOutputStream; import java.util.zip.ZipEntry; import java.util.zip.ZipInputStream; -import org.matt123337.proxy.ClassRemapper; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassWriter; import org.objectweb.asm.commons.RemappingClassAdapter; @@ -26,6 +25,7 @@ import org.objectweb.asm.tree.ClassNode; import org.parabot.core.Directories; import org.parabot.core.build.BuildPath; import org.parabot.core.io.SizeInputStream; +import org.parabot.core.proxy.ClassRemapper; import org.parabot.core.ui.components.VerboseLoader; /** diff --git a/parabotv2/src/org/matt123337/proxy/ClassRemapper.java b/parabotv2/src/org/parabot/core/proxy/ClassRemapper.java similarity index 94% rename from parabotv2/src/org/matt123337/proxy/ClassRemapper.java rename to parabotv2/src/org/parabot/core/proxy/ClassRemapper.java index 61f3a9f..a297640 100644 --- a/parabotv2/src/org/matt123337/proxy/ClassRemapper.java +++ b/parabotv2/src/org/parabot/core/proxy/ClassRemapper.java @@ -1,4 +1,4 @@ -package org.matt123337.proxy; +package org.parabot.core.proxy; import java.util.HashMap; diff --git a/parabotv2/src/org/matt123337/proxy/ProxySocket.java b/parabotv2/src/org/parabot/core/proxy/ProxySocket.java similarity index 99% rename from parabotv2/src/org/matt123337/proxy/ProxySocket.java rename to parabotv2/src/org/parabot/core/proxy/ProxySocket.java index df6f531..03c9149 100644 --- a/parabotv2/src/org/matt123337/proxy/ProxySocket.java +++ b/parabotv2/src/org/parabot/core/proxy/ProxySocket.java @@ -1,4 +1,4 @@ -package org.matt123337.proxy; +package org.parabot.core.proxy; import java.io.BufferedReader; import java.io.DataInputStream; diff --git a/parabotv2/src/org/matt123337/proxy/ProxyType.java b/parabotv2/src/org/parabot/core/proxy/ProxyType.java similarity index 59% rename from parabotv2/src/org/matt123337/proxy/ProxyType.java rename to parabotv2/src/org/parabot/core/proxy/ProxyType.java index d954f7b..ac6a8c2 100644 --- a/parabotv2/src/org/matt123337/proxy/ProxyType.java +++ b/parabotv2/src/org/parabot/core/proxy/ProxyType.java @@ -1,4 +1,4 @@ -package org.matt123337.proxy; +package org.parabot.core.proxy; public enum ProxyType { SOCKS5,SOCKS4,HTTP diff --git a/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java b/parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java similarity index 96% rename from parabotv2/src/org/matt123337/spoofer/NetworkInterface.java rename to parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java index e07dac3..3b441c0 100644 --- a/parabotv2/src/org/matt123337/spoofer/NetworkInterface.java +++ b/parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java @@ -1,4 +1,4 @@ -package org.matt123337.spoofer; +package org.parabot.core.spoofer; import java.net.InetAddress; import java.net.SocketException; diff --git a/parabotv2/src/org/matt123337/spoofer/Runtime.java b/parabotv2/src/org/parabot/core/spoofer/Runtime.java similarity index 97% rename from parabotv2/src/org/matt123337/spoofer/Runtime.java rename to parabotv2/src/org/parabot/core/spoofer/Runtime.java index 3439042..6def902 100644 --- a/parabotv2/src/org/matt123337/spoofer/Runtime.java +++ b/parabotv2/src/org/parabot/core/spoofer/Runtime.java @@ -1,4 +1,4 @@ -package org.matt123337.spoofer; +package org.parabot.core.spoofer; import java.io.IOException; diff --git a/parabotv2/src/org/parabot/core/ui/NetworkUI.java b/parabotv2/src/org/parabot/core/ui/NetworkUI.java index a49da70..a465de6 100644 --- a/parabotv2/src/org/parabot/core/ui/NetworkUI.java +++ b/parabotv2/src/org/parabot/core/ui/NetworkUI.java @@ -25,9 +25,9 @@ import javax.swing.text.BadLocationException; import javax.swing.text.Document; import javax.swing.text.PlainDocument; -import org.matt123337.proxy.ProxySocket; -import org.matt123337.proxy.ProxyType; -import org.matt123337.spoofer.NetworkInterface; +import org.parabot.core.proxy.ProxySocket; +import org.parabot.core.proxy.ProxyType; +import org.parabot.core.spoofer.NetworkInterface; import org.parabot.core.ui.components.LogArea; import org.parabot.core.ui.utils.UILog; From ff026bc6ff9dc0d926130617312d5887312d2722 Mon Sep 17 00:00:00 2001 From: Clisprail Date: Tue, 18 Feb 2014 01:52:49 +0100 Subject: [PATCH 5/5] revert proxy as requested --- parabotv2/src/org/parabot/Landing.java | 30 -- .../org/parabot/core/classpath/ClassPath.java | 5 +- .../org/parabot/core/proxy/ClassRemapper.java | 24 -- .../org/parabot/core/proxy/ProxySocket.java | 276 ----------------- .../src/org/parabot/core/proxy/ProxyType.java | 5 - .../core/spoofer/NetworkInterface.java | 49 --- .../src/org/parabot/core/spoofer/Runtime.java | 64 ---- parabotv2/src/org/parabot/core/ui/BotUI.java | 5 - .../src/org/parabot/core/ui/NetworkUI.java | 279 ------------------ 9 files changed, 1 insertion(+), 736 deletions(-) delete mode 100644 parabotv2/src/org/parabot/core/proxy/ClassRemapper.java delete mode 100644 parabotv2/src/org/parabot/core/proxy/ProxySocket.java delete mode 100644 parabotv2/src/org/parabot/core/proxy/ProxyType.java delete mode 100644 parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java delete mode 100644 parabotv2/src/org/parabot/core/spoofer/Runtime.java delete mode 100644 parabotv2/src/org/parabot/core/ui/NetworkUI.java diff --git a/parabotv2/src/org/parabot/Landing.java b/parabotv2/src/org/parabot/Landing.java index 069e0fa..aebb6cf 100644 --- a/parabotv2/src/org/parabot/Landing.java +++ b/parabotv2/src/org/parabot/Landing.java @@ -8,8 +8,6 @@ import javax.swing.UIManager; import org.parabot.core.Core; import org.parabot.core.Directories; import org.parabot.core.forum.AccountManager; -import org.parabot.core.proxy.ProxySocket; -import org.parabot.core.proxy.ProxyType; import org.parabot.core.ui.LoginUI; import org.parabot.core.ui.ServerSelector; import org.parabot.core.ui.utils.UILog; @@ -87,14 +85,6 @@ public final class Landing { username = args[++i]; password = args[++i]; break; - case "-proxy": - String type = args[++i]; - String ip = args[++i]; - String port = args[++i]; - if (!handleProxy(type, ip, port)) { - System.exit(1); - } - break; case "-loadlocal": Core.setLoadLocal(true); break; @@ -103,25 +93,5 @@ public final class Landing { } } - private static boolean handleProxy(String type, String ip, String port) { - ProxyType proxyType = null; - for (ProxyType pt : ProxyType.values()) { - if (pt.name().equalsIgnoreCase(type)) { - proxyType = pt; - break; - } - } - if (proxyType == null) { - System.err.println("Unknown proxy type:" + type); - return false; - } - try { - int p = Integer.parseInt(port); - ProxySocket.setProxy(proxyType, ip, p); - return true; - } catch (Exception e) { - return false; - } - } } diff --git a/parabotv2/src/org/parabot/core/classpath/ClassPath.java b/parabotv2/src/org/parabot/core/classpath/ClassPath.java index 6152578..099631c 100644 --- a/parabotv2/src/org/parabot/core/classpath/ClassPath.java +++ b/parabotv2/src/org/parabot/core/classpath/ClassPath.java @@ -20,12 +20,10 @@ import java.util.zip.ZipInputStream; import org.objectweb.asm.ClassReader; import org.objectweb.asm.ClassWriter; -import org.objectweb.asm.commons.RemappingClassAdapter; import org.objectweb.asm.tree.ClassNode; import org.parabot.core.Directories; import org.parabot.core.build.BuildPath; import org.parabot.core.io.SizeInputStream; -import org.parabot.core.proxy.ClassRemapper; import org.parabot.core.ui.components.VerboseLoader; /** @@ -188,8 +186,7 @@ public class ClassPath { protected void loadClass(InputStream in) throws IOException { ClassReader cr = new ClassReader(in); ClassNode cn = new ClassNode(); - RemappingClassAdapter adapter = new RemappingClassAdapter(cn,new ClassRemapper()); - cr.accept(adapter, ClassReader.EXPAND_FRAMES); + cr.accept(cn, ClassReader.EXPAND_FRAMES); classes.put(cn.name, cn); } diff --git a/parabotv2/src/org/parabot/core/proxy/ClassRemapper.java b/parabotv2/src/org/parabot/core/proxy/ClassRemapper.java deleted file mode 100644 index a297640..0000000 --- a/parabotv2/src/org/parabot/core/proxy/ClassRemapper.java +++ /dev/null @@ -1,24 +0,0 @@ -package org.parabot.core.proxy; - -import java.util.HashMap; - -import org.objectweb.asm.commons.Remapper; - -public class ClassRemapper extends Remapper { - private static HashMap remapNames = new HashMap(); - static { - remapNames.put("java/net/Socket", "org/matt123337/proxy/ProxySocket"); - remapNames.put("java/net/NetworkInterface", "org/matt123337/spoofer/NetworkInterface"); - remapNames.put("java/lang/Runtime", "org/matt123337/spoofer/Runtime"); - } - - @Override - public String map(String str) { - String s = remapNames.get(str); - if (s != null) { - return s; - } else { - return str; - } - } -} \ No newline at end of file diff --git a/parabotv2/src/org/parabot/core/proxy/ProxySocket.java b/parabotv2/src/org/parabot/core/proxy/ProxySocket.java deleted file mode 100644 index 03c9149..0000000 --- a/parabotv2/src/org/parabot/core/proxy/ProxySocket.java +++ /dev/null @@ -1,276 +0,0 @@ -package org.parabot.core.proxy; - -import java.io.BufferedReader; -import java.io.DataInputStream; -import java.io.DataOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.io.OutputStream; -import java.net.InetAddress; -import java.net.InetSocketAddress; -import java.net.Socket; -import java.net.SocketAddress; -import java.net.UnknownHostException; -import java.nio.channels.SocketChannel; -import java.util.ArrayList; -import java.util.List; - -import javax.swing.JOptionPane; - -import org.parabot.core.ui.components.LogArea; -import org.parabot.core.ui.utils.UILog; - -public class ProxySocket extends Socket { - - private static Listconnections = new ArrayList(); - - private static ProxyType proxyType = ProxyType.HTTP; - - private static int proxyPort = 0; - - private InetAddress addr; - private int port; - - private static InetAddress proxyInetAddress = null; - - private InetSocketAddress cachedAddr; - - public static int closeConnections(){ - int value = 0; - for(ProxySocket socket : connections) - try{ - connections.remove(socket); - if(socket.isClosed()) - continue; - socket.close(); - value++; - }catch(Exception e){ - - } - return value; - } - - public ProxySocket(InetAddress addr, int port) throws IOException { - super(addr, port); - } - - public ProxySocket() { - super(); - } - - public ProxySocket(String host, int port) throws IOException { - super(host, port); - } - - public static void setProxy(ProxyType type,String host, int port) { - try { - proxyInetAddress = InetAddress.getByName(host); - proxyPort = port; - proxyType = type; - } catch (UnknownHostException e) { - throw new RuntimeException(e); - } - } - - public static InetAddress getProxyAddress(){ - return proxyInetAddress; - } - - public static int getProxyPort(){ - return proxyPort; - } - - public static ProxyType getProxyType(){ - return proxyType; - } - - @Override - public void connect(SocketAddress addr) throws IOException { - connections.add(this); - if (addr instanceof InetSocketAddress) { - InetSocketAddress isa = (InetSocketAddress) addr; - this.addr = InetAddress.getByName(isa.getHostString()); - this.port = isa.getPort(); - } - if (proxyInetAddress != null && proxyPort > 0) { - try{ - super.connect(cachedAddr = new InetSocketAddress(proxyInetAddress, - proxyPort)); - initProxy(); - }catch(Exception e){ - UILog.log( - "Proxy Error", - e.getMessage(), - JOptionPane.ERROR_MESSAGE); - } - } else - super.connect(addr); - } - - private void initProxy() throws IOException { - LogArea.log("Proxying:" + addr + ":" + port - + " Over:" + proxyInetAddress + ":" + proxyPort + " Type:" - + proxyType); - switch (proxyType) { - case HTTP: - http_connect(); - break; - case SOCKS4: - socks4_connect(); - break; - case SOCKS5: - socks5_connect(); - break; - default: - throw new IOException("Unsupported proxy type:" + proxyType); - } - } - - private void http_connect() throws IOException { - InputStream in = getInputStream(); - BufferedReader br = new BufferedReader(new InputStreamReader(in)); - OutputStream out = getOutputStream(); - out.write(("CONNECT " + addr.getHostAddress() + ":" + port + "\r\n") - .getBytes()); - // out.write("Connection:keep-alive\r\n".getBytes()); - out.write("\r\n".getBytes()); - String str; - while ((str = br.readLine()) != null) { - if (str.length() == 0) - break; - if (!str.startsWith("HTTP")) - continue; - int code = Integer.parseInt(str.substring(9, 12)); - switch (code) { - case 404: - throw new IOException( - "Proxy seems to think we're connecting to a webpage..."); - case 403: - throw new IOException( - "Proxy doesn't support connecting to port: " + port + "! Try a different proxy."); - } - if (code / 100 != 2) - throw new IOException( - "Unable to connect to proxy server! HTTP Error code:" + code); - } - } - - private void socks4_connect() throws IOException { - DataOutputStream out = new DataOutputStream(getOutputStream()); - DataInputStream in = new DataInputStream(getInputStream()); - - out.write(0x04); - out.write(0x01); // connection type (TCP stream) - out.writeShort(port); - byte[] b = addr.getAddress(); - if (b.length != 4) - throw new IOException("Unsupported IP type for socksv4!"); - out.write(b); - out.write(0); // the userID stuff, 0 means end of string (null - // terminated) - out.flush(); - - if (in.read() != 0x00) // null byte - throw new IOException("Proxy server dun goofed"); - if (in.read() != 0x5a) - throw new IOException( - "Proxy server was unable to connect to server!"); - - in.readShort(); // ignored - in.readFully(b); // ignored - } - - private void socks5_connect() throws IOException { - DataOutputStream out = new DataOutputStream(getOutputStream()); - DataInputStream in = new DataInputStream(getInputStream()); - out.write(0x05); // the version - out.write(1); // number of authentication methods (no auth for now) - out.write(0); // the authentication (none) - out.flush(); - - if (in.read() != 0x05) // remote proxy version - throw new IOException("Proxy server is not supported!"); - if (in.read() != 0x00) // make sure shit is a vaild request - throw new IOException("Proxy server declined request!"); - - // now to write the actual request - out.write(0x05); // again the socks version - out.write(0x01); // the connection type (0x01 = TCP Connection) - out.write(0x00); // the reserve byte, un-used - byte[] b = addr.getAddress(); - out.write(b.length == 4 ? 0x01 : 0x04); // if ipv4 or ipv6 (0x03 = - // domain name, but that's - // unsupported as of yet) - out.write(b); - out.writeShort(port); - out.flush(); - - // now to read the server's reply - if (in.read() != 0x05) // socks version (again) - throw new IOException("Proxy server dun goofed"); - int reply = in.read(); - if (reply == 0x08) - throw new IOException("Bad address sent to proxy server"); - if (reply != 0x00) - throw new IOException("Unable to connect to server!"); - in.read(); // reserve byte - int addrType = in.read(); - b = new byte[4]; - switch (addrType) { - case 0x01: - b = new byte[4]; - break; - case 0x04: - b = new byte[16]; - break; - default: - throw new IOException("Bad address type from proxy server!"); - } - in.readFully(b); - in.readShort(); // the returned port #, ignored - } - - @Override - public int getPort() { - if (super.getInetAddress().equals(proxyInetAddress)) - return port; - return super.getPort(); - } - - @Override - public InetAddress getInetAddress() { - if (super.getInetAddress().equals(proxyInetAddress)) - return addr; - return super.getInetAddress(); - } - - @Override - public SocketAddress getRemoteSocketAddress() { - if (super.getInetAddress().equals(proxyInetAddress)) - return cachedAddr; - return super.getRemoteSocketAddress(); - } - - @Override - public SocketChannel getChannel() { - if (super.getInetAddress().equals(proxyInetAddress)) - return null; - return super.getChannel(); - } - - @Override - public void close() throws IOException{ - connections.remove(this); - super.close(); - } - - public static void setType(ProxyType pt) { - proxyType = pt; - } - - public static int getConnectionCount() { - return connections.size(); - } - -} diff --git a/parabotv2/src/org/parabot/core/proxy/ProxyType.java b/parabotv2/src/org/parabot/core/proxy/ProxyType.java deleted file mode 100644 index ac6a8c2..0000000 --- a/parabotv2/src/org/parabot/core/proxy/ProxyType.java +++ /dev/null @@ -1,5 +0,0 @@ -package org.parabot.core.proxy; - -public enum ProxyType { - SOCKS5,SOCKS4,HTTP -} diff --git a/parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java b/parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java deleted file mode 100644 index 3b441c0..0000000 --- a/parabotv2/src/org/parabot/core/spoofer/NetworkInterface.java +++ /dev/null @@ -1,49 +0,0 @@ -package org.parabot.core.spoofer; - -import java.net.InetAddress; -import java.net.SocketException; -import java.util.Enumeration; - -public class NetworkInterface { - - public static byte[] mac = new byte[] { 11, 11, 11, 11, 11, 11 }; - - private static byte[] realMac; - - private static NetworkInterface cached; - - static { - try { - mac = getRealHardwareAddress(); - } catch (Exception ignored) { - } - } - - public byte[] getHardwareAddress() { - return mac; - } - - public static byte[] getRealHardwareAddress() throws SocketException { - if (realMac != null) - return realMac; - Enumeration nis = java.net.NetworkInterface - .getNetworkInterfaces(); - while (nis.hasMoreElements()) { - try { - byte[] b = nis.nextElement().getHardwareAddress(); - if (b.length == 0) - continue; - return realMac = b; - } catch (Exception e) { - } - } - return mac; - } - - public static NetworkInterface getByInetAddress(InetAddress addr) { - if (cached == null) - cached = new NetworkInterface(); - return cached; - } - -} diff --git a/parabotv2/src/org/parabot/core/spoofer/Runtime.java b/parabotv2/src/org/parabot/core/spoofer/Runtime.java deleted file mode 100644 index 6def902..0000000 --- a/parabotv2/src/org/parabot/core/spoofer/Runtime.java +++ /dev/null @@ -1,64 +0,0 @@ -package org.parabot.core.spoofer; - -import java.io.IOException; - -import org.parabot.core.ui.components.LogArea; - -public class Runtime { - - private java.lang.Runtime rt; - - private static Runtime cached; - - private Runtime(java.lang.Runtime rt){ - this.rt = rt; - } - - - public void addShutdownHook(Thread t){ - rt.addShutdownHook(t); - } - - public int availableProcessors(){ - return rt.availableProcessors(); - } - - public void exit(int i){ - rt.exit(i); - } - - public Process exec(String str) throws IOException{ - LogArea.log("RT:" + str); - System.out.println("RT:" + str); - return rt.exec(str); - } - - public Process exec(String[] cmdarray) throws IOException{ - StringBuffer sb = new StringBuffer(); - for(int i = 0; i < cmdarray.length;i++){ - sb.append(cmdarray[i] + (i < cmdarray.length - 1 ? "," : "")); - } - LogArea.log("RT: {" + sb + "}"); - System.out.println("RT: {" + sb + "}"); - return rt.exec(cmdarray); - } - - public long freeMemory(){ - return rt.freeMemory(); - } - - public void gc(){ - rt.gc(); - } - - public long maxMemory(){ - return rt.maxMemory(); - } - - public static Runtime getRuntime(){ - if(cached == null) - cached = new Runtime(java.lang.Runtime.getRuntime()); - return cached; - } - -} diff --git a/parabotv2/src/org/parabot/core/ui/BotUI.java b/parabotv2/src/org/parabot/core/ui/BotUI.java index 976d3c6..b5a8dd6 100644 --- a/parabotv2/src/org/parabot/core/ui/BotUI.java +++ b/parabotv2/src/org/parabot/core/ui/BotUI.java @@ -100,11 +100,6 @@ public class BotUI extends JFrame implements ActionListener { case "Exit": System.exit(0); break; - case "Network": - NetworkUI proxy = NetworkUI.getInstance(); - proxy.setLocationRelativeTo(BotUI.getInstance()); - proxy.setVisible(true); - break; default: System.out.println("Invalid command: "); } diff --git a/parabotv2/src/org/parabot/core/ui/NetworkUI.java b/parabotv2/src/org/parabot/core/ui/NetworkUI.java deleted file mode 100644 index a465de6..0000000 --- a/parabotv2/src/org/parabot/core/ui/NetworkUI.java +++ /dev/null @@ -1,279 +0,0 @@ -package org.parabot.core.ui; - -import java.awt.event.ActionEvent; -import java.awt.event.ActionListener; -import java.awt.event.KeyEvent; -import java.awt.event.KeyListener; -import java.net.SocketException; - -import javax.swing.Box; -import javax.swing.BoxLayout; -import javax.swing.JButton; -import javax.swing.JComboBox; -import javax.swing.JFrame; -import javax.swing.JLabel; -import javax.swing.JList; -import javax.swing.JPanel; -import javax.swing.JScrollPane; -import javax.swing.JTextField; -import javax.swing.ListSelectionModel; -import javax.swing.border.EmptyBorder; -import javax.swing.event.DocumentEvent; -import javax.swing.event.DocumentListener; -import javax.swing.text.AttributeSet; -import javax.swing.text.BadLocationException; -import javax.swing.text.Document; -import javax.swing.text.PlainDocument; - -import org.parabot.core.proxy.ProxySocket; -import org.parabot.core.proxy.ProxyType; -import org.parabot.core.spoofer.NetworkInterface; -import org.parabot.core.ui.components.LogArea; -import org.parabot.core.ui.utils.UILog; - -public class NetworkUI extends JFrame implements KeyListener, ActionListener, - DocumentListener { - private static final long serialVersionUID = 1L; - - private static NetworkUI instance; - - private JComboBox proxyType; - private JTextField proxyHost; - private IntTextField proxyPort; - private JButton submitButton; - - JList[] macList; - JScrollPane[] macScrollList; - - private NetworkUI() { - initGUI(); - } - - public static NetworkUI getInstance() { - return instance == null ? instance = new NetworkUI() : instance; - } - - @Override - public void setVisible(boolean b) { - BotUI.getInstance().setEnabled(!b); - if (ProxySocket.getProxyAddress() != null) - proxyHost.setText(ProxySocket.getProxyAddress().getHostName()); - proxyPort.setText("" + ProxySocket.getProxyPort()); - proxyType.setSelectedItem(ProxySocket.getProxyType()); - super.setVisible(b); - } - - private void initGUI() { - proxyType = new JComboBox(ProxyType.values()); - proxyType.setSelectedItem(ProxySocket.getProxyType()); - - proxyHost = new JTextField(); - proxyHost.addKeyListener(this); - - proxyPort = new IntTextField(80, 5); - proxyPort.setColumns(5); - proxyPort.addKeyListener(this); - - submitButton = new JButton("Submit"); - submitButton.addActionListener(this); - - byte[] mac = new byte[6]; - try { - mac = NetworkInterface.getRealHardwareAddress(); - } catch (SocketException e) { - e.printStackTrace(); - } - macList = new JList[mac.length]; - macScrollList = new JScrollPane[mac.length]; - for (int i = 0; i < mac.length; i++) { - int value = mac[i] & 0xFF; - macList[i] = createMacList(); - macList[i].setSelectedIndex(value); - macScrollList[i] = new JScrollPane(macList[i]); - macList[i].ensureIndexIsVisible(value > 0 ? value - 1 : value); - - } - JPanel p = createPanelUI(); - add(p); - setResizable(false); - setDefaultCloseOperation(HIDE_ON_CLOSE); - pack(); - setTitle("Network Settings"); - } - - private JPanel createPanelUI() { - JPanel ret = new JPanel(); - ret.setLayout(new BoxLayout(ret, BoxLayout.LINE_AXIS)); - Box main = Box.createVerticalBox(); - - Box type = Box.createHorizontalBox(); - type.add(new JLabel("Proxy Type: ")); - type.add(proxyType); - - Box host = Box.createHorizontalBox(); - host.add(new JLabel("Proxy Host: ")); - host.add(proxyHost); - - Box port = Box.createHorizontalBox(); - port.add(new JLabel("Proxy Port: ")); - port.add(proxyPort); - - Box macBox = Box.createHorizontalBox(); - macBox.add(new JLabel("MAC:")); - for (int i = 0; i < macList.length; i++) { - macBox.add(new JScrollPane(macList[i])); - macBox.add(Box.createHorizontalStrut(5)); - } - - Box submit = Box.createHorizontalBox(); - submit.add(submitButton); - - main.add(type); - - main.add(Box.createVerticalStrut(5)); - main.add(host); - - main.add(Box.createVerticalStrut(5)); - main.add(port); - - main.add(Box.createVerticalStrut(5)); - main.add(macBox); - - main.add(Box.createVerticalStrut(5)); - main.add(submit); - - ret.add(main); - ret.setBorder(new EmptyBorder(10, 10, 10, 10)); - return ret; - } - - @Override - public void keyPressed(KeyEvent e) { - Object source = e.getSource(); - if (source == proxyPort || source == proxyHost) { - if (e.getKeyCode() == KeyEvent.VK_ENTER) { - actionPerformed(null); - } - } - } - - @Override - public void keyReleased(KeyEvent arg0) { - // TODO Auto-generated method stub - - } - - @Override - public void keyTyped(KeyEvent arg0) { - // TODO Auto-generated method stub - - } - - @Override - public void changedUpdate(DocumentEvent arg0) { - - } - - @Override - public void insertUpdate(DocumentEvent arg0) { - if (proxyPort.isValid()) { - proxyPort.setText("" + proxyPort.getValue()); - } - } - - @Override - public void removeUpdate(DocumentEvent arg0) { - insertUpdate(arg0); - } - - @Override - public void actionPerformed(ActionEvent arg0) { - byte[] mac = new byte[macList.length]; - for (int i = 0; i < mac.length; i++) - mac[i] = (byte) Short.parseShort((String) macList[i].getSelectedValue(), 16); - NetworkInterface.mac = mac; - - try { - if(ProxySocket.getConnectionCount() > 0) { - try { - LogArea.log("Closing Existing Connections..."); - ProxySocket.closeConnections(); - } catch (Exception e) { - - } - } - ProxySocket.setProxy((ProxyType) proxyType.getSelectedItem(), - proxyHost.getText(), proxyPort.getValue()); - UILog.log("Info", "Network settings have been set!"); - } catch (Exception e) { - UILog.log("Error", - "Unable to set proxy info!\n\nReason:" + e.getMessage()); - e.printStackTrace(); - } - setVisible(false); - } - - private JList createMacList() { - String[] hexStrings = new String[256]; - for (int i = 0; i < 256; i++) { - hexStrings[i] = String.format("%02X", i); - } - JList ret = new JList(hexStrings); - ret.setVisibleRowCount(3); - ret.setSelectionMode(ListSelectionModel.SINGLE_SELECTION); - return ret; - } - - class IntTextField extends JTextField { - /** - * - */ - private static final long serialVersionUID = 1L; - - public IntTextField(int defval, int size) { - super("" + defval, size); - } - - protected Document createDefaultModel() { - return new IntTextDocument(); - } - - public boolean isValid() { - try { - int i = Integer.parseInt(getText()); - return i > 0 && i <= 25565; - } catch (Exception e) { - return false; - } - } - - public int getValue() { - try { - return Integer.parseInt(getText()); - } catch (NumberFormatException e) { - return 0; - } - } - - class IntTextDocument extends PlainDocument { - /** - * - */ - private static final long serialVersionUID = 1L; - - public void insertString(int offs, String str, AttributeSet a) - throws BadLocationException { - if (str == null) - return; - String oldString = getText(0, getLength()); - String newString = oldString.substring(0, offs) + str - + oldString.substring(offs); - try { - Integer.parseInt(newString.replace("-", "") + "0"); - super.insertString(offs, str, a); - } catch (NumberFormatException e) { - } - } - } - } -}