use of net.runelite.asm.execution.InstructionContext in project runelite by runelite.
the class Swap method execute.
@Override
public InstructionContext execute(Frame frame) {
InstructionContext ins = new InstructionContext(this, frame);
Stack stack = frame.getStack();
StackContext one = stack.pop();
StackContext two = stack.pop();
ins.pop(one, two);
StackContext ctx = new StackContext(ins, one.getType(), one.getValue());
stack.push(ctx);
ins.push(ctx);
ctx = new StackContext(ins, two.getType(), two.getValue());
stack.push(ctx);
ins.push(ctx);
return ins;
}
use of net.runelite.asm.execution.InstructionContext in project runelite by runelite.
the class InjectHook method recursivelyPush.
private int recursivelyPush(Instructions ins, int idx, StackContext sctx) {
InstructionContext ctx = sctx.getPushed();
if (ctx.getInstruction() instanceof DupInstruction) {
DupInstruction dupInstruction = (DupInstruction) ctx.getInstruction();
sctx = dupInstruction.getOriginal(sctx);
ctx = sctx.getPushed();
}
for (StackContext s : Lists.reverse(ctx.getPops())) {
idx = recursivelyPush(ins, idx, s);
}
ins.getInstructions().add(idx++, ctx.getInstruction().clone());
return idx;
}
use of net.runelite.asm.execution.InstructionContext in project runelite by runelite.
the class InjectHook method run.
public void run() {
Execution e = new Execution(inject.getVanilla());
e.populateInitialMethods();
Set<Instruction> done = new HashSet<>();
Set<Instruction> doneIh = new HashSet<>();
e.addExecutionVisitor((InstructionContext ic) -> {
Instruction i = ic.getInstruction();
Instructions ins = i.getInstructions();
Code code = ins.getCode();
Method method = code.getMethod();
if (method.getName().equals(CLINIT)) {
return;
}
if (!(i instanceof SetFieldInstruction)) {
return;
}
if (!done.add(i)) {
return;
}
SetFieldInstruction sfi = (SetFieldInstruction) i;
Field fieldBeingSet = sfi.getMyField();
if (fieldBeingSet == null) {
return;
}
HookInfo hookInfo = hooked.get(fieldBeingSet);
if (hookInfo == null) {
return;
}
String hookName = hookInfo.fieldName;
assert hookName != null;
logger.trace("Found injection location for hook {} at instruction {}", hookName, sfi);
++injectedHooks;
Instruction objectInstruction = new AConstNull(ins);
StackContext objectStackContext = null;
if (sfi instanceof PutField) {
// Object being set on
StackContext objectStack = ic.getPops().get(1);
objectStackContext = objectStack;
}
int idx = ins.getInstructions().indexOf(sfi);
assert idx != -1;
try {
// idx + 1 to insert after the set
injectCallback(ins, idx + 1, hookInfo, null, objectStackContext);
} catch (InjectionException ex) {
throw new RuntimeException(ex);
}
});
// these look like:
// getfield
// iload_0
// iconst_0
// iastore
e.addExecutionVisitor((InstructionContext ic) -> {
Instruction i = ic.getInstruction();
Instructions ins = i.getInstructions();
Code code = ins.getCode();
Method method = code.getMethod();
if (method.getName().equals(CLINIT)) {
return;
}
if (!(i instanceof ArrayStore)) {
return;
}
if (!doneIh.add(i)) {
return;
}
ArrayStore as = (ArrayStore) i;
Field fieldBeingSet = as.getMyField(ic);
if (fieldBeingSet == null) {
return;
}
HookInfo hookInfo = hooked.get(fieldBeingSet);
if (hookInfo == null) {
return;
}
String hookName = hookInfo.fieldName;
// assume this is always at index 1
StackContext index = ic.getPops().get(1);
StackContext arrayReference = ic.getPops().get(2);
InstructionContext arrayReferencePushed = arrayReference.getPushed();
StackContext objectStackContext = null;
if (arrayReferencePushed.getInstruction().getType() == InstructionType.GETFIELD) {
StackContext objectReference = arrayReferencePushed.getPops().get(0);
objectStackContext = objectReference;
}
// inject hook after 'i'
logger.info("Found array injection location for hook {} at instruction {}", hookName, i);
++injectedHooks;
int idx = ins.getInstructions().indexOf(i);
assert idx != -1;
try {
injectCallback(ins, idx + 1, hookInfo, index, objectStackContext);
} catch (InjectionException ex) {
throw new RuntimeException(ex);
}
});
e.run();
}
use of net.runelite.asm.execution.InstructionContext in project runelite by runelite.
the class PacketHandlerOrder method run.
@Override
public void run(ClassGroup group) {
// This is run on the deobfuscated jar, so there are no symbols yet...
// Find packetType and buffer classes
PacketTypeFinder ptf = new PacketTypeFinder(group);
ptf.find();
BufferFinder bf = new BufferFinder(group);
bf.find();
HandlerFinder hf = new HandlerFinder(group, ptf.getPacketType());
PacketHandlers handlers = hf.findHandlers();
logger.info("Found {} packet handlers", handlers.getHandlers().size());
for (PacketHandler handler : handlers.getHandlers()) {
Execution e = hf.getExecution();
e.reset();
e.staticStep = true;
e.step = false;
e.noInvoke = true;
// exception processing won't do non-local jumps, so
// depending on whether methods are inlined or not
// it may jump completely out of the handler into the
// catch all for all packet handling
// just disable exception execution
e.noExceptions = true;
assert e.frames.isEmpty();
Frame f = handler.jumpFrame.dup();
assert f.isExecuting();
f.getMethodCtx().reset();
e.clearExecutionVisitor();
e.addExecutionVisitor(ictx -> {
if (ictx.getInstruction() instanceof MappableInstruction) {
if (ictx.getInstruction().getType() != InstructionType.INVOKESTATIC) {
if (!handler.mappable.contains(ictx.getInstruction())) {
handler.mappable.add(ictx.getInstruction());
}
}
}
if (ictx.getInstruction().getType() == InstructionType.INVOKEVIRTUAL) {
InvokeInstruction ii = (InvokeInstruction) ictx.getInstruction();
// check if the invoke is on buffer/packetbuffer classes
boolean matches = ii.getMethods().stream().filter(m -> m.getDescriptor().size() == 0).map(method -> method.getClassFile()).anyMatch(cf -> cf == bf.getBuffer() || cf == bf.getPacketBuffer());
if (matches) {
Method method = ii.getMethods().get(0);
Signature signature = method.getDescriptor();
Type returnValue = signature.getReturnValue();
// buffer reference
assert ictx.getPops().size() == 1;
InstructionContext bufferCtx = ictx.getPops().get(0).getPushed();
if (bufferCtx.getInstruction().getType() != InstructionType.GETSTATIC) {
// sometimes buffer is passed to a function and then invoked.
return;
}
PacketRead packetRead = new PacketRead(returnValue, bufferCtx.getInstruction(), ictx);
if (!handler.reads.contains(packetRead)) {
handler.reads.add(packetRead);
}
}
}
if (ictx.getInstruction().getType() == InstructionType.INVOKEVIRTUAL || ictx.getInstruction().getType() == InstructionType.INVOKESPECIAL || ictx.getInstruction().getType() == InstructionType.INVOKEINTERFACE) {
InvokeInstruction ii = (InvokeInstruction) ictx.getInstruction();
// read methods are scrambled so cant count them
if (!handler.hasPacketRead(ictx.getInstruction())) {
handler.methodInvokes.addAll(ii.getMethods());
}
}
if (ictx.getInstruction() instanceof SetFieldInstruction) {
SetFieldInstruction sfi = (SetFieldInstruction) ictx.getInstruction();
Field field = sfi.getMyField();
if (field != null) {
handler.fieldWrite.add(field);
}
}
if (ictx.getInstruction() instanceof GetFieldInstruction) {
GetFieldInstruction gfi = (GetFieldInstruction) ictx.getInstruction();
Field field = gfi.getMyField();
if (field != null) {
handler.fieldRead.add(field);
}
}
if (ictx.getInstruction() instanceof LVTInstruction) {
LVTInstruction lvt = (LVTInstruction) ictx.getInstruction();
if (!lvt.store()) {
// get lvt access order
Frame frame = ictx.getFrame();
int order = frame.getNextOrder();
if (!handler.lvtOrder.containsKey(lvt.getVariableIndex())) {
handler.lvtOrder.put(lvt.getVariableIndex(), order);
}
}
}
if (ictx.getInstruction() instanceof PushConstantInstruction) {
PushConstantInstruction pci = (PushConstantInstruction) ictx.getInstruction();
handler.constants.add(pci.getConstant());
}
});
logger.debug("Beginning execution of opcode {}", handler.getOpcode());
e.run();
logger.info("Executed opcode {}: {} mappable instructions", handler.getOpcode(), handler.mappable.size());
handler.findReorderableReads();
}
List<PacketHandler> unsortedHandlers = new ArrayList<>(handlers.getHandlers());
List<PacketHandler> sortedHandlers = new ArrayList<>(handlers.getHandlers()).stream().sorted((PacketHandler p1, PacketHandler p2) -> {
int c = compareReads(p1.reads, p2.reads);
if (c != 0) {
return c;
}
if (p1.methodInvokes.size() != p2.methodInvokes.size()) {
return Integer.compare(p1.methodInvokes.size(), p2.methodInvokes.size());
}
if (p1.fieldRead.size() != p2.fieldRead.size()) {
return Integer.compare(p1.fieldRead.size(), p2.fieldRead.size());
}
if (p1.fieldWrite.size() != p2.fieldWrite.size()) {
return Integer.compare(p1.fieldWrite.size(), p2.fieldWrite.size());
}
int i = Integer.compare(p1.mappable.size(), p2.mappable.size());
if (i != 0) {
return i;
}
int s1 = hashConstants(p1.constants), s2 = hashConstants(p2.constants);
if (s1 != s2) {
return Integer.compare(s1, s2);
}
logger.warn("Unable to differentiate {} from {}", p1, p2);
return 0;
}).map(s -> s.clone()).collect(Collectors.toList());
assert sortedHandlers.size() == handlers.getHandlers().size();
for (PacketHandler handler : sortedHandlers) {
handler.sortedReads = new ArrayList<>(handler.reads);
Collections.sort(handler.sortedReads, (PacketRead p1, PacketRead p2) -> {
LVTInstruction l1 = (LVTInstruction) p1.getStore();
LVTInstruction l2 = (LVTInstruction) p2.getStore();
if (l1 == null && l2 == null) {
return 0;
}
if (l1 == null) {
return 1;
}
if (l2 == null) {
return -1;
}
if (l1.getVariableIndex() == l2.getVariableIndex()) {
return 0;
}
Integer i1 = handler.lvtOrder.get(l1.getVariableIndex());
Integer i2 = handler.lvtOrder.get(l2.getVariableIndex());
assert i1 != null;
assert i2 != null;
int i = Integer.compare(i1, i2);
if (i == 0) {
logger.warn("Cannot differentiate {} from {}", p1, p2);
}
return i;
});
Collections.reverse(handler.sortedReads);
}
ClassFile runeliteOpcodes = group.findClass(RUNELITE_OPCODES);
assert runeliteOpcodes != null : "Opcodes class must exist";
for (PacketHandler handler : sortedHandlers) {
logger.info("Handler {} mappable {} reads {} invokes {} freads {} fwrites {}", handler.getOpcode(), handler.mappable.size(), handler.reads.size(), handler.methodInvokes.size(), handler.fieldRead.size(), handler.fieldWrite.size());
final String fieldName = "PACKET_SERVER_" + handler.getOpcode();
// Add opcode fields
if (runeliteOpcodes.findField(fieldName) == null) {
Field opField = new Field(runeliteOpcodes, fieldName, Type.INT);
// ACC_FINAL causes javac to inline the fields, which prevents
// the mapper from doing field mapping
opField.setAccessFlags(ACC_PUBLIC | ACC_STATIC);
// setting a non-final static field value
// doesn't work with fernflower
opField.setValue(handler.getOpcode());
runeliteOpcodes.addField(opField);
// add initialization
Method clinit = runeliteOpcodes.findMethod("<clinit>");
assert clinit != null;
Instructions instructions = clinit.getCode().getInstructions();
instructions.addInstruction(0, new LDC(instructions, handler.getOpcode()));
instructions.addInstruction(1, new PutStatic(instructions, opField));
}
}
// Find unique methods
List<Method> methods = unsortedHandlers.stream().map(ph -> ph.getMethod()).distinct().collect(Collectors.toList());
for (Method m : methods) {
List<PacketHandler> unsortedMethodHandlers = unsortedHandlers.stream().filter(ph -> ph.getMethod() == m).collect(Collectors.toList());
List<PacketHandler> sortedMethodHandlers = sortedHandlers.stream().filter(ph -> ph.getMethod() == m).collect(Collectors.toList());
assert unsortedMethodHandlers.size() == sortedMethodHandlers.size();
for (int i = 0; i < sortedMethodHandlers.size(); ++i) {
PacketHandler unsorted = unsortedMethodHandlers.get(i);
PacketHandler sortedh = sortedMethodHandlers.get(i);
// Set opcode/jump from sorted -> unsorted
If jump = (If) unsorted.getJump();
PushConstantInstruction pci = (PushConstantInstruction) unsorted.getPush();
assert unsorted.getOpcode() == ((Number) pci.getConstant()).intValue();
Instructions instructions = unsorted.getMethod().getCode().getInstructions();
final String fieldName = "PACKET_SERVER_" + sortedh.getOpcode();
net.runelite.asm.pool.Field field = new net.runelite.asm.pool.Field(new net.runelite.asm.pool.Class(RUNELITE_OPCODES), fieldName, Type.INT);
instructions.replace(unsorted.getPush(), new GetStatic(instructions, field));
assert jump.getType() == InstructionType.IF_ICMPEQ || jump.getType() == InstructionType.IF_ICMPNE;
Label startLabel = instructions.createLabelFor(sortedh.getStart());
if (jump.getType() == InstructionType.IF_ICMPEQ) {
instructions.replace(jump, new IfICmpEq(instructions, startLabel));
} else if (jump.getType() == InstructionType.IF_ICMPNE) {
// insert a jump after to go to sortedh start
int idx = instructions.getInstructions().indexOf(jump);
assert idx != -1;
instructions.addInstruction(idx + 1, new Goto(instructions, startLabel));
} else {
throw new IllegalStateException();
}
}
}
insertSortedReads(group, sortedHandlers);
insertPacketLength(group, ptf);
}
use of net.runelite.asm.execution.InstructionContext in project runelite by runelite.
the class PutField method isSame.
@Override
public boolean isSame(InstructionContext thisIc, InstructionContext otherIc) {
if (thisIc.getInstruction().getClass() != otherIc.getInstruction().getClass()) {
return false;
}
PutField thisPf = (PutField) thisIc.getInstruction(), otherPf = (PutField) otherIc.getInstruction();
net.runelite.asm.Field f1 = thisPf.getMyField();
net.runelite.asm.Field f2 = otherPf.getMyField();
if ((f1 != null) != (f2 != null)) {
return false;
}
if (!MappingExecutorUtil.isMaybeEqual(f1.getClassFile(), f2.getClassFile()) || !MappingExecutorUtil.isMaybeEqual(f1.getType(), f2.getType())) {
return false;
}
// check assignment
StackContext object1 = thisIc.getPops().get(1), object2 = otherIc.getPops().get(1);
InstructionContext base1 = MappingExecutorUtil.resolve(object1.getPushed(), object1);
InstructionContext base2 = MappingExecutorUtil.resolve(object2.getPushed(), object2);
if (!isMaybeEqual(base1, base2)) {
return false;
}
// check value
object1 = thisIc.getPops().get(0);
object2 = otherIc.getPops().get(0);
base1 = MappingExecutorUtil.resolve(object1.getPushed(), object1);
base2 = MappingExecutorUtil.resolve(object2.getPushed(), object2);
if (!isMaybeEqual(base1, base2)) {
return false;
}
return true;
}
Aggregations