Jocky
Java Obfuscate Compiler Kit for You
一、前言
1.1 什么是Jocky?
我们知道，
Java是一种跨平台的编程语言，其源码(.
java文件)被编译成与平台无关的字节码(.
class文件)，然后在运行期动态链接。这样，编译后的类文件
中将包含有符号表，从而使得
Java程序很容易被反编译。相信每一个
Java开发人员，都曾经用过诸如Jad之类的反编译器，对
Java的
class 文件进行反编译，从而观察程序的结构与实现细节。如此一来，对于那些需要严格进行知识产权保护的
Java应用，如何有效的保护客户的商业投资，是开发人员经常需要面对的问题。
于是就出现了
Java混淆编译器，它的作用是打乱
class文件
中的符号信息，从而使反向
工程变得非常困难。
Jocky就是这样一款优秀的
Java混淆编译器。
1.2 为什么需要Jocky?
目前业界有不少商业的甚或是开源的混淆编译器，但它们普遍
存在一些这样或者那样的问题。一般而言，现有的混淆器都是对编译好的
class文件进行混淆，这样就需要编译和混淆两个步骤。而事实上，并不是所有的符号都需要混淆。如果你开发的是一个类库，或者某些类需要动态装载，那些公共API(或者说:那些被publish出来的API)就必须保留符号不变，只有这样，别人才能使用你的类库。现有的混淆器提供了GUI或脚本的方式来对那些需要保留的符号名称进行配置，但如果程序较大时，配置工作将变得很复杂，而程序一旦修改，配置工作又要重新进行。某些混淆器能够调整字节码的顺序，使反编译更加困难，但笔者经历过混淆之后的程序运行出错的情况。
而Jocky与其它混淆编译器最大的不同之处在于:它是直接从源码上做文章，也就是说编译过程本身就是一个混淆过程。
1.3 Jocky是如何工作的?
Jocky混淆编译器是在Sun JDK
中提供的
Java编译器(
javac)的基础上完成的，修改了其
中的代码生成过程，对编译器生成的
中间代码进行混淆，最后再生成
class文件，这样编译和混淆只需要一个步骤就可以完成。另外可以在源程序
中插入 符号保留指令 来控制哪些符号需要保留，将混淆过程与开发过程融合在一起，不需要单独的配置。
1.4 Jocky的作用
1.4.1代码混淆
如前文所述，混淆编译是Jocky的首要用途。我们举一个最简单的例子，下面的SimpleBean是未经混淆的
class文件通过Jad反编译以后获得的源文件:
public
class SimpleBean implements Serializable {
private String name = \"myname\";
private List myList = null;
public void SimpleBean() {
myList = new ArrayList(10);
}
public void foo1() {
myList.add(\"name\");
}
private void foo2() {
}
private void writeObject(
java.io.ObjectOutputStream out)
throws IOException {
}
}
<未混淆的类文件反编译后的效果>
下面是经Jocky混淆过的类文件，通过Jad反编译后产生的源文件:
public
class SimpleBean implements Serializable {
private String _$2;
private List _$1;
public SimpleBean() {
_$2 = \"myname\";
this;
JVM INSTR new #4 <
Class ArrayList>;
JVM INSTR dup ;
JVM INSTR swap ;
10;
ArrayList();
_$1;
}
public void foo1() {
_$1.add(\"name\");
}
private void _$1() {
}
private void writeObject(ObjectOutputStream objectoutputstream){
throws IOException {
}
}
<Jocky混淆过的类文件反编译的效果>
1.4.2 支持将JDK 5.0的语法编译成能够在JDK 1.4上运行的类文件
JDK 5.0在语法层面上有许多新增特色，能够为简化应用的开发带来一些便利。譬如Generics、Enhanced for Loop以及 Autoboxing/Unboxing等。但另人遗憾的是，倘若利用这些新的语法开发应用，就意味着不能够在JDK 1.4上运行，而JDK 1.4毕竟是目前最为普及的VM版本。幸运是，Jocky的另一个特色就是:通过参数配置，能够把用JDK 5.0语法编写的应用编译成JDK 1.4上的类文件版本。我们可以把经过 Jocky编译的类文件以UltraEdit
打开，可以发现在第8个字节上(类文件的major version)的数值是0x30，即十进制的48，这是JDK 1.4所能够理解的类文件版本(JDK 5.0默认编译的类文件版本是49)。前提是:应用
中不能够使用JDK 1.4
中所没有的一些API。
二、Jocky的用法
2.1 常规用法
使用Jocky非常简单，获得jocky.jar以后，只需要运行
java -jar jocky.jar就可以启动Jocky混淆编译器，jocky的命令行参数和
javac完全相同，但增加了一个新的参数-scramble，它的用法如下：
-scramble 混淆所有package private或private符号
-scrambleall 混淆所有符号
-scramble:<level> 混淆相应级别的符号
其
中<level>指定混淆级别，可以是以下几种级别：
-scramble:none 不进行混淆
-scramble:private 对所有private访问级别的元素进行混淆
-scramble:package 对所有private或package private元素进行混淆
-scramble:protected 对所有private, package private, protected元素进行混淆
-scramble:public 对所有的元素都进行混淆
-scramble:all 相当于-scramble:public
如果使用-scramble不带级别参数，则相当于-scramble:package
2.2 Jocky for Ant
近年来，Ant
已经成为
Java应用开发
中打包工具的事实上的标准。在应用的开发过程
中，我们往往都会有一个Ant脚本，通过该脚本，能够对应用进行编译、打包、发布等一系列过程。因此，Jocky的最佳切入点便是对Ant的支持。
在Ant
中使用Jocky非常简单：
1. 将lib\\jocky-ant.jar copy至ANT_HOME\\lib目录下。
2. 在ant脚本
中加入这样一行代码，以引入Jocky Task
<taskdef resource=\"jockytasks/\">
3. 设置Jocky的一些基本属性，包括: jocky.jar包的位置，以及混淆级别，如下所示:
<jocky jar=\" F:\\Works2\\Jocky\\jocky1.0\\lib\\jocky.jar\" enable=\"true\" level=\"private/\">
4. 当设置jocky的enable属性为true时，此时，Ant脚本
中的
javac编译命令，便会被自动替换成Jocky编译器；当设置enable属性为false时，
javac编译命令将恢复成正常设置，示例脚本如下:
<project name=\"jocky\" default=\"build\">
<!-- 引入Jocky Ant Task，要确保jocky-ant.jar位于ANT_HOME\\lib目录下 -->
<taskdef resource=\"jockytasks\"> </taskdef>
<target name=\"build\">
<!-- 设置jocky.jar的位置以及混淆级别，当enable为true时，
javac task将被自动替换成Jocky混淆编译器 -->
<jocky jar=\" F:\\Works2\\Jocky\\jocky1.0\\lib\\jocky.jar\" enable=\" true\" level=\" private\"> </jocky>
<!-- 下面的编译，将使用Jocky混淆编译器 -->
<
javac destdir=\"bin2\" debug=\"on\" source=\"1.5\" target=\"1.4\">
<src path=\"src\"></src>
</
javac>
<!-- 当enable为false时，
javac task将被恢复成正常设置, Jocky编译器不再起作用 -->
<jocky enable=\"false\"></jocky>
<!-- 下面的编译，将使用正常的
Javac编译器 -->
<
javac destdir=\"bin3\" debug=\"on\" target=\"1.4\">
<src path=\"src\"></src>
</
javac>
</target>
</project>
<Jocky的Ant脚本示例>
注意: Jocky for Ant在Ant 1.6.5上开发，推荐使用该版本。
2.3 Jocky for
Eclipse
Jocky提供了
Eclipse的插件，从而能够直接在
Eclipse中使用Jocky。
1. Jocky插件的安装：
将Jocky插件安装至
Eclipse中非常简单，只需要将
eclipse/plugins/org.apusic.jocky_1.0.0目录 copy 至
Eclipse的 plugins目录即可。或者在
Eclipse/links文件夹
中，通过link方式指定Jocky的插件目录。
2. 在
Eclipse中使用Jocky：
在
Eclipse中使用Jocky也非常简单，任何一个
Java工程，选
中工程通过右键菜单，都可以出现Jocky的快捷菜单:
<Jocky在
Eclipse中的右键菜单>
<Jocky在
Eclipse中的属性设置>
事实上，在
Eclipse中使用Jocky时，Jocky也是首先针对所选
工程生成Ant的Build文件（默认名称jocky_build.xml），然后再通过Ant完成混淆编译。
以下是Jocky在
Eclipse中自动生成的Ant Build 文件示例：
<project basedir=\".\" default=\"build\" name=\"jocky.example.jocky\">
<property name=\"jocky.jar\" value=\"f:\\
EclipseWTP1.0.8\\workspace_jdk5_apusicstudio\\org.apusic.jocky\\jocky.jar\"></property>
<property name=\"jocky.output.dir\" value=\"jocky\"></property>
<property name=\"jocky.scramble.level\" value=\"package\"></property>
<property name=\"target\" value=\"1.4\"></property>
<path id=\"project.
classpath\">
<pathelement location=\"bin\"></pathelement>
</path>
<target name=\"init\">
<jocky jar=\"${jocky.jar}\" level=\"${jocky.scramble.level}\"></jocky>
<mkdir dir=\"${jocky.output.dir}\"></mkdir>
<mkdir dir=\"${jocky.output.dir}/bin\"></mkdir>
</target>
<target name=\"clean\">
<delete dir=\"${jocky.output.dir}/bin\"></delete>
<delete dir=\"${jocky.output.dir}\"></delete>
</target>
<target depends=\"init\" name=\"build\">
<echo message=\"${ant.project.name}: ${ant.
file}\"></echo>
<jocky enable=\"true\"></jocky>
<
javac destdir=\"${jocky.output.dir}/bin\" target=\"${target}\">
<src path=\"src\"></src>
<
classpath refid=\"project.
classpath\"></
classpath>
</
javac>
</target>
</project>
<Jocky在
Eclipse中自动生成的Ant脚本示例>
注1：只支持
Eclipse 3.1.1及以上版本。
注2：如果在
Eclipse中找不到Jocky插件，请删除
Eclipse安装目录/configuration/org.
eclipse.update 文件夹 (Maybe an
eclipse bug?)。
2.4 如何使用符号保留指令
除了在命令行用 -scramble 参数控制符号混淆级别外，还可以在源代码
中使用符号保留指令来控制那些符号需要保留。符号保留指令是一个
Java文档注释指令，可以插入在类和类成员的文档注释
中，例如：
/**
* This
class should preserve.
* @preserve
*/
public
class Foo {
/**
* You can specify which field should be preserved.
* @preserve
*/
private int x;
/**
* This field is not preserved.
*/
private int y;
/**
* You can also preserve methods.
* @preserve
*/
public void hello() {}
/**
* This method is not preserved.
*/
private void collect() {}
}
<使用preserved指令的示例>
如果没有@preserve指令，则根据混淆级别及成员的访问级别来确定符号是否保留。
对于类的符号保留指令可以附带一个保留级别参数，来控制类成员的符号保留，包括：
@preserve 仅对类名进行保留，类成员的保留根据-scramble命令行参数决定
@preserve public 保留所有public成员
@preserve protected 保留所有public和protected成员
@preserve package 保留所有public, protected, package private成员
@preserve private 保留所有成员
@preserve all 相当于@preserve private
事实上，即便不加@preserve指令，Jocky对
Java语言特有的一些private级别的方法不进行混淆，譬如，在序列化时有特殊作用的writeObject及readObject方法等。但笔者强烈建议: 针对这些有特殊含义不能够被混淆的 private级别的方法或者字段，请以@preserve指令予以保护。
注1：建议通过IDE的
JavaDoc设置，来辅助@preserve指令的书写。
三、Jocky的限制
正如前文所说，Jocky是基于源代码的混淆编译器，因此，Jocky不支持分别编译，必须对所有的源文件同时进行混淆编译。但事实上，倘若混淆级别控制在private级别上，该限制便不复
存在。
1387
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
