forked from openrs2/openrs2
This change paves the way to feed the NameMap into the TypedRemapper, such that refactored names (and static member movements) are preserved across deobfuscator runs. Signed-off-by: Graham <gpe@openrs2.dev>
parent
cccbbe4d19
commit
7d9b1c61e8
@ -0,0 +1,219 @@ |
||||
package dev.openrs2.asm.classpath |
||||
|
||||
import dev.openrs2.asm.ClassVersionUtils |
||||
import dev.openrs2.asm.MemberRef |
||||
import dev.openrs2.asm.remap |
||||
import org.objectweb.asm.Opcodes |
||||
import org.objectweb.asm.tree.ClassNode |
||||
import org.objectweb.asm.tree.FieldInsnNode |
||||
import org.objectweb.asm.tree.FieldNode |
||||
import org.objectweb.asm.tree.InsnList |
||||
import org.objectweb.asm.tree.InsnNode |
||||
import org.objectweb.asm.tree.MethodNode |
||||
import java.util.SortedMap |
||||
import java.util.TreeMap |
||||
import kotlin.math.max |
||||
|
||||
class LibraryRemapper( |
||||
private val remapper: ExtendedRemapper, |
||||
private var classes: SortedMap<String, ClassNode> |
||||
) { |
||||
private class Initializer(val instructions: InsnList, val maxStack: Int) { |
||||
val dependencies = instructions.asSequence() |
||||
.filterIsInstance<FieldInsnNode>() |
||||
.filter { it.opcode == Opcodes.GETSTATIC } |
||||
.map(::MemberRef) |
||||
.toSet() |
||||
} |
||||
|
||||
private class Field(val owner: String, val node: FieldNode, val version: Int, val initializer: Initializer?) |
||||
private class Method(val owner: String, val node: MethodNode, val version: Int) |
||||
|
||||
private val fields = mutableMapOf<MemberRef, Field>() |
||||
private val splicedFields = mutableSetOf<MemberRef>() |
||||
private val methods = mutableListOf<Method>() |
||||
|
||||
fun remap(): SortedMap<String, ClassNode> { |
||||
// extract static fields/methods that are being moved between classes |
||||
extractFields() |
||||
extractMethods() |
||||
|
||||
// map remaining fields/methods |
||||
for (clazz in classes.values) { |
||||
clazz.remap(remapper) |
||||
} |
||||
|
||||
classes = classes.mapKeysTo(TreeMap()) { (_, clazz) -> clazz.name } |
||||
|
||||
// splice static fields/methods into their new classes |
||||
spliceFields() |
||||
spliceMethods() |
||||
|
||||
// remove empty <clinit> methods (so EmptyClassTransformer works later) |
||||
removeEmptyClinitMethods() |
||||
|
||||
return classes |
||||
} |
||||
|
||||
private fun extractFields() { |
||||
for (clazz in classes.values) { |
||||
clazz.fields.removeIf { field -> |
||||
// do nothing if the field is not moved between classes |
||||
val oldOwner = remapper.mapType(clazz.name) |
||||
val newOwner = remapper.mapFieldOwner(clazz.name, field.name, field.desc) |
||||
if (oldOwner == newOwner) { |
||||
return@removeIf false |
||||
} |
||||
|
||||
/* |
||||
* Remove the initializer (if present) from the old owner's |
||||
* <clinit> method. |
||||
*/ |
||||
val initializer = extractInitializer(clazz, field) |
||||
|
||||
/* |
||||
* Map the field (it won't be caught by a ClassNode::remap call |
||||
* during the main pass). |
||||
*/ |
||||
field.remap(remapper, clazz.name) |
||||
|
||||
/* |
||||
* Store the field so it can be spliced into its new class |
||||
* later. We key on the new owner/name/descriptor, rather than |
||||
* the old one, as spliceFields's dependency tracking runs |
||||
* after the Initializer::dependencies has been mapped. |
||||
*/ |
||||
val newMember = MemberRef(newOwner, field.name, field.desc) |
||||
fields[newMember] = Field(newOwner, field, clazz.version, initializer) |
||||
|
||||
// remove the field from its old class |
||||
return@removeIf true |
||||
} |
||||
} |
||||
} |
||||
|
||||
private fun extractInitializer(clazz: ClassNode, field: FieldNode): Initializer? { |
||||
val clinit = clazz.methods.find { it.name == "<clinit>" } ?: return null |
||||
val initializer = remapper.getFieldInitializer(clazz.name, field.name, field.desc) ?: return null |
||||
|
||||
val list = InsnList() |
||||
for (insn in initializer) { |
||||
/* |
||||
* Remove initializer from <clinit>. It is stored alongside the |
||||
* FieldNode so it can be spliced into its new class later. |
||||
*/ |
||||
clinit.instructions.remove(insn) |
||||
list.add(insn) |
||||
|
||||
/* |
||||
* Remap the initializer (it won't be caught by a ClassNode::remap |
||||
* call during the main pass). |
||||
*/ |
||||
insn.remap(remapper) |
||||
} |
||||
|
||||
return Initializer(list, clinit.maxStack) |
||||
} |
||||
|
||||
private fun extractMethods() { |
||||
for (clazz in classes.values) { |
||||
clazz.methods.removeIf { method -> |
||||
// do nothing if the method is not moved between classes |
||||
val oldOwner = remapper.mapType(clazz.name) |
||||
val newOwner = remapper.mapMethodOwner(clazz.name, method.name, method.desc) |
||||
if (oldOwner == newOwner) { |
||||
return@removeIf false |
||||
} |
||||
|
||||
/* |
||||
* Map the method (it won't be caught by a ClassNode::remap call |
||||
* during the main pass). |
||||
*/ |
||||
method.remap(remapper, clazz.name) |
||||
|
||||
// store the method |
||||
methods += Method(newOwner, method, clazz.version) |
||||
|
||||
// remove the method from its old class |
||||
return@removeIf true |
||||
} |
||||
} |
||||
} |
||||
|
||||
private fun spliceFields() { |
||||
for (member in fields.keys) { |
||||
spliceField(member) |
||||
} |
||||
} |
||||
|
||||
private fun spliceField(member: MemberRef) { |
||||
if (!splicedFields.add(member)) { |
||||
return |
||||
} |
||||
|
||||
val field = fields[member] ?: return |
||||
val clazz = classes.computeIfAbsent(field.owner, ::createClass) |
||||
|
||||
if (field.initializer != null) { |
||||
for (dependency in field.initializer.dependencies) { |
||||
spliceField(dependency) |
||||
} |
||||
|
||||
val clinit = clazz.methods.find { it.name == "<clinit>" } ?: createClinitMethod(clazz) |
||||
// TODO(gpe): check the <clinit> method only has a single RETURN and that it is the last instruction |
||||
clinit.maxStack = max(clinit.maxStack, field.initializer.maxStack) |
||||
clinit.instructions.insertBefore(clinit.instructions.last, field.initializer.instructions) |
||||
} |
||||
|
||||
clazz.version = ClassVersionUtils.max(clazz.version, field.version) |
||||
clazz.fields.add(field.node) |
||||
} |
||||
|
||||
private fun spliceMethods() { |
||||
for (method in methods) { |
||||
val clazz = classes.computeIfAbsent(method.owner, ::createClass) |
||||
clazz.version = ClassVersionUtils.max(clazz.version, method.version) |
||||
clazz.methods.add(method.node) |
||||
} |
||||
} |
||||
|
||||
private fun removeEmptyClinitMethods() { |
||||
for (clazz in classes.values) { |
||||
val clinit = clazz.methods.find { it.name == "<clinit>" } ?: continue |
||||
|
||||
val first = clinit.instructions.firstOrNull { it.opcode != -1 } |
||||
if (first != null && first.opcode == Opcodes.RETURN) { |
||||
clazz.methods.remove(clinit) |
||||
} |
||||
} |
||||
} |
||||
|
||||
private fun createClass(name: String): ClassNode { |
||||
val clazz = ClassNode() |
||||
clazz.version = Opcodes.V1_1 |
||||
clazz.access = Opcodes.ACC_PUBLIC or Opcodes.ACC_SUPER or Opcodes.ACC_FINAL |
||||
clazz.name = name |
||||
clazz.superName = "java/lang/Object" |
||||
clazz.interfaces = mutableListOf() |
||||
clazz.innerClasses = mutableListOf() |
||||
clazz.fields = mutableListOf() |
||||
clazz.methods = mutableListOf() |
||||
return clazz |
||||
} |
||||
|
||||
private fun createClinitMethod(clazz: ClassNode): MethodNode { |
||||
val clinit = MethodNode() |
||||
clinit.access = Opcodes.ACC_STATIC |
||||
clinit.name = "<clinit>" |
||||
clinit.desc = "()V" |
||||
clinit.exceptions = mutableListOf() |
||||
clinit.parameters = mutableListOf() |
||||
clinit.instructions = InsnList() |
||||
clinit.instructions.add(InsnNode(Opcodes.RETURN)) |
||||
clinit.tryCatchBlocks = mutableListOf() |
||||
|
||||
clazz.methods.add(clinit) |
||||
|
||||
return clinit |
||||
} |
||||
} |
||||
@ -1,276 +0,0 @@ |
||||
package dev.openrs2.deob.transform |
||||
|
||||
import com.github.michaelbull.logging.InlineLogger |
||||
import dev.openrs2.asm.ClassVersionUtils |
||||
import dev.openrs2.asm.MemberDesc |
||||
import dev.openrs2.asm.MemberRef |
||||
import dev.openrs2.asm.classpath.ClassPath |
||||
import dev.openrs2.asm.classpath.Library |
||||
import dev.openrs2.asm.getExpression |
||||
import dev.openrs2.asm.isSequential |
||||
import dev.openrs2.asm.transform.Transformer |
||||
import dev.openrs2.deob.Profile |
||||
import dev.openrs2.util.collect.DisjointSet |
||||
import org.objectweb.asm.Opcodes |
||||
import org.objectweb.asm.tree.AbstractInsnNode |
||||
import org.objectweb.asm.tree.ClassNode |
||||
import org.objectweb.asm.tree.FieldInsnNode |
||||
import org.objectweb.asm.tree.FieldNode |
||||
import org.objectweb.asm.tree.InsnList |
||||
import org.objectweb.asm.tree.InsnNode |
||||
import org.objectweb.asm.tree.MethodInsnNode |
||||
import org.objectweb.asm.tree.MethodNode |
||||
import javax.inject.Inject |
||||
import javax.inject.Singleton |
||||
import kotlin.math.max |
||||
|
||||
@Singleton |
||||
class StaticScramblingTransformer @Inject constructor(private val profile: Profile) : Transformer() { |
||||
private data class Field(val node: FieldNode, val initializer: InsnList, val version: Int, val maxStack: Int) { |
||||
val dependencies = initializer.asSequence() |
||||
.filterIsInstance<FieldInsnNode>() |
||||
.filter { it.opcode == Opcodes.GETSTATIC } |
||||
.map(::MemberRef) |
||||
.toSet() |
||||
} |
||||
|
||||
private lateinit var inheritedFieldSets: DisjointSet<MemberRef> |
||||
private lateinit var inheritedMethodSets: DisjointSet<MemberRef> |
||||
private val fields = mutableMapOf<DisjointSet.Partition<MemberRef>, Field>() |
||||
private val fieldClasses = mutableMapOf<DisjointSet.Partition<MemberRef>, String>() |
||||
private val methodClasses = mutableMapOf<DisjointSet.Partition<MemberRef>, String>() |
||||
private var nextStaticClass: ClassNode? = null |
||||
private var nextClinit: MethodNode? = null |
||||
private val staticClasses = mutableListOf<ClassNode>() |
||||
|
||||
private fun nextClass(): Pair<ClassNode, MethodNode> { |
||||
var clazz = nextStaticClass |
||||
if (clazz != null && clazz.fields.size < MAX_FIELDS && clazz.methods.size < MAX_METHODS) { |
||||
return Pair(clazz, nextClinit!!) |
||||
} |
||||
|
||||
val clinit = MethodNode() |
||||
clinit.access = Opcodes.ACC_STATIC |
||||
clinit.name = "<clinit>" |
||||
clinit.desc = "()V" |
||||
clinit.exceptions = mutableListOf() |
||||
clinit.parameters = mutableListOf() |
||||
clinit.instructions = InsnList() |
||||
clinit.instructions.add(InsnNode(Opcodes.RETURN)) |
||||
clinit.tryCatchBlocks = mutableListOf() |
||||
|
||||
clazz = ClassNode() |
||||
clazz.version = Opcodes.V1_1 |
||||
clazz.access = Opcodes.ACC_PUBLIC or Opcodes.ACC_SUPER or Opcodes.ACC_FINAL |
||||
clazz.name = "Static${staticClasses.size + 1}" |
||||
clazz.superName = "java/lang/Object" |
||||
clazz.interfaces = mutableListOf() |
||||
clazz.innerClasses = mutableListOf() |
||||
clazz.fields = mutableListOf() |
||||
clazz.methods = mutableListOf(clinit) |
||||
|
||||
staticClasses += clazz |
||||
nextStaticClass = clazz |
||||
nextClinit = clinit |
||||
|
||||
return Pair(clazz, clinit) |
||||
} |
||||
|
||||
private fun MethodNode.extractEntryExitBlocks(): List<AbstractInsnNode> { |
||||
/* |
||||
* Most (or all?) of the <clinit> methods have "simple" initializers |
||||
* that we're capable of moving in the first and last basic blocks of |
||||
* the method. The last basic block is always at the end of the code |
||||
* and ends in a RETURN. This allows us to avoid worrying about making |
||||
* a full basic block control flow graph here. |
||||
*/ |
||||
val entry = instructions.takeWhile { it.isSequential } |
||||
|
||||
val last = instructions.lastOrNull() |
||||
if (last == null || last.opcode != Opcodes.RETURN) { |
||||
return entry |
||||
} |
||||
|
||||
val exit = instructions.toList() |
||||
.dropLast(1) |
||||
.takeLastWhile { it.isSequential } |
||||
|
||||
return entry.plus(exit) |
||||
} |
||||
|
||||
private fun MethodNode.extractInitializers(owner: String): Pair<Map<MemberDesc, InsnList>, Set<MemberDesc>> { |
||||
val entryExitBlocks = extractEntryExitBlocks() |
||||
|
||||
val simpleInitializers = mutableMapOf<MemberDesc, InsnList>() |
||||
val complexInitializers = instructions.asSequence() |
||||
.filter { !entryExitBlocks.contains(it) } |
||||
.filterIsInstance<FieldInsnNode>() |
||||
.filter { it.opcode == Opcodes.GETSTATIC && it.owner == owner } |
||||
.filter { !profile.excludedFields.matches(it.owner, it.name, it.desc) } |
||||
.map(::MemberDesc) |
||||
.toSet() |
||||
|
||||
val putstatics = entryExitBlocks |
||||
.filterIsInstance<FieldInsnNode>() |
||||
.filter { it.opcode == Opcodes.PUTSTATIC && it.owner == owner } |
||||
.filter { !profile.excludedFields.matches(it.owner, it.name, it.desc) } |
||||
|
||||
for (putstatic in putstatics) { |
||||
val desc = MemberDesc(putstatic) |
||||
if (simpleInitializers.containsKey(desc) || complexInitializers.contains(desc)) { |
||||
continue |
||||
} |
||||
|
||||
// TODO(gpe): use a filter here (pure with no *LOADs?) |
||||
val expr = getExpression(putstatic) ?: continue |
||||
|
||||
val initializer = InsnList() |
||||
for (insn in expr) { |
||||
instructions.remove(insn) |
||||
initializer.add(insn) |
||||
} |
||||
instructions.remove(putstatic) |
||||
initializer.add(putstatic) |
||||
|
||||
simpleInitializers[desc] = initializer |
||||
} |
||||
|
||||
return Pair(simpleInitializers, complexInitializers) |
||||
} |
||||
|
||||
private fun spliceInitializers() { |
||||
val done = mutableSetOf<DisjointSet.Partition<MemberRef>>() |
||||
for ((partition, field) in fields) { |
||||
spliceInitializers(done, partition, field) |
||||
} |
||||
} |
||||
|
||||
private fun spliceInitializers( |
||||
done: MutableSet<DisjointSet.Partition<MemberRef>>, |
||||
partition: DisjointSet.Partition<MemberRef>, |
||||
field: Field |
||||
) { |
||||
if (!done.add(partition)) { |
||||
return |
||||
} |
||||
|
||||
for (dependency in field.dependencies) { |
||||
val dependencyPartition = inheritedFieldSets[dependency]!! |
||||
val dependencyField = fields[dependencyPartition] ?: continue |
||||
spliceInitializers(done, partition, dependencyField) |
||||
} |
||||
|
||||
val (staticClass, clinit) = nextClass() |
||||
staticClass.fields.add(field.node) |
||||
staticClass.version = ClassVersionUtils.max(staticClass.version, field.version) |
||||
clinit.instructions.insertBefore(clinit.instructions.last, field.initializer) |
||||
clinit.maxStack = max(clinit.maxStack, field.maxStack) |
||||
|
||||
fieldClasses[partition] = staticClass.name |
||||
} |
||||
|
||||
override fun preTransform(classPath: ClassPath) { |
||||
inheritedFieldSets = classPath.createInheritedFieldSets() |
||||
inheritedMethodSets = classPath.createInheritedMethodSets() |
||||
fields.clear() |
||||
fieldClasses.clear() |
||||
methodClasses.clear() |
||||
nextStaticClass = null |
||||
staticClasses.clear() |
||||
|
||||
for (library in classPath.libraries) { |
||||
// TODO(gpe): improve detection of the client library |
||||
if ("client" !in library) { |
||||
continue |
||||
} |
||||
|
||||
for (clazz in library) { |
||||
// TODO(gpe): exclude the JSObject class |
||||
|
||||
val clinit = clazz.methods.find { it.name == "<clinit>" } |
||||
val (simpleInitializers, complexInitializers) = clinit?.extractInitializers(clazz.name) |
||||
?: Pair(emptyMap(), emptySet()) |
||||
|
||||
clazz.fields.removeIf { field -> |
||||
if (field.access and Opcodes.ACC_STATIC == 0) { |
||||
return@removeIf false |
||||
} else if (profile.excludedFields.matches(clazz.name, field.name, field.desc)) { |
||||
return@removeIf false |
||||
} |
||||
|
||||
val desc = MemberDesc(field) |
||||
if (complexInitializers.contains(desc)) { |
||||
return@removeIf false |
||||
} |
||||
|
||||
val initializer = simpleInitializers[desc] ?: InsnList() |
||||
val maxStack = clinit?.maxStack ?: 0 |
||||
|
||||
val partition = inheritedFieldSets[MemberRef(clazz, field)]!! |
||||
fields[partition] = Field(field, initializer, clazz.version, maxStack) |
||||
return@removeIf true |
||||
} |
||||
|
||||
clazz.methods.removeIf { method -> |
||||
if (method.access and Opcodes.ACC_STATIC == 0) { |
||||
return@removeIf false |
||||
} else if (method.access and Opcodes.ACC_NATIVE != 0) { |
||||
return@removeIf false |
||||
} else if (profile.excludedMethods.matches(clazz.name, method.name, method.desc)) { |
||||
return@removeIf false |
||||
} |
||||
|
||||
val (staticClass, _) = nextClass() |
||||
staticClass.methods.add(method) |
||||
staticClass.version = ClassVersionUtils.max(staticClass.version, clazz.version) |
||||
|
||||
val partition = inheritedMethodSets[MemberRef(clazz, method)]!! |
||||
methodClasses[partition] = staticClass.name |
||||
return@removeIf true |
||||
} |
||||
|
||||
val first = clinit?.instructions?.firstOrNull { it.opcode != -1 } |
||||
if (first != null && first.opcode == Opcodes.RETURN) { |
||||
clazz.methods.remove(clinit) |
||||
} |
||||
} |
||||
|
||||
spliceInitializers() |
||||
|
||||
for (clazz in staticClasses) { |
||||
library.add(clazz) |
||||
} |
||||
} |
||||
} |
||||
|
||||
override fun transformCode(classPath: ClassPath, library: Library, clazz: ClassNode, method: MethodNode): Boolean { |
||||
for (insn in method.instructions) { |
||||
when (insn) { |
||||
is FieldInsnNode -> { |
||||
val partition = inheritedFieldSets[MemberRef(insn)] |
||||
if (partition != null) { |
||||
insn.owner = fieldClasses.getOrDefault(partition, insn.owner) |
||||
} |
||||
} |
||||
is MethodInsnNode -> { |
||||
val partition = inheritedMethodSets[MemberRef(insn)] |
||||
if (partition != null) { |
||||
insn.owner = methodClasses.getOrDefault(partition, insn.owner) |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
return false |
||||
} |
||||
|
||||
override fun postTransform(classPath: ClassPath) { |
||||
logger.info { "Moved ${fieldClasses.size} fields and ${methodClasses.size} methods" } |
||||
} |
||||
|
||||
private companion object { |
||||
private val logger = InlineLogger() |
||||
private const val MAX_FIELDS = 500 |
||||
private const val MAX_METHODS = 50 |
||||
} |
||||
} |
||||
Loading…
Reference in new issue