Java代码混淆

http://blog.csdn.net/intimater/article/details/6302031

下面一段文字摘自《Java 手机/PDA 程序设计入门》一书,可以做为混淆器性能的大致观点:
 
笔者没用过DashO,所以无法对其作出个人评价。所以现在仅说明笔者曾用过的产品。以笔者的个人观点,如果就混淆的程度来说,ZKM最好,JAX中等,RetroGuard和ProGuard最差,一分钱一分货,这是千古不变的道理。如果就功能性而言,ZKM和JAX都不错,不过,JAX是IBM所开发的产品,因此也继承了大部分IBM产品的最大特色,就是“功能超强,可是不易使用”,可能光是要看完JAX的设定文件就是一个很大的问题。
 
下面分别介绍几种具有代表性的混淆器,对它们的产品性能进行对比。我们使用不同混淆器对同一段java代码进行混淆,分别列出混淆后代码反编译的结果,并给出使用的一些直接体会。原始java代码:
[java] view plain copy
  1. public class SimpleBean implements Serializable {  
  2.    private String[] name = {"name0","name1","name2","name3"};  
  3.    private List myList = null;  
  4.      
  5.    public void SimpleBean() {  
  6.      myList = new ArrayList(4);  
  7.    }  
  8.    public void init_public() {  
  9.     myList.add("name");  
  10.     for(int i= 1; i < 4; i++){  
  11.      init_private(i);  
  12.     }  
  13.    }     
  14.    private void init_private(int j) {    
  15.        myList.add(name[j]);  
  16.    }    
  17.    private void writeObject(java.io.ObjectOutputStream out)  
  18.        throws IOException {  
  19.    }  
  20. }  
一、ProGuard 4.5.1
ProGuard是一款免费的Java类文件压缩器、优化器和混淆器。它能发现并删除无用类、字段(field)、方法和属性值(attribute)。它也能优化字节码并删除无用的指令。最后,它使用简单无意义的名字来重命名你的类名、字段名和方法名。经过以上操作的jar文件 会变得更小,并很难进行逆向工程。eclipse已经把Proguard集成在一起了。它支持脚本控制,可以使用GUI界面,字符串不加密,支持 J2ME。
类似功能的开源混淆器:RetroGuard yGuard(RetroGuard的一个升级版本) JODE 
Jad反编译混淆后class得到的代码:
   
   
   
   
[java] view plain copy
  1. public class SimpleBean  
  2.     implements Serializable  
  3. {  
  4.   
  5.     public SimpleBean()  
  6.     {  
  7.         a_java_util_List_fld = null;  
  8.     }  
  9.   
  10.     public void SimpleBean()  
  11.     {  
  12.         a_java_util_List_fld = new ArrayList(4);  
  13.     }  
  14.   
  15.     public void init_public()  
  16.     {  
  17.         a_java_util_List_fld.add("name");  
  18.         for(int i = 1; i < 4; i++)  
  19.         {  
  20.             int j = i;  
  21.             SimpleBean simplebean = this;  
  22.             a_java_util_List_fld.add(simplebean.a_java_lang_String_array1d_fld[j]);  
  23.         }  
  24.   
  25.     }  
  26.   
  27.     private String a_java_lang_String_array1d_fld[] = {  
  28.         "name0""name1""name2""name3"  
  29.     };  
  30.     private List a_java_util_List_fld;  
  31. }  
优点:
1、对内部private方法的调用进行了内联,但基本达不到混淆效果;
2、使用文档详尽,混淆选项配置文件的编写示例多;
3、混淆选项粒度较细,可以使用GUI界面,支持本地方法的保护等;
4、支持j2me,可以集成到Eclipse;
5、开源。
缺点:
1、符号混淆的命名具有提示性,字符串未加密,没有其它的混淆措施;
2、混淆主要针对Xlet、Midlet等应用,混淆库文件时配置文件将会很复杂。
 
