ASM Fix其他方法/方法调用

Question

I'm currently working at obfuscation stuff with ASM and need some help at that:

My current code is:

public void renameMethods()
    {
        Map<String, byte[]> generatedOutput = new HashMap<>();

        for (ClassNode classNode : classes.values())
        {
            ClassWriter classWriter = new ClassWriter(0);
            ClassVisitor classVisitor = new ClassVisitor(ASM4, classWriter)
            {
                @Override
                public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions)
                {
                    if (name.equals("getToken") && desc.equals("(I)Ljava/lang/String;"))
                    {
                        return super.visitMethod(access, "func_001", desc, signature, exceptions);
                    }
                    return super.visitMethod(access, name, desc, signature, exceptions);
                }
            };
            classNode.accept(classVisitor);
            generatedOutput.put(classNode.name, classWriter.toByteArray());
        }

        JarUtils.saveAsJar(out, outputJar.getAbsolutePath());
    }

I'm renaming a Method, which returns an String, called "getToken" to "func_001"! This works great. But in an another Class im calling the Method, and there the Method isn't renamed. So I need some help to fix that.

Answer 1

You need to visit all classes twice:

In the first round visit only obtain a list of method names and descriptors (guaranteed to be unique in each scope).

This implementation will give the same name to the methods with the same name and description in different classes. This may not be optimal obfuscation-wise but it avoids differentiating between overridden methods and methods that just happen to be called the same.

final List<String> methods = new ArrayList<>();
for (ClassNode classNode : classes.values()) {
    for (MethodNode methodNode : classNode.methods) {
        methods.add(methodNode.name + methodNode.desc);
    }
}

The visitor is not connected to the writer, because no modification has been done yet.

Then map each name to a new obfuscated name (maybe random numbers or just number the methods):

final Map<String, String> map = new HashMap<>();
for (int i = 0; i < methods.size(); i++) {
    String obfName = String.format("func_%03d", i);
    map.put(methods.get(i), obfName);
}

Finally, visit each method body to edit each method call instruction accordingly and save the modified result.

for (ClassNode classNode : classes.values()) {
    ClassWriter classWriter = new ClassWriter(0);
    ClassVisitor visitor = new ClassVisitor(ASM4, classWriter) {
        @Override
        public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
            final MethodVisitor mv = super.methodVisitor(access, name, desc, signature, exceptions);
            return new AdviceAdapter(ASM4, mv, access, name, desc) {
                @Override
                public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
                    String newName = map.getOrDefault(name + desc, name);
                    return super.visitMethodInsn(opcode, owner, newName, desc, itf);
                }
            };
        }
    };
    classNode.accept(classVisitor);
    generatedOutput.put(classNode.name, classWriter.toByteArray());
}

Note : you will have problems with overridden methods from classes that you are not modifying such as String toString() from Object or any other from Java or external libraries. To avoid this, you could either have a whitelist of the methods you want to obfuscate, read the annotations to detect overridden methods and skip them, for example.