obfuscated.rar   2.6 KB 这是混淆后的类文件, 内含原始代码. 执行方式 java –jar hello.jar 即可.

众所周知, Java的最大缺陷就是编译后的代码很容易被反编译, 从而使辛辛苦苦交付给客户的项目或者是客户端软件, 例如RCP/IM客户端, 很容易的就被人破解掉. 保护代码的方式, 相对来说要比C/C++困难的多, 而且加密/保护后的类文件运行时比较容易出现一些问题. 最常见的方式就是混淆, 例如国产的Jocky, 国外的各种Guard等, 不过, JVM 实际上也支持数字格式的类名, 甚至是以空格命名的包名和变量名, 唯一的约束只是在编译时所产生的.

混淆效果演示:

原始程序:

代码1

import util.Tools;

public class Hello {
    private int a = 1;
    private int b = 2;

    public int result() {
        return Tools.add(a, b);
    }
    /**
     * 日期: 2010-7-1
     * @param args
     */
    public static void main(String[] args) {
        System.out.println("simple test:" + new Hello().result());
    }

}

代码2

package util;

public class Tools {
    public static int add(int a, int b) {
        System.out.println("Call for Tools.add()");
        return a + b;
    }
}

混淆后的 hello.jar

反编译后的代码(基本上无法编译欢迎回去, 变量名,方法名和类名都是数字, 可正常执行)

import java.io.PrintStream;

public class 0
{
  private int 0 = 1;
  private int 1 = 2;

  public int 0()
  {
    return 0.0.0(this.0, this.1);
  }

  public static void main(String[] paramArrayOfString)
  {
    System.out.println("simple test:" + new 0().0());
  }
}

package 0;

import java.io.PrintStream;

public class 0
{
  public static int 0(int paramInt1, int paramInt2)
  {
    System.out.println("Call for Tools.add()");
    return paramInt1 + paramInt2;
  }
}

混淆后的hello1.jar

反编译后的代码(包名和变量名为空格或者字符串,增加还原难度, 可正常执行)

import java.io.PrintStream;

public class 0
{
  private int   = 1;
  private int  "wlstat" = 2;

  public int  ()
  {
    return  .0. (this. , this. "wlstat");
  }

  public static void main(String[] paramArrayOfString)
  {
    System.out.println("simple test:" + new 0(). ());
  }
}

package  ;

import java.io.PrintStream;

public class 0
{
  public static int  (int paramInt1, int paramInt2)
  {
    System.out.println("Call for Tools.add()");
    return paramInt1 + paramInt2;
  }
}

此文仅为展示一种可能性, 不推荐在项目中使用.

Jocky http://www.operamasks.org/ProjectDetails.jsp?proId=9c89b9f7010d1000e000007cca67bf51

Jocky是金蝶中间件技术领袖袁红岗先生的个人作品（旧有名称JOC)。原本是方便Apusic 应用服务器的开发，现在开放出来，供大家自由使用 ... Jocky提供了对IDE Eclipse的支持，同时，也支持在Ant中使用（事实上，在Eclipse中，也是先生成一个ant文件，然后再编译).

是挺好用, 编译后的代码大部分反编译出来只有 JVM 指令! 的确是保护系统核心的利器! 支持 JDK 1.5. 可是 Jocky 竟然不开源... 领袖啊!

以下是官方IDE(Apusic IDE)中的详细说明:

Jocky

Java Obfuscate Compiler Kit  for You

一、前言

1.1 什么是Jocky?

1.2 为什么需要Jocky?

1.3 Jocky是如何工作的?

1.4 Jocky的作用

1.4.1代码混淆

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上运行的类文件

二、Jocky的用法

2.1 常规用法

    -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

<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中的右键菜单>

<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 如何使用符号保留指令

/**
* 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

三、Jocky的限制