前言
Java 反编译,一听可能觉得高深莫测,其实反编译并不是什么特别高级的操作,Java 对于 Class 字节码文件的生成有着严格的要求,如果你非常熟悉 Java 虚拟机规范,了解 Class 字节码文件中一些字节的作用,那么理解反编译的原理并不是什么问题。甚至像下面这样的 Class 文件你都能看懂一二。
Jadx
GitHub 地址:https://github.com/skylot/jadx
Jadx 是一款可以反编译 JAR、APK、DEX、AAR、AAB、ZIP 文件的反编译工具,并且也配有 Jadx-gui 用于界面操作。Jadx 使用 Grade 进行依赖管理,可以自行克隆仓库打包运行。
git clone https://github.com/skylot/jadx.git
cd jadx
./gradlew dist
# 查看帮助
./build/jadx/bin/jadx --help
jadx - dex to java decompiler, version: dev
usage: jadx [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab)
options:
-d, --output-dir - output directory
-ds, --output-dir-src - output directory for sources
-dr, --output-dir-res - output directory for resources
-r, --no-res - do not decode resources
-s, --no-src - do not decompile source code
--single-class - decompile a single class
--output-format - can be \'java\' or \'json\', default: java
-e, --export-gradle - save as android gradle project
-j, --threads-count - processing threads count, default: 6
--show-bad-code - show inconsistent code (incorrectly decompiled)
--no-imports - disable use of imports, always write entire package name
--no-debug-info - disable debug info
--add-debug-lines - add comments with debug line numbers if available
--no-inline-anonymous - disable anonymous classes inline
--no-replace-consts - don\'t replace constant value with matching constant field
--escape-unicode - escape non latin characters in strings (with u)
--respect-bytecode-access-modifiers - don\'t change original access modifiers
--deobf - activate deobfuscation
--deobf-min - min length of name, renamed if shorter, default: 3
--deobf-max - max length of name, renamed if longer, default: 64
--deobf-cfg-file - deobfuscation map file, default: same dir and name as input file with \'.jobf\' extension
--deobf-rewrite-cfg - force to save deobfuscation map
--deobf-use-sourcename - use source file name as class name alias
--deobf-parse-kotlin-metadata - parse kotlin metadata to class and package names
--rename-flags - what to rename, comma-separated, \'case\' for system case sensitivity, \'valid\' for java identifiers, \'printable\' characters, \'none\' or \'all\' (default)
--fs-case-sensitive - treat filesystem as case sensitive, false by default
--cfg - save methods control flow graph to dot file
--raw-cfg - save methods control flow graph (use raw instructions)
-f, --fallback - make simple dump (using goto instead of \'if\', \'for\', etc)
-v, --verbose - verbose output (set --log-level to DEBUG)
-q, --quiet - turn off output (set --log-level to QUIET)
--log-level - set log level, values: QUIET, PROGRESS, ERROR, WARN, INFO, DEBUG, default: PROGRESS
--version - print jadx version
-h, --help - print this help
Example:
jadx -d out classes.dex
根据 HELP 信息,如果想要反编译 decompiler.jar 到 out 文件夹。
./build/jadx/bin/jadx -d ./out ~/Desktop/decompiler.jar
INFO - loading ...
INFO - processing ...
INFO - doneress: 1143 of 1217 (93%)
Fernflower
GitHub 地址:https://github.com/fesh0r/fernflower
Fernflower 和 Jadx 一样使用 Grade 进行依赖管理,可以自行克隆仓库打包运行。
➜ fernflower-master ./gradlew build
BUILD SUCCESSFUL in 32s
4 actionable tasks: 4 executed
➜ fernflower-master java -jar build/libs/fernflower.jar
Usage: java -jar fernflower.jar [-<option>=<value>]* [<source>]+ <destination>
Example: java -jar fernflower.jar -dgs=true c:mysource c:my.jar d:decompiled
➜ fernflower-master mkdir out
➜ fernflower-master java -jar build/libs/fernflower.jar ~/Desktop/decompiler.jar ./out
INFO: Decompiling class com/strobel/assembler/metadata/ArrayTypeLoader
INFO: ... done
INFO: Decompiling class com/strobel/assembler/metadata/ParameterDefinition
INFO: ... done
INFO: Decompiling class com/strobel/assembler/metadata/MethodHandle
...
➜ fernflower-master ll out
total 1288
-rw-r--r-- 1 darcy staff 595K 5 16 17:47 decompiler.jar
➜ fernflower-master
Fernflower 在反编译 JAR 同时,默认反编译的结果也是一个 JAR 包。Jad
反编译速度
到这里已经介绍了五款 Java 反编译工具了,那么在日常开发中我们应该使用哪一个呢?又或者在代码分析时我们又该选择哪一个呢?我想这两种情况的不同,使用时的关注点也是不同的。如果是日常使用,读读代码,我想应该是对可读性要求更高些,如果是大量的代码分析工作,那么可能反编译的速度和语法的支持上要求更高些。为了能有一个简单的参考数据,我使用 JMH 微基准测试工具分别对这五款反编译工具进行了简单的测试,下面是一些测试结果。
测试环境
环境变量描述处理器2.6 GHz 六核Intel Core i7内存16 GB 2667 MHz DDR4Java 版本JDK 14.0.2测试方式JMH 基准测试。待反编译 JAR 1procyon-compilertools-0.5.33.jar (1.5 MB)待反编译 JAR 2python2java4common-1.0.0-20180706.084921-1.jar (42 MB)
反编译 JAR 1:procyon-compilertools-0.5.33.jar (1.5 MB)
BenchmarkModeCntScoreUnitscfravgt106548.642 ± 363.502ms/opfernfloweravgt1012699.147 ± 1081.539ms/opjdcoreavgt105728.621 ± 310.645ms/opprocyonavgt1026776.125 ± 2651.081ms/opjadxavgt107059.354 ± 323.351ms/op
反编译 JAR 2: python2java4common-1.0.0-20180706.084921-1.jar (42 MB)
JAR 2 这个包是比较大的,是拿很多代码仓库合并到一起的,同时还有很多 Python 转 Java 生成的代码,理论上代码的复杂度会更高。
BenchmarkCntScoreCfr1413838.826msfernflower1246819.168msjdcore1Errorprocyon1487647.181msjadx1505600.231ms
语法支持和可读性
如果反编译后的代码需要自己看的话,那么可读性更好的代码更占优势,下面我写了一些代码,主要是 Java 8 及以下的代码语法和一些嵌套的流程控制,看看反编译后的效果如何。
package com.wdbyte.decompiler;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.IntStream;
import org.benf.cfr.reader.util.functors.UnaryFunction;
/**
* @author https://www.wdbyte.com
* @date 2021/05/16
*/
public class HardCode <A, B> {
public HardCode(A a, B b) { }
public static void test(int... args) { }
public static void main(String... args) {
test(1, 2, 3, 4, 5, 6);
}
int byteAnd0() {
int b = 1;
int x = 0;
do {
b = (byte)((b ^ x));
} while (b++ < 10);
return b;
}
private void a(Integer i) {
a(i);
b(i);
c(i);
}
private void b(int i) {
a(i);
b(i);
c(i);
}
private void c(double d) {
c(d);
d(d);
}
private void d(Double d) {
c(d);
d(d);
}
private void e(Short s) {
b(s);
c(s);
e(s);
f(s);
}
private void f(short s) {
b(s);
c(s);
e(s);
f(s);
}
void test1(String path) {
try {
int x = 3;
} catch (NullPointerException t) {
System.out.println(\"File Not found\");
if (path == null) { return; }
throw t;
} finally {
System.out.println(\"Fred\");
if (path == null) { throw new IllegalStateException(); }
}
}
private final List<Integer> stuff = new ArrayList<>();{
stuff.add(1);
stuff.add(2);
}
public static int plus(boolean t, int a, int b) {
int c = t ? a : b;
return c;
}
// Lambda
Integer lambdaInvoker(int arg, UnaryFunction<Integer, Integer> fn) {
return fn.invoke(arg);
}
// Lambda
public int testLambda() {
return lambdaInvoker(3, x -> x + 1);
// return 1;
}
// Lambda
public Integer testLambda(List<Integer> stuff, int y, boolean b) {
return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findFirst().orElse(null);
}
// stream
public static <Y extends Integer> void testStream(List<Y> list) {
IntStream s = list.stream()
.filter(x -> {
System.out.println(x);
return x.intValue() / 2 == 0;
})
.map(x -> (Integer)x+2)
.mapToInt(x -> x);
s.toArray();
}
// switch
public void testSwitch1(){
int i = 0;
switch(((Long)(i + 1L)) + \"\") {
case \"1\":
System.out.println(\"one\");
}
}
// switch
public void testSwitch2(String string){
switch (string) {
case \"apples\":
System.out.println(\"apples\");
break;
case \"pears\":
System.out.println(\"pears\");
break;
}
}
// switch
public static void testSwitch3(int x) {
while (true) {
if (x < 5) {
switch (\"test\") {
case \"okay\":
continue;
default:
continue;
}
}
System.out.println(\"wow x2!\");
}
}
}
此处本来贴出了所有工具的反编译结果,但是碍于文章长度和阅读体验,没有放出来,不过我在个人博客的发布上是有完整代码的,个人网站排版比较自由,可以使用 Tab 选项卡的方式展示。如果需要查看可以访问 https://www.wdbyte.com 进行查看。
Procyon
看到 Procyon 的反编译结果,还是比较吃惊的,在正常反编译的情况下,反编译后的代码基本上都是原汁原味。唯一一处反编译后和源码语法上有变化的地方,是一个集合的初始化操作略有不同。
// 源码
public HardCode(A a, B b) { }
private final List<Integer> stuff = new ArrayList<>();{
stuff.add(1);
stuff.add(2);
}
// Procyon 反编译
private final List<Integer> stuff;
public HardCode(final A a, final B b) {
(this.stuff = new ArrayList<Integer>()).add(1);
this.stuff.add(2);
}
而其他部分代码, 比如装箱拆箱,Switch 语法,Lambda 表达式,流式操作以及流程控制等,几乎完全一致,阅读没有障碍。
装箱拆箱操作反编译后完全一致,没有多余的类型转换代码。
// 源码
private void a(Integer i) {
a(i);
b(i);
c(i);
}
private void b(int i) {
a(i);
b(i);
c(i);
}
private void c(double d) {
c(d);
d(d);
}
private void d(Double d) {
c(d);
d(d);
}
private void e(Short s) {
b(s);
c(s);
e(s);
f(s);
}
private void f(short s) {
b(s);
c(s);
e(s);
f(s);
}
// Procyon 反编译
private void a(final Integer i) {
this.a(i);
this.b(i);
this.c(i);
}
private void b(final int i) {
this.a(i);
this.b(i);
this.c(i);
}
private void c(final double d) {
this.c(d);
this.d(d);
}
private void d(final Double d) {
this.c(d);
this.d(d);
}
private void e(final Short s) {
this.b(s);
this.c(s);
this.e(s);
this.f(s);
}
private void f(final short s) {
this.b(s);
this.c(s);
this.e(s);
this.f(s);
}
Switch 部分也是一致,流程控制部分也没有变化。
// 源码 switch
public void testSwitch1(){
int i = 0;
switch(((Long)(i + 1L)) + \"\") {
case \"1\":
System.out.println(\"one\");
}
}
public void testSwitch2(String string){
switch (string) {
case \"apples\":
System.out.println(\"apples\");
break;
case \"pears\":
System.out.println(\"pears\");
break;
}
}
public static void testSwitch3(int x) {
while (true) {
if (x < 5) {
switch (\"test\") {
case \"okay\":
continue;
default:
continue;
}
}
System.out.println(\"wow x2!\");
}
}
// Procyon 反编译
public void testSwitch1() {
final int i = 0;
final String string = (Object)(i + 1L) + \"\";
switch (string) {
case \"1\": {
System.out.println(\"one\");
break;
}
}
}
public void testSwitch2(final String string) {
switch (string) {
case \"apples\": {
System.out.println(\"apples\");
break;
}
case \"pears\": {
System.out.println(\"pears\");
break;
}
}
}
public static void testSwitch3(final int x) {
while (true) {
if (x < 5) {
final String s = \"test\";
switch (s) {
case \"okay\": {
continue;
}
default: {
continue;
}
}
}
else {
System.out.println(\"wow x2!\");
}
}
}
Lambda 表达式和流式操作完全一致。
// 源码
// Lambda
public Integer testLambda(List<Integer> stuff, int y, boolean b) {
return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findFirst().orElse(null);
}
// stream
public static <Y extends Integer> void testStream(List<Y> list) {
IntStream s = list.stream()
.filter(x -> {
System.out.println(x);
return x.intValue() / 2 == 0;
})
.map(x -> (Integer)x+2)
.mapToInt(x -> x);
s.toArray();
}
// Procyon 反编译
public Integer testLambda(final List<Integer> stuff, final int y, final boolean b) {
return stuff.stream().filter(b ? (x -> x > y) : (x -> x < 3)).findFirst().orElse(null);
}
public static <Y extends Integer> void testStream(final List<Y> list) {
final IntStream s = list.stream().filter(x -> {
System.out.println(x);
return x / 2 == 0;
}).map(x -> x + 2).mapToInt(x -> x);
s.toArray();
}
流程控制,反编译后发现丢失了无异议的代码部分,阅读来说并无障碍。
// 源码
void test1(String path) {
try {
int x = 3;
} catch (NullPointerException t) {
System.out.println(\"File Not found\");
if (path == null) { return; }
throw t;
} finally {
System.out.println(\"Fred\");
if (path == null) { throw new IllegalStateException(); }
}
}
// Procyon 反编译
void test1(final String path) {
try {}
catch (NullPointerException t) {
System.out.println(\"File Not found\");
if (path == null) {
return;
}
throw t;
}
finally {
System.out.println(\"Fred\");
if (path == null) {
throw new IllegalStateException();
}
}
}
鉴于代码篇幅,下面几种的反编译结果的对比只会列出不同之处,相同之处会直接跳过。
CFR
CFR 的反编译结果多出了类型转换部分,个人来看没有 Procyon 那么原汁原味,不过也算是十分优秀,测试案例中唯一不满意的地方是对 while continue 的处理。
// CFR 反编译结果
// 装箱拆箱
private void e(Short s) {
this.b(s.shortValue()); // 装箱拆箱多出了类型转换部分。
this.c(s.shortValue()); // 装箱拆箱多出了类型转换部分。
this.e(s);
this.f(s);
}
// 流程控制
void test1(String path) {
try {
int n = 3;// 流程控制反编译结果十分满意,原汁原味,甚至此处的无意思代码都保留了。
}
catch (NullPointerException t) {
System.out.println(\"File Not found\");
if (path == null) {
return;
}
throw t;
}
finally {
System.out.println(\"Fred\");
if (path == null) {
throw new IllegalStateException();
}
}
}
// Lambda 和 Stream 操作完全一致,不提。
// switch 处,反编译后功能一致,但是流程控制有所更改。
public static void testSwitch3(int x) {
block6: while (true) { // 源码中只有 while(true),反编译后多了 block6
if (x < 5) {
switch (\"test\") {
case \"okay\": {
continue block6; // 多了 block6
}
}
continue;
}
System.out.println(\"wow x2!\");
}
}
JD-Core
JD-Core 和 CFR 一样,对于装箱拆箱操作,反编译后不再一致,多了类型转换部分,而且自动优化了数据类型。个人感觉,如果是反编译后自己阅读,通篇的数据类型的转换优化影响还是挺大的。
// JD-Core 反编译
private void d(Double d) {
c(d.doubleValue()); // 新增了数据类型转换
d(d);
}
private void e(Short s) {
b(s.shortValue()); // 新增了数据类型转换
c(s.shortValue()); // 新增了数据类型转换
e(s);
f(s.shortValue()); // 新增了数据类型转换
}
private void f(short s) {
b(s);
c(s);
e(Short.valueOf(s)); // 新增了数据类型转换
f(s);
}
// Stream 操作中,也自动优化了数据类型转换,阅读起来比较累。
public static <Y extends Integer> void testStream(List<Y> list) {
IntStream s = list.stream().filter(x -> {
System.out.println(x);
return (x.intValue() / 2 == 0);
}).map(x -> Integer.valueOf(x.intValue() + 2)).mapToInt(x -> x.intValue());
s.toArray();
}
Jadx
首先 Jadx 在反编译测试代码时,报出了错误,反编译的结果里也有提示不能反编 Lambda 和 Stream 操作,反编译结果中变量名称杂乱无章,流程控制几乎阵亡,如果你想反编译后生物肉眼阅读,Jadx 肯定不是一个好选择。
// Jadx 反编译
private void e(Short s) {
b(s.shortValue());// 新增了数据类型转换
c((double) s.shortValue());// 新增了数据类型转换
e(s);
f(s.shortValue());// 新增了数据类型转换
}
private void f(short s) {
b(s);
c((double) s);// 新增了数据类型转换
e(Short.valueOf(s));// 新增了数据类型转换
f(s);
}
public int testLambda() { // testLambda 反编译失败
/*
r2 = this;
r0 = 3
r1 = move-result
java.lang.Integer r0 = r2.lambdaInvoker(r0, r1)
int r0 = r0.intValue()
return r0
*/
throw new UnsupportedOperationException(\"Method not decompiled: com.wdbyte.decompiler.HardCode.testLambda():int\");
}
// Stream 反编译失败
public static <Y extends java.lang.Integer> void testStream(java.util.List<Y> r3) {
/*
java.util.stream.Stream r1 = r3.stream()
r2 = move-result
java.util.stream.Stream r1 = r1.filter(r2)
r2 = move-result
java.util.stream.Stream r1 = r1.map(r2)
r2 = move-result
java.util.stream.IntStream r0 = r1.mapToInt(r2)
r0.toArray()
return
*/
throw new UnsupportedOperationException(\"Method not decompiled: com.wdbyte.decompiler.HardCode.testStream(java.util.List):void\");
}
public void testSwitch2(String string) { // switch 操作无法正常阅读,和源码出入较大。
char c = 65535;
switch (string.hashCode()) {
case -1411061671:
if (string.equals(\"apples\")) {
c = 0;
break;
}
break;
case 106540109:
if (string.equals(\"pears\")) {
c = 1;
break;
}
break;
}
switch (c) {
case 0:
System.out.println(\"apples\");
return;
case 1:
System.out.println(\"pears\");
return;
default:
return;
}
}
Fernflower
Fernflower 的反编译结果总体上还是不错的,不过也有不足,它对变量名称的指定,以及 Switch 字符串时的反编译结果不够理想。
//反编译后变量命名不利于阅读,有很多 var 变量
int byteAnd0() {
int b = 1;
byte x = 0;
byte var10000;
do {
int b = (byte)(b ^ x);
var10000 = b;
b = b + 1;
} while(var10000 < 10);
return b;
}
// switch 反编译结果使用了hashCode
public static void testSwitch3(int x) {
while(true) {
if (x < 5) {
String var1 = \"test\";
byte var2 = -1;
switch(var1.hashCode()) {
case 3412756:
if (var1.equals(\"okay\")) {
var2 = 0;
}
default:
switch(var2) {
case 0:
}
}
} else {
System.out.println(\"wow x2!\");
}
}
}
总结
五种反编译工具比较下来,结合反编译速度和代码可读性测试,看起来 CFR 工具胜出,Procyon 紧随其后。CFR 在速度上不落下风,在反编译的代码可读性上,是最好的,主要体现在反编译后的变量命名、装箱拆箱、类型转换,流程控制上,以及对 Lambda 表达式、Stream 流式操作和 Switch 的语法支持上,都非常优秀。根据 CFR 官方介绍,已经支持到 Java 14 语法,而且截止写这篇测试文章时,CFR 最新提交代码时间是在 11 小时之前,更新速度很快。
文中部分代码已经上传 GitHub 的 niumoo/lab-notes 仓库 的 java-decompiler 目录。
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容,请发送邮件至 55@qq.com 举报,一经查实,本站将立刻删除。转转请注明出处:https://www.szhjjp.com/n/33647.html