2006-Scape/Parabot
1
0
Fork 0
mirror of https://github.com/2006-Scape/Parabot.git synced 2026-07-04 00:37:46 +00:00
Code Issues 2 Packages Projects Releases 3 Wiki Activity

Low level proxy support added, MAC address spoofing done, basic runtime interception done

Browse Source 
Signed-off-by: matt123337 <matt123337@hotmail.com>
This commit is contained in:
matt123337
2014-02-17 19:26:58 -05:00
parent dc08dd5777
commit 74a731d2e0
19 changed files with 1980 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+6
View File
@@ -46,3 +46,9 @@ parabotv2/src/META-INF/MANIFEST.MF
/bin
.idea/uiDesigner.xml
*.jar
*.classpath
*.project
parabotv2/src/org/matt123337/proxy/ClassRemapper.java
+24
View File
@@ -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<String, String> remapNames = new HashMap<String, String>();
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;
}
}
}
parabotv2/src/org/matt123337/proxy/ProxySocket.java
+276
View File
@@ -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 List<ProxySocket>connections = new ArrayList<ProxySocket>();
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();
}
}
parabotv2/src/org/matt123337/proxy/ProxyType.java
+5
View File
@@ -0,0 +1,5 @@
package org.matt123337.proxy;
public enum ProxyType {
SOCKS5,SOCKS4,HTTP
}
parabotv2/src/org/matt123337/spoofer/NetworkInterface.java
+51
View File
@@ -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<java.net.NetworkInterface> 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;
}
}
parabotv2/src/org/matt123337/spoofer/Runtime.java
+64
View File
@@ -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;
}
}
parabotv2/src/org/objectweb/asm/commons/LocalVariablesSorter.java
+376
View File
@@ -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}. <i>Subclasses must not use
* this constructor</i>. 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;
}
}
parabotv2/src/org/objectweb/asm/commons/Remapper.java
+223
View File
@@ -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:
*
* <ul>
* <li>{@link #map(String)} - map type</li>
* <li>{@link #mapFieldName(String, String, String)} - map field name</li>
* <li>{@link #mapMethodName(String, String, String)} - map method name</li>
* </ul>
*
* @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;
}
}
parabotv2/src/org/objectweb/asm/commons/RemappingAnnotationAdapter.java
+79
View File
@@ -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));
}
}
parabotv2/src/org/objectweb/asm/commons/RemappingClassAdapter.java
+135
View File
@@ -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);
}
}
parabotv2/src/org/objectweb/asm/commons/RemappingFieldAdapter.java
+71
View File
@@ -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);
}
}
parabotv2/src/org/objectweb/asm/commons/RemappingMethodAdapter.java
+195
View File
@@ -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);
}
}
parabotv2/src/org/objectweb/asm/commons/RemappingSignatureAdapter.java
+155
View File
@@ -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();
}
}
parabotv2/src/org/parabot/Landing.java
+36 -7
View File
@@ -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;
}
}
}
parabotv2/src/org/parabot/core/classpath/ClassPath.java
+4 -1
View File
@@ -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);
}
parabotv2/src/org/parabot/core/spoofing/Ip.java
-14
View File
@@ -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);
}
}
parabotv2/src/org/parabot/core/ui/BotUI.java
+9
View File
@@ -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: ");
}
parabotv2/src/org/parabot/core/ui/NetworkUI.java
+268
View File
@@ -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> 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>(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<String>(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) {
}
}
}
}
}
parabotv2/src/org/parabot/core/ui/utils/UILog.java
+3 -1
View File
@@ -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);
}