Threadtear

Threadtear est un outil de désobfuscation multifonctionnel pour Java. Le support des applications Android arrive bientôt (je travaille actuellement sur un convertisseur dalvik vers java). Idéal pour une analyse de code plus facile sans trop se soucier de l'obfuscation. Même les obfuscateurs les plus chers comme ZKM ou Stringer sont inclus. Pour faciliter le débogage, d'autres outils sont fournis. Insérez des numéros de ligne de débogage pour mieux comprendre d'où proviennent les exceptions, ou ajoutez .printStackTrace() aux blocs try-catch sans recompiler votre code. La rétrocompatibilité n'est plus un problème si aucune méthode spécifique à une version n'est utilisée. Analysez le flux de code dans un graphe pour mieux comprendre les algorithmes.

Exécutions

Une « exécution » est une tâche qui est exécutée et modifie tous les fichiers de classe chargés. Il existe plusieurs types d'exécutions, allant du nettoyage du bytecode à la désobfuscation de chaînes. Assurez-vous de les avoir dans le bon ordre. Les exécutions de nettoyage, par exemple, doivent être exécutées en dernier, mais elles peuvent aussi aider d'autres exécutions si elles sont exécutées en premier. Lorsque vous êtes prêt, cliquez sur le bouton « Run », et elles seront exécutées dans l'ordre.

Avertissement

Utilisez cet outil à vos risques et périls. Certaines exécutions utilisent des ClassLoaders implémentés pour exécuter du code à partir du fichier jar. Un attaquant pourrait modifier le bytecode pour que du code malveillant soit exécuté. Les exécutions concernées utilisent la classe me.nov.threadtear.asm.vm.VM. Celles-ci sont principalement utilisées pour déchiffrer les chaînes ou désobfusquer les ressources/l'accès, car il est beaucoup plus facile d'exécuter les méthodes de déchiffrement à distance.

Sécurité

Threadtear fait de son mieux pour vous protéger des appels malveillants (exécutions de code arbitraire) en utilisant son propre SecurityManager, mais il n'y a aucune garantie. En particulier avec les désobfuscateurs comme ceux pour ZKM ou Stringer, vous devez être très prudent, car la réflexion doit être autorisée, sinon ils ne fonctionneraient pas. Si vous découvrez une ACE, veuillez ouvrir un ticket. J'essaierai de les corriger dès que possible.

Comment compiler

D'abord, exécutez gradle build, puis gradle fatJar. Dans builds/libs, un fichier jar exécutable devrait alors avoir été créé. Si vous ne souhaitez pas télécharger le dépôt, vous pouvez utiliser la dernière version publiée.

Créez votre propre exécution

Vous pouvez facilement créer votre propre tâche d'exécution. Il suffit d'étendre me.nov.threadtear.execution.Execution:

public class MyExecution extends Execution {
	public MyExecution() {
		super(ExecutionCategory.CLEANING /* category */, "My execution" /* name */,
				"Executes something" /* description, can use html */);
	}
	/**
	* This method is invoked when the user clicks on the Run button
	* @return true if success, false if failure
	*/
	@Override
	public boolean execute(Map<String, Clazz> classes, boolean verbose) {
		classes.values().stream().map(c -> c.node).forEach(c -> {
			//transform the classes here using the tree-API of ASM
		});
		return false;
	}
}

Pour charger des ClassNodes à l'exécution, utilisez la classe me.nov.threadtear.asm.vm.VM et implémentez me.nov.threadtear.asm.vm.IVMReferenceHandler:

public class MyExecution extends Execution implements IVMReferenceHandler {
	public MyExecution() {
		super(ExecutionCategory.GENERIC, "My execution", "Loads ClassNodes at runtime");
	}
	@Override
	public boolean execute(Map<String, Clazz> classes, boolean verbose) {
		classes.values().stream().map(c -> c.node).forEach(c -> {
			VM vm = VM.constructVM(this);
			//transform bytecode to java.lang.Class
			Class<?> loadedClass = vm.loadClass(c.name.replace('/', '.'), true);
			//do stuff with your class here
			loadedClass.getMethods()[0].invoke(...);
			return true;
		});
	}
	/**
	* Will get invoked by VM, when VM.loadClass is called
	*/
	@Override
	public ClassNode tryClassLoad(String name) {
		//try to find the class to be loaded in open jar archive
		return classes.containsKey(name) ? classes.get(name).node : null;
	}
}

En utilisant ConstantTracker (me.nov.threadtear.analysis.stack.ConstantTracker), vous pouvez analyser les méthodes et suivre les valeurs de pile non variables. Si, par exemple, iconst_0 est poussé sur la pile, la valeur elle-même n'est pas perdue comme dans l'analyseur ASM de base, et vous pouvez l'utiliser pour prédire des éléments ultérieurs dans le code.

public class MyExecution extends Execution implements IConstantReferenceHandler {
	public MyExecution() {
		super(ExecutionCategory.GENERIC, "My execution", "Performs stack analysis and replaces code.");
	}
	@Override
	public boolean execute(Map<String, Clazz> classes, boolean verbose) {
		classes.values().stream().map(c -> c.node).forEach(this::analyzeAndRewrite);
		return true;
	}
	public void analyzeAndRewrite(ClassNode cn) {
		cn.methods.forEach(m -> {
			// this analyzer keeps known stack values, e.g. can be useful for jump prediction
			Analyzer<ConstantValue> a = new Analyzer<ConstantValue>(new ConstantTracker(this, Access.isStatic(m.access), m.maxLocals, m.desc, new Object[0]));
			try {
				a.analyze(cn.name, m);
			} catch (AnalyzerException e) {
				logger.severe("Failed stack analysis in " + cn.name + "." + m.name + ":" + e.getMessage());
				return;
			}
			Frame<ConstantValue>[] frames = a.getFrames();
			InsnList rewrittenCode = new InsnList();
			Map<LabelNode, LabelNode> labels = Instructions.cloneLabels(m.instructions);