use of net.runelite.asm.ClassFile in project runelite by runelite.
the class HookImporter method importHooks.
@Test
@Ignore
public void importHooks() {
int classes = 0, fields = 0, methods = 0, callbacks = 0;
for (String deobfuscatedClassName : hooks.keySet()) {
ClassHook ch = hooks.get(deobfuscatedClassName);
ClassFile cf = this.findClassWithObfuscatedName(ch.getClazz());
assert cf != null;
String implementsName = getAnnotation(cf.getAnnotations(), IMPLEMENTS);
if (implementsName.isEmpty()) {
cf.getAnnotations().addAnnotation(IMPLEMENTS, "value", deobfuscatedClassName);
++classes;
}
for (String deobfuscatedFieldName : ch.getFields().keySet()) {
FieldHook fh = ch.getFields().get(deobfuscatedFieldName);
String[] s = fh.getField().split("\\.");
Field f;
if (s.length == 2) {
ClassFile cf2 = this.findClassWithObfuscatedName(s[0]);
assert cf2 != null;
f = this.findFieldWithObfuscatedName(cf2, s[1]);
} else if (s.length == 1) {
f = this.findFieldWithObfuscatedName(cf, fh.getField());
} else {
throw new RuntimeException();
}
assert f != null;
String exportedName = getAnnotation(f.getAnnotations(), EXPORT);
if (exportedName.isEmpty()) {
f.getAnnotations().addAnnotation(EXPORT, "value", deobfuscatedFieldName);
++fields;
}
}
for (String deobfuscatedMethodName : ch.getMethods().keySet()) {
MethodHook mh = ch.getMethods().get(deobfuscatedMethodName);
String[] s = mh.getMethod().split("\\.");
Method m;
if (s.length == 2) {
ClassFile cf2 = this.findClassWithObfuscatedName(s[0]);
assert cf2 != null;
m = this.findMethodWithObfuscatedName(cf2, s[1], mh.getClientDesc());
} else if (s.length == 1) {
m = this.findMethodWithObfuscatedName(cf, mh.getMethod(), mh.getClientDesc());
} else {
throw new RuntimeException();
}
assert m != null;
String exportedName = getAnnotation(m.getAnnotations(), EXPORT);
if (exportedName.isEmpty()) {
m.getAnnotations().addAnnotation(EXPORT, "value", deobfuscatedMethodName);
++methods;
}
}
for (String deobfuscatedMethodName : ch.getCallbacks().keySet()) {
MethodHook mh = ch.getCallbacks().get(deobfuscatedMethodName);
String[] s = mh.getMethod().split("\\.");
Method m;
if (s.length == 2) {
ClassFile cf2 = this.findClassWithObfuscatedName(s[0]);
assert cf2 != null;
m = this.findMethodWithObfuscatedName(cf2, s[1], mh.getClientDesc());
} else if (s.length == 1) {
m = this.findMethodWithObfuscatedName(cf, mh.getMethod(), mh.getClientDesc());
} else {
throw new RuntimeException();
}
assert m != null;
String exportedName = getAnnotation(m.getAnnotations(), EXPORT);
if (exportedName.isEmpty()) {
m.getAnnotations().addAnnotation(EXPORT, "value", deobfuscatedMethodName);
++callbacks;
}
}
}
System.out.println("Imported " + classes + " classes, " + fields + " fields, " + methods + " methods, " + callbacks + " callbacks");
}
use of net.runelite.asm.ClassFile in project runelite by runelite.
the class MappingImporter method makeMappings.
@Test
@Ignore
public void makeMappings() throws IOException {
InjectionModscript mod = Injection.load(MappingImporter.class.getResourceAsStream(RL_INJECTION));
int fields = 0, classes = 0;
for (int i = 0; i < mod.getGetterInjects().size(); ++i) {
GetterInjectInstruction gii = (GetterInjectInstruction) mod.getGetterInjects().get(i);
ClassFile cf = this.findClassWithObfuscatedName(gii.getGetterClassName());
Assert.assertNotNull(cf);
Field f = this.findFieldWithObfuscatedName(cf, gii.getGetterFieldName());
if (f == null) {
// so they don't all exist
continue;
}
String attrName = gii.getGetterName();
attrName = Utils.toExportedName(attrName);
Annotations an = f.getAnnotations();
Annotation a = an.find(EXPORT);
if (a != null) {
String exportedName = a.getElement().getString();
if (!attrName.equals(exportedName)) {
logger.info("Exported field " + f + " with mismatched name. Theirs: " + attrName + ", mine: " + exportedName);
}
} else {
an.addAnnotation(EXPORT, "value", attrName);
logger.info("Exporting field " + f + " with name " + attrName);
++fields;
}
}
for (AddInterfaceInstruction aii : mod.getAddInterfaceInjects()) {
ClassFile cf = this.findClassWithObfuscatedName(aii.getClientClass());
Assert.assertNotNull(cf);
String iface = aii.getInterfaceClass();
iface = iface.replace("com/runeloader/api/bridge/os/accessor/", "");
Annotations an = cf.getAnnotations();
Annotation a = an.find(IMPLEMENTS);
if (a != null) {
String implementsName = a.getElement().getString();
if (!iface.equals(implementsName)) {
logger.info("Implements class " + cf + " with mismatched name. Theirs: " + iface + ", mine: " + implementsName);
}
} else {
an.addAnnotation(IMPLEMENTS, "value", iface);
logger.info("Exporting class " + cf.getName() + " with name " + iface);
++classes;
}
}
logger.info("Added {} fields, {} classes", fields, classes);
}
use of net.runelite.asm.ClassFile in project runelite by runelite.
the class TestingClassLoader method findClass.
@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
ClassFile cf = group.findClass(name);
if (cf == null) {
return super.findClass(name);
}
Class<?> c = classes.get(name);
if (c != null) {
return c;
}
byte[] clazz = JarUtil.writeClass(group, cf);
return defineClass(name, clazz);
}
use of net.runelite.asm.ClassFile in project runelite by runelite.
the class DrawAfterWidgets method injectDrawAfterWidgets.
private void injectDrawAfterWidgets() throws InjectionException {
/*
This call has to be injected using raw injection because the
drawWidgets method gets inlined in some revisions. If it wouldn't be,
mixins would be used to add the call to the end of drawWidgets.
--> This hook depends on the positions of "if (535573958 * kl != -1)" and "jz.db();".
Revision 153 - client.ll():
______________________________________________________
if (535573958 * kl != -1) {
me = 0;
var1 = kl * 1593233303;
var2 = 523525871 * q;
var3 = -1668171507 * h.n;
if (!bo.p(var1, (byte)111)) {
for(var4 = 0; var4 < 100; ++var4) {
mb[var4] = true;
}
} else {
z.lj = null;
bl.hz(fa.g[var1], -1, 0, 0, var2, var3, 0, 0, -1, 1505114436);
if (z.lj != null) {
bl.hz(z.lj, -1412584499, 0, 0, var2, var3, 1475313862 * bq.la, aq.lc * 1205565233, -1, 2123188146);
z.lj = null;
}
}
}
// <-- INJECT CALL HERE
jz.db(); <-- noClip method
______________________________________________________
*/
boolean injected = false;
Method noClip = findStaticMethod("noClip");
if (noClip == null) {
throw new InjectionException("Mapped method \"noClip\" could not be found.");
}
net.runelite.asm.pool.Method poolNoClip = noClip.getPoolMethod();
for (ClassFile c : inject.getVanilla().getClasses()) {
for (Method m : c.getMethods()) {
if (m.getCode() == null) {
continue;
}
Instructions instructions = m.getCode().getInstructions();
Set<Label> labels = new HashSet<>();
// Let's find "invokestatic <some class>.noClip()" and its label
ListIterator<Instruction> labelIterator = instructions.getInstructions().listIterator();
while (labelIterator.hasNext()) {
Instruction i = labelIterator.next();
if (!(i instanceof InvokeStatic)) {
continue;
}
InvokeStatic is = (InvokeStatic) i;
if (!is.getMethod().equals(poolNoClip)) {
continue;
}
labelIterator.previous();
Instruction i2 = labelIterator.previous();
labelIterator.next();
labelIterator.next();
// Find the label that marks the code path for the instruction
if (!(i2 instanceof Label)) {
continue;
}
// There can be several noClip invocations in a method, so let's catch them all
labels.add((Label) i2);
}
if (labels.isEmpty()) {
// If we get here, we're either in the wrong method
// or Jagex has removed the "if (535573958 * kl != -1)"
logger.debug("Could not find the label for jumping to the " + noClip + " call in " + m);
continue;
}
Set<Label> labelsToInjectAfter = new HashSet<>();
ListIterator<Instruction> jumpIterator = instructions.getInstructions().listIterator();
while (jumpIterator.hasNext()) {
Instruction i = jumpIterator.next();
if (!(i instanceof JumpingInstruction)) {
continue;
}
JumpingInstruction ji = (JumpingInstruction) i;
Label label = null;
for (Label l : labels) {
if (ji.getJumps().contains(l)) {
label = l;
break;
}
}
if (label == null) {
continue;
}
jumpIterator.previous();
Set<Instruction> insns = new HashSet<>();
insns.add(jumpIterator.previous());
insns.add(jumpIterator.previous());
insns.add(jumpIterator.previous());
insns.add(jumpIterator.previous());
// Get the iterator back to i's position
jumpIterator.next();
jumpIterator.next();
jumpIterator.next();
jumpIterator.next();
jumpIterator.next();
/*
Check that these instruction types are passed into the if-statement:
ICONST_M1
GETSTATIC client.kr : I
LDC 634425425
IMUL
We cannot depend on the order of these because of the obfuscation,
so let's make it easier by just checking that they are there.
*/
if (insns.stream().filter(i2 -> i2 instanceof PushConstantInstruction).count() != 2 || insns.stream().filter(i2 -> i2 instanceof IMul).count() != 1 || insns.stream().filter(i2 -> i2 instanceof GetStatic).count() != 1) {
continue;
}
// At this point, we have found the real injection point
labelsToInjectAfter.add(label);
}
for (Label l : labelsToInjectAfter) {
InvokeStatic invoke = new InvokeStatic(instructions, new net.runelite.asm.pool.Method(new net.runelite.asm.pool.Class(HOOKS), "drawAfterWidgets", new Signature("()V")));
instructions.addInstruction(instructions.getInstructions().indexOf(l) + 1, invoke);
logger.info("injectDrawAfterWidgets injected a call after " + l);
injected = true;
}
}
}
if (!injected) {
throw new InjectionException("injectDrawAfterWidgets failed to inject!");
}
}
use of net.runelite.asm.ClassFile in project runelite by runelite.
the class InjectConstructTest method testInjectConstruct.
@Test
public void testInjectConstruct() throws Exception {
ClassFile targetClass = new ClassFile();
targetClass.setName("test");
ClassFile vanillaClass = new ClassFile();
vanillaClass.setName("ab");
Method constructor = new Method(vanillaClass, "<init>", new Signature("()V"));
vanillaClass.addMethod(constructor);
Inject inject = mock(Inject.class);
when(inject.findVanillaForInterface(Matchers.any(Class.class))).thenReturn(vanillaClass);
InjectConstruct injectConstruct = new InjectConstruct(inject);
injectConstruct.injectConstruct(targetClass, APIClass.class.getDeclaredMethod("create"));
assertNotNull(targetClass.findMethod("create"));
}
Aggregations