loerting/threadtearSuite d'outils multifonctionnelle de désobfuscation Java
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.
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.
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.
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.
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.
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);
// rewrite method instructions
for (int i = 0; i < m.instructions.size(); i++) {
AbstractInsnNode ain = m.instructions.get(i);
Frame<ConstantValue> frame = frames[i];
// replace / modify instructions, etc...
if (frame.getStackSize() > 0) {
ConstantValue top = frame.getStack(frame.getStackSize() - 1);
if (top.isKnown() && top.isInteger()) {
int knownTopStackValue = top.getInteger();
// use the known stack to remove jumps, simplify code, etc...
// if(...) { rewrittenCode.add(...); }
continue;
}
}
rewrittenCode.add(ain.clone(labels));
}
// update instructions and fix try catch blocks, local variables, etc...
Instructions.updateInstructions(m, labels, rewrittenCode);
});
}
/**
* Use this method to predict stack values if fields are loaded
*/
@Override
public Object getFieldValueOrNull(BasicValue v, String owner, String name, String desc) {
return null;
}
/**
* Use this method to predict stack values if methods are invoked on known objects
*/
@Override
public Object getMethodReturnOrNull(BasicValue v, String owner, String name, String desc, List<? extends ConstantValue> values) {
if (name.equals("toCharArray") && owner.equals("java/lang/String")) {
if (!values.get(0).isKnown()) {
// invocation target is not known, we can't compute the return
return null;
}
return ((String) values.get(0).getValue()).toCharArray();
}
return null;
}
}
N'oubliez pas d'ajouter votre exécution à l'arbre dans me.nov.threadtear.execution.ExecutionLink!
Il existe quelques astuces qui peuvent vous aider à identifier et désobfusquer avec succès des fichiers jar. Avant d'exécuter des exécutions, décompilez le code pour découvrir ce qui doit être utilisé. Vous pouvez utiliser le décompilateur intégré pour cela.
Le meilleur ordre pour une désobfuscation est « exécutions génériques > désobfuscation d'accès > désobfuscation de chaînes > exécutions de nettoyage ».
Les obfuscateurs présentent des motifs que vous pouvez utiliser pour les identifier. Le moyen le plus simple d'identifier un obfuscateur est de parcourir le fichier META-INF/MANIFEST.MF.
Il est possible qu'il y ait un attribut Obfuscated-By: XXX ou Protected-By: XXX.
Code extrêmement obfusqué (notamment au niveau du flux), souvent reconnaissable par une méthode de déchiffrement de chaînes dans l'initialiseur statique contenant des switchs,
ou des méthodes de déchiffrement de chaînes avec un très long bloc switch (environ 250 cas).
ZKM est l'un des meilleurs (et des plus anciens) obfuscateurs pour Java, et très cher. Aussi ancien que l'obfuscateur est leur site web.
Si votre fichier jar contient des classes spéciales avec d'énormes algorithmes de déchiffrement utilisés par l'obfuscation de chaînes et l'obfuscation d'accès, il s'agit probablement de Stringer.
La protection n'est pas mauvaise et Stringer est l'un des obfuscateurs les plus chers. Contrairement aux obfuscateurs normaux, il n'inclut pas d'obfuscation des noms.
Il est plutôt utilisé comme « deuxième couche ». Probablement 90% des personnes qui utilisent cet obfuscateur utilisent une crack, car il coûte plus qu'une voiture.
Si votre fichier a été obfusqué avec plusieurs obfuscateurs, et que Stringer en fait partie, vous devriez commencer votre désobfuscation par Stringer, car l'obfuscation Stringer ne peut pas être écrasée.
(En raison de la signature JAR personnalisée et de l'utilisation des noms de méthodes lors du déchiffrement des chaînes)
Des noms de classe comme IiIlIlIiIl ou aUx, cOn, PrX indiquent une obfuscation Allatori.
Allatori est très courant parmi les fichiers jar obfusqués, car il propose une démo gratuite accessible en quelques clics. L'obfuscation n'est pas très difficile à inverser.
Paramorphism est comme le petit frère de Stringer, car il lui ressemble, mais n'est pas aussi bon. Il possède également certaines fonctionnalités intéressantes qui visent à faire planter les outils de rétro-ingénierie, et qui peuvent être facilement supprimées.
La force de l'obfuscation est comparable à celle d'Allatori.
Pour d'autres obfuscateurs, vous pouvez essayer les exécutions génériques ou ouvrir un ticket, et je verrai ce que je peux faire.
Avant de sélectionner une exécution, consultez les infobulles lorsque vous survolez. Elles contiennent une petite description de ce qu'elles font, mais aussi des tags qui vous aident à comprendre comment le comportement de votre fichier JAR sera modifié.
Threadtear est sous licence GNU General Public License 3.0
Cet outil a représenté énormément de travail. Si je vous ai fait gagner du temps, et que vous souhaitez me payer un café, vous pouvez le faire ici : Donate with Bitcoin
Utilisez Threadtear uniquement à des fins légales. Threadtear n'a pas pour objectif d'être un outil de cracking, mais plutôt une boîte à outils d'analyse de logiciels malveillants.
Veuillez ouvrir un ticket ou m'envoyer un e-mail si un transformateur ne fonctionne pas correctement et joignez le journal.
Notez que les fichiers de sortie ne sont très probablement pas exécutables. Si vous souhaitez tout de même essayer de les exécuter, utilisez -noverify comme argument JVM !
Cet outil est destiné à être utilisé avec Java 8, mais il fonctionnera probablement aussi sur des versions ultérieures.