二、Jocky
Jocky是金蝶中间件技术领袖袁红岗先生的个人作品(旧有名称JOC)。原本是方便Apusic 应用服务器的开发,现在开放出来,供大家自由使用。Jocky混淆编译器是在Sun JDK中提供的Java编译器(javac)的基础上完成的,修改了其中的代码生成过程,对编译器生成的中间代码进行混淆,最后再生成class文件,这样编译和混淆只需要一个步骤就可以完成。也就是说,它是直接从源码上做文章,这是Jocky与其它混淆编译器最大的不同之处。另外可以在源程序中插入符号保留指令来控制哪些符号需要保留,将混淆过程与开发过程融合在一起,不需要单独的混淆选项配置文件。Jocky的上述特点较适合于java类库的混淆。
Jad反编译混淆后class得到的代码:
   
   
   
   
[java] view plain copy
  1. public class SimpleBean  
  2.     implements Serializable  
  3. {  
  4.   
  5.     public SimpleBean()  
  6.     {  
  7.         this;  
  8.         String as[] = new String[4];  
  9.         as;  
  10.         as[0] = "name0";  
  11.         as;  
  12.         JVM INSTR swap ;  
  13.         1;  
  14.         "name1";  
  15.         JVM INSTR aastore ;  
  16.         JVM INSTR dup ;  
  17.         JVM INSTR swap ;  
  18.         2;  
  19.         "name2";  
  20.         JVM INSTR aastore ;  
  21.         JVM INSTR dup ;  
  22.         JVM INSTR swap ;  
  23.         3;  
  24.         "name3";  
  25.         JVM INSTR aastore ;  
  26.         _$2;  
  27.         _$1 = null;  
  28.         return;  
  29.     }  
  30.   
  31.     public void SimpleBean()  
  32.     {  
  33.         this;  
  34.         JVM INSTR new #9   <Class ArrayList>;  
  35.         JVM INSTR dup ;  
  36.         JVM INSTR swap ;  
  37.         4;  
  38.         ArrayList();  
  39.         _$1;  
  40.     }  
  41.   
  42.     public void init_public()  
  43.     {  
  44.         _$1.add("name");  
  45.         for(int i = 1; i < 4; i++)  
  46.             _$1(i);  
  47.   
  48.     }  
  49.   
  50.     private void _$1(int i)  
  51.     {  
  52.         _$1.add(_$2[i]);  
  53.     }  
  54.   
  55.     private void writeObject(ObjectOutputStream objectoutputstream)  
  56.         throws IOException  
  57.     {  
  58.     }  
  59.   
  60.     private String _$2[];  
  61.     private List _$1;  
  62. }  
优点:
1、除符号混淆外增加了数据混淆(字符数组初始化);
2、有一些语句反编译只能得到字节码指令;
3、在Sun JDK中提供的Java编译器(javac)的基础上完成,编译和混淆一体完成,不需要先生成class文件再混淆;
4、提供了Eclipse的插件,能够直接在Eclipse中使用Jocky。
缺点:
1、混淆选项粒度较粗,使用中可能要在具体代码中添加@preserve指令来实现,工作量大;
2、没有控制流混淆。
 
三、Allatori 3.1_demo
Allatori属于第二代混淆器,具有全方位保护你的知识产权的能力。Allatori具有以下几种保护方式:命名混淆,流混淆,调试信息混淆,字符串编码,以及水印技术。对于教育和非商业项目来说这个混淆器是免费的。2.1版本支持war和ear文件格式,并且允许对需要混淆代码的应用程序添加有效日期。
Jad反编译混淆后class得到的代码:
   
   
   
   
[java] view plain copy
  1. public class SimpleBean  
  2.     implements Serializable  
  3. {  
  4.   
  5.     public void init_public()  
  6.     {  
  7.         d.add(c.k("{u{0"));  
  8.         int i = 1;  
  9.           goto _L1  
  10. _L3:  
  11.         H(i);  
  12.         ++i;  
  13. _L1:  
  14.         4;  
  15.         JVM INSTR icmplt 21;  
  16.            goto _L2 _L3  
  17. _L2:  
  18.     }  
  19.   
  20.     public void SimpleBean()  
  21.     {  
  22.         d = new ArrayList(4);  
  23.     }  
  24.   
  25.     private void H(int a)  
  26.     {  
  27.         d.add(c[a]);  
  28.     }  
  29.   
  30.     public SimpleBean()  
  31.     {  
  32.         d = null;  
  33.     }  
  34.   
  35.     private void H(ObjectOutputStream objectoutputstream)  
  36.         throws IOException  
  37.     {  
  38.     }  
  39.   
  40.     private String c[] = {  
  41.         c.k("\177q\177te"), c.k("\177q\177td"), c.k("\177q\177tg"), c.k("\177q\177tf")  
  42.     };  
  43.     private List d;  
  44. }  
注:c.k是为进行字符串加密额外生成的类c的静态方法。
优点:
1、设计考虑了库文件混淆的使用场景;
2、使用文档详尽,混淆选项配置文件的编写示例多;
3、除符号混淆外,还使用了两种高级的混淆手段:控制混淆(改写了for循环)和字符串加密(String数组初始化);
4、混淆选项粒度较细,支持本地方法的保护等;
5、支持水印技术,允许对需要混淆的代码添加有效日期;
6、支持j2me;
缺点:
1、商业软件(价格附后),对教育和非商业用途免费(网站链接是http://www.allatori.com/price.html)。
附:价格情况
SINGLE DEVELOPER LICENSE
1 license              $290
2-5 licenses           $260
6-10 licenses          $230
11+ licenses           $200
SITE LICENSE           $3750
BUSINESS LICENSE       $4850
ANNUAL SUPPORT UPDATE  $45
 
四、Zelix KlassMaster(ZKM)
Zelix KlassMaster是一个来自Zelix Pty Ltd的商业混淆器。官方文档中关于它的混淆特性的介绍很少。它的保护功能非常强大,可以进行符号混淆和控制混淆,支持字符串的复杂加密保护,堆栈混乱,支持异常重构,支持增量混淆,支持J2ME。Zelix KlassMaster提供试用版本,可以到http://www.zelix.com下载。
 
五、DashO Pro
DashO Pro 是由Preemptive Solutions开发的商业化的混淆器. 免费的评估版可以到http://www.preemptive.com下载。DashO Pro代码保护能力强大易用,方便灵活(商业软件,非开源)。该Java混淆器是Sun的选择,对于企业级应用,作为其Java开发包的一部分,Sun微系统使用DashO Pro来混淆其加密库。DashO Pro能够对ID进行重新命名,使之成为毫无意义的字符;混淆元数据;改变控制流等,所有这些操作使得java代码被混淆,难于理解。产品特点包括:
领先的Java源码保护机制;
运用专利Overload-Induction技术对包/类/方法/域进行重命名;
高级的流程控制混淆机制;
字符串加密技术;
防止反编译器生成有用的输出;
水印软件;
提高Java源码效率;
不采用类/方法/域,全面移除常数存储库;
类/方法级别的优化,以提高JIT效果;
动态加载检测到的类;
全面高效的Java源码的拓展和部署;
支持所有的JDK版本 (JSE, J2EE, J2ME, etc)包括1.5;
自动堆栈跟踪转换;
在指定路径打包或者java jars;
支持任何打包类型的Java内容——程序、库、applets程序、小服务器程序、EJB等;
支持基于J2ME CLDC的架构,包括MIDP和 iAppli;
支持CLDC预检验库中的类;
可以从指定路径、Zip压缩包或者jars中提取;
支持导出100%纯粹的Java,并提供验证;
命令行接口适合集成到构建环境内;
基于XML的配置文件,易于使用;
全面准确的PDF格式用户指南。


你可能感兴趣的:(Java代码混淆